1275 lines
71 KiB
C#
1275 lines
71 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Text.RegularExpressions;
|
||
using BeWo.Data.Access;
|
||
using BeWo.Data.Entities;
|
||
using BeWo.Service.DCEntityMapper;
|
||
using BeWo.Service.ServiceImplementations;
|
||
using BS.Shared;
|
||
using BS.Shared.Core;
|
||
using BS.Shared.DataContracts;
|
||
using BS.Shared.DataContracts.Compact;
|
||
using BS.Shared.Extensions;
|
||
|
||
namespace BeWo.Service.Plugins
|
||
{
|
||
public class VacationService : AbstractIDSpecificDefaultClass<VacationService>
|
||
{
|
||
private List<FeiertagDC> databaseFeiertage = null;
|
||
private List<DateTime> _Feiertage { get;set; }
|
||
private string _Bundesland = "NRW";
|
||
|
||
public virtual string Bundesland
|
||
{
|
||
get
|
||
{
|
||
return _Bundesland;
|
||
}
|
||
set
|
||
{
|
||
_Bundesland = value;
|
||
}
|
||
}
|
||
|
||
public virtual bool IstFeiertag(DateTime start)
|
||
{
|
||
List<DateTime> feiertage = GetFeiertage(start.Year);
|
||
|
||
foreach (var ft in feiertage)
|
||
{
|
||
if (start.Date == ft)
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
public virtual List<DateTime> GetFeiertage(int year)
|
||
{
|
||
var list = GetFeiertage(year, Bundesland);
|
||
|
||
return list.Select(f => f.Datum).ToList();
|
||
}
|
||
|
||
public virtual FeiertagDC GetFeiertag(DateTime start)
|
||
{
|
||
var feiertage = GetFeiertage(start.Year, Bundesland);
|
||
|
||
foreach (var ft in feiertage)
|
||
{
|
||
if (start == ft.Datum)
|
||
return ft;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public virtual FerienDC GetFerien(DateTime start, String bundesland)
|
||
{
|
||
var ferienList = GetFerien(bundesland);
|
||
|
||
foreach (var ferien in ferienList)
|
||
{
|
||
if (start >= ferien.Start && start <= ferien.Ende)
|
||
return ferien;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public virtual List<FeiertagDC> GetFeiertage(int year, String bundesland)
|
||
{
|
||
List<FeiertagDC> list = new List<FeiertagDC>();
|
||
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 1, 1), Name = "Neujahr" });
|
||
//list.Add(new DateTime(year, 1, 6)); // , "Heilige Drei Könige"));
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 5, 1), Name = "Tag der Arbeit" });
|
||
//list.Add(new DateTime(year, 8, 15)); // , "Mariä Himmelfahrt"));
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 10, 3), Name = "Tag der Deutschen Einheit" });
|
||
//list.Add(new DateTime(year, 10, 31)); // , "Reformationstag"));
|
||
|
||
if (bundesland.ToLower() == "bayern")
|
||
{
|
||
//list.Add(new FeiertagDC { Datum = new DateTime(year, 8, 15), Name = "Mariä Himmelfahrt" });
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 1, 6), Name = "Heilige Drei Könige" });
|
||
}
|
||
|
||
if (bundesland.ToLower() == "nrw" || bundesland.ToLower() == "bayern")
|
||
{
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 11, 1), Name = "Allerheiligen" });
|
||
}
|
||
if (bundesland.ToLower() == "bayern")
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 8, 15), Name = "Mariä Himmelfahrt" });
|
||
|
||
|
||
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 12, 24), Name = "Heilig Abend" }); // Eigentlich kein gesetzlicher Feiertag, wird bei uns aber immer als Standard gesetzt, da in der Praxis die meisten Unternehmen einen halben für Heilig Abend und einen halben für Silvester geben.
|
||
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 12, 25), Name = "1. Weihnachtstag" });
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 12, 26), Name = "2. Weihnachtstag" });
|
||
|
||
if (year == 2017 || bundesland.ToLower() == "brandenburg" || bundesland.ToLower() == "niedersachsen")
|
||
list.Add(new FeiertagDC { Datum = new DateTime(year, 10, 31), Name = "Reformationstag" });
|
||
|
||
DateTime osterSonntag = GetOsterSonntag(year);
|
||
//list.Add(osterSonntag); // , "Ostersonntag"));
|
||
//list.Add(osterSonntag.AddDays(-3)); // , "Gründonnerstag")); q
|
||
//list.Add(osterSonntag.AddDays(-48)); // , "Rosenmontag"));
|
||
list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(-2), Name = "Karfreitag" });
|
||
list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(1), Name = "Ostermontag" });
|
||
list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(39), Name = "Christi Himmelfahrt" });
|
||
|
||
list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(50), Name = "Pfingstmontag" });
|
||
if (bundesland.ToLower() == "nrw" || bundesland.ToLower() == "hessen" || bundesland.ToLower() == "bayern")
|
||
list.Add(new FeiertagDC { Datum = osterSonntag.AddDays(60), Name = "Fronleichnam" });
|
||
|
||
list.AddRange(GetDBFeiertage(year));
|
||
|
||
return list;
|
||
}
|
||
|
||
//Für zentrale Ablage der Feiertage
|
||
public virtual List<FeiertagDC> GetDBFeiertage(int year)
|
||
{
|
||
if (databaseFeiertage == null)
|
||
{
|
||
var feiertage = DAOFactory.GenericDAO.GetAllActive<Feiertag>();
|
||
|
||
databaseFeiertage = MapperFactory.FeiertagDC_Feiertag.MapToNewDCs(feiertage.Where(f => !f.OrganisationOid.HasValue));
|
||
|
||
}
|
||
|
||
|
||
return databaseFeiertage.Where(f => f.Datum >= new DateTime(year, 1, 1) && f.Datum < new DateTime(year + 1, 1, 1)).ToList();
|
||
}
|
||
|
||
public static DateTime GetOsterSonntag(int year)
|
||
{
|
||
|
||
int g, h, c, j, l, i;
|
||
|
||
g = year % 19;
|
||
c = year / 100;
|
||
h = ((c - (c / 4)) - (((8 * c) + 13) / 25) + (19 * g) + 15) % 30;
|
||
i = h - (h / 28) * (1 - (29 / (h + 1)) * ((21 - g) / 11));
|
||
j = (year + (year / 4) + i + 2 - c + (c / 4)) % 7;
|
||
|
||
l = i - j;
|
||
int month = (int)(3 + ((l + 40) / 44));
|
||
int day = (int)(l + 28 - 31 * (month / 4));
|
||
|
||
return new DateTime(year, month, day);
|
||
|
||
}
|
||
|
||
public virtual List<FerienDC> GetFerien(String bundesland = "nrw")
|
||
{
|
||
List<FerienDC> list = new List<FerienDC>();
|
||
|
||
if (bundesland.ToLower() == "nrw")
|
||
{
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2014", Start = new DateTime(2014, 7, 7), Ende = new DateTime(2014, 8, 19) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2014", Start = new DateTime(2014, 10, 6), Ende = new DateTime(2014, 10, 18) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2014", Start = new DateTime(2014, 12, 22), Ende = new DateTime(2015, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2015", Start = new DateTime(2015, 3, 30), Ende = new DateTime(2015, 4, 11) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2015", Start = new DateTime(2015, 6, 29), Ende = new DateTime(2015, 8, 11) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2015", Start = new DateTime(2015, 10, 5), Ende = new DateTime(2015, 10, 17) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2015", Start = new DateTime(2015, 12, 23), Ende = new DateTime(2016, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2016", Start = new DateTime(2016, 3, 21), Ende = new DateTime(2016, 4, 2) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2016", Start = new DateTime(2016, 7, 11), Ende = new DateTime(2016, 8, 23) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2016", Start = new DateTime(2016, 10, 10), Ende = new DateTime(2016, 10, 21) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2016", Start = new DateTime(2016, 12, 23), Ende = new DateTime(2017, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2017", Start = new DateTime(2017, 4, 10), Ende = new DateTime(2017, 4, 22) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2017", Start = new DateTime(2017, 7, 17), Ende = new DateTime(2017, 8, 29) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2017", Start = new DateTime(2017, 10, 23), Ende = new DateTime(2017, 11, 4) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2017", Start = new DateTime(2017, 12, 27), Ende = new DateTime(2018, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2018", Start = new DateTime(2018, 3, 26), Ende = new DateTime(2018, 4, 7) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2018", Start = new DateTime(2018, 7, 16), Ende = new DateTime(2018, 8, 28) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2018", Start = new DateTime(2018, 10, 15), Ende = new DateTime(2018, 10, 27) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2018", Start = new DateTime(2018, 12, 21), Ende = new DateTime(2019, 1, 4) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2019", Start = new DateTime(2019, 4, 15), Ende = new DateTime(2019, 4, 27) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2019", Start = new DateTime(2019, 7, 15), Ende = new DateTime(2019, 8, 27) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2019", Start = new DateTime(2019, 10, 14), Ende = new DateTime(2019, 10, 26) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2019", Start = new DateTime(2019, 12, 23), Ende = new DateTime(2020, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2020", Start = new DateTime(2020, 4, 6), Ende = new DateTime(2020, 4, 18) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2020", Start = new DateTime(2020, 6, 29), Ende = new DateTime(2020, 8, 11) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2020", Start = new DateTime(2020, 10, 12), Ende = new DateTime(2020, 10, 24) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2020", Start = new DateTime(2020, 12, 21), Ende = new DateTime(2021, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2021", Start = new DateTime(2021, 3, 29), Ende = new DateTime(2021, 4, 10) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2021", Start = new DateTime(2021, 7, 5), Ende = new DateTime(2021, 8, 17) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2021", Start = new DateTime(2021, 10, 11), Ende = new DateTime(2021, 10, 23) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2021", Start = new DateTime(2021, 12, 24), Ende = new DateTime(2022, 1, 8) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2022", Start = new DateTime(2022, 4, 11), Ende = new DateTime(2022, 4, 23) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2022", Start = new DateTime(2022, 6, 27), Ende = new DateTime(2022, 8, 9) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2022", Start = new DateTime(2022, 10, 4), Ende = new DateTime(2022, 10, 15) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2022", Start = new DateTime(2022, 12, 23), Ende = new DateTime(2023, 1, 7) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2023", Start = new DateTime(2023, 4, 3), Ende = new DateTime(2023, 4, 15) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2023", Start = new DateTime(2023, 6, 22), Ende = new DateTime(2023, 8, 5) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2023", Start = new DateTime(2023, 10, 2), Ende = new DateTime(2023, 10, 14) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2023", Start = new DateTime(2023, 12, 21), Ende = new DateTime(2024, 1, 5) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2024", Start = new DateTime(2024, 3, 25), Ende = new DateTime(2024, 4, 6) });
|
||
list.Add(new FerienDC() { Name = "Pfingstferien 2024", Start = new DateTime(2024, 5, 21), Ende = new DateTime(2024, 5, 21) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2024", Start = new DateTime(2024, 7, 8), Ende = new DateTime(2024, 8, 20) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2024", Start = new DateTime(2024, 10, 14), Ende = new DateTime(2024, 10, 26) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2024", Start = new DateTime(2024, 12, 23), Ende = new DateTime(2025, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2025", Start = new DateTime(2025, 4, 14), Ende = new DateTime(2025, 4, 26) });
|
||
list.Add(new FerienDC() { Name = "Pfingstferien 2025", Start = new DateTime(2025, 6, 10), Ende = new DateTime(2024, 6, 10) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2025", Start = new DateTime(2025, 7, 14), Ende = new DateTime(2025, 8, 26) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2025", Start = new DateTime(2025, 10, 13), Ende = new DateTime(2025, 10, 25) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2025", Start = new DateTime(2025, 12, 22), Ende = new DateTime(2026, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2026", Start = new DateTime(2026, 3, 30), Ende = new DateTime(2026, 4, 11) });
|
||
list.Add(new FerienDC() { Name = "Pfingstferien 2026", Start = new DateTime(2026, 5, 26), Ende = new DateTime(2026, 5, 26) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2026", Start = new DateTime(2026, 7, 20), Ende = new DateTime(2026, 9, 1) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2026", Start = new DateTime(2026, 10, 17), Ende = new DateTime(2026, 10, 31) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2026", Start = new DateTime(2026, 12, 23), Ende = new DateTime(2027, 1, 6) });
|
||
}
|
||
else if (bundesland.ToLower() == "niedersachsen")
|
||
{
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2020", Start = new DateTime(2020, 12, 21), Ende = new DateTime(2021, 1, 8) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2021", Start = new DateTime(2021, 3, 29), Ende = new DateTime(2021, 4, 09) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2021", Start = new DateTime(2021, 7, 22), Ende = new DateTime(2021, 9, 1) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2021", Start = new DateTime(2021, 10, 18), Ende = new DateTime(2021, 10, 29) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2021", Start = new DateTime(2021, 12, 23), Ende = new DateTime(2022, 1, 7) });
|
||
|
||
list.Add(new FerienDC() { Name = "Winterferien 2022", Start = new DateTime(2022, 1, 31), Ende = new DateTime(2022, 2, 1) });
|
||
list.Add(new FerienDC() { Name = "Osterferien 2022", Start = new DateTime(2022, 4, 4), Ende = new DateTime(2022, 4, 19) });
|
||
list.Add(new FerienDC() { Name = "Pfingstferien 2022", Start = new DateTime(2022, 5, 27), Ende = new DateTime(2022, 5, 27) }); //Brückentag Himmelfahrt
|
||
list.Add(new FerienDC() { Name = "Pfingstferien 2022", Start = new DateTime(2022, 6, 7), Ende = new DateTime(2022, 6, 7) }); //Pfingstdienstag
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2022", Start = new DateTime(2022, 7, 14), Ende = new DateTime(2022, 8, 24) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2022", Start = new DateTime(2022, 10, 17), Ende = new DateTime(2022, 10, 28) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2022", Start = new DateTime(2022, 12, 23), Ende = new DateTime(2023, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Winterferien 2023", Start = new DateTime(2023, 1, 30), Ende = new DateTime(2023, 1, 31) });
|
||
list.Add(new FerienDC() { Name = "Osterferien 2023", Start = new DateTime(2023, 3, 27), Ende = new DateTime(2023, 4, 11) });
|
||
list.Add(new FerienDC() { Name = "Brückentag 2023", Start = new DateTime(2023, 5, 19), Ende = new DateTime(2023, 5, 19) }); //Brückentag Himmelfahrt
|
||
list.Add(new FerienDC() { Name = "Pfingstferien 2023", Start = new DateTime(2023, 5, 30), Ende = new DateTime(2023, 5, 31) }); //Pfingstdienstag
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2023", Start = new DateTime(2023, 7, 6), Ende = new DateTime(2023, 8, 17) });
|
||
list.Add(new FerienDC() { Name = "Brückentag 2023", Start = new DateTime(2023, 10, 2), Ende = new DateTime(2023, 10, 3) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2023", Start = new DateTime(2023, 10, 16), Ende = new DateTime(2023, 10, 31) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2023", Start = new DateTime(2023, 12, 27), Ende = new DateTime(2024, 1, 6) });
|
||
|
||
list.Add(new FerienDC() { Name = "Winterferien 2024", Start = new DateTime(2024, 2, 1), Ende = new DateTime(2024, 2, 3) });
|
||
list.Add(new FerienDC() { Name = "Osterferien 2024", Start = new DateTime(2024, 3, 18), Ende = new DateTime(2024, 3, 29) });
|
||
list.Add(new FerienDC() { Name = "Brückentag 2024", Start = new DateTime(2024, 5, 10), Ende = new DateTime(2024, 5, 10) }); //Brückentag Himmelfahrt
|
||
list.Add(new FerienDC() { Name = "Pfingstferien 2024", Start = new DateTime(2024, 5, 21), Ende = new DateTime(2024, 5, 21) }); //Pfingstdienstag
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2024", Start = new DateTime(2024, 6, 24), Ende = new DateTime(2024, 8, 3) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2024", Start = new DateTime(2024, 10, 4), Ende = new DateTime(2024, 10, 19) });
|
||
list.Add(new FerienDC() { Name = "Brückentag 2024", Start = new DateTime(2024, 11, 1), Ende = new DateTime(2024, 11, 1) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2024", Start = new DateTime(2024, 12, 23), Ende = new DateTime(2025, 1, 4) });
|
||
|
||
list.Add(new FerienDC() { Name = "Winterferien 2025", Start = new DateTime(2025, 2, 3), Ende = new DateTime(2025, 2, 4) });
|
||
list.Add(new FerienDC() { Name = "Osterferien 2025", Start = new DateTime(2025, 4, 7), Ende = new DateTime(2025, 4, 19) });
|
||
list.Add(new FerienDC() { Name = "Brückentag 2025", Start = new DateTime(2025, 4, 30), Ende = new DateTime(2025, 4, 30) }); //Brückentag 1.Mai
|
||
list.Add(new FerienDC() { Name = "Brückentag 2025", Start = new DateTime(2025, 5, 2), Ende = new DateTime(2025, 5, 2) }); //Brückentag Himmelfahrt
|
||
list.Add(new FerienDC() { Name = "Brückentag 2025", Start = new DateTime(2025, 5, 30), Ende = new DateTime(2025, 5, 30) });
|
||
list.Add(new FerienDC() { Name = "Pfingstferien 2025", Start = new DateTime(2025, 6, 10), Ende = new DateTime(2025, 6, 10) }); //Pfingstdienstag
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2025", Start = new DateTime(2025, 7, 3), Ende = new DateTime(2025, 8, 13) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2025", Start = new DateTime(2025, 10, 13), Ende = new DateTime(2025, 10, 25) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2025", Start = new DateTime(2025, 12, 22), Ende = new DateTime(2026, 1, 5) });
|
||
|
||
list.Add(new FerienDC() { Name = "Winterferien 2026", Start = new DateTime(2026, 2, 2), Ende = new DateTime(2026, 2, 3) });
|
||
list.Add(new FerienDC() { Name = "Osterferien 2026", Start = new DateTime(2026, 3, 23), Ende = new DateTime(2026, 4, 7) });
|
||
list.Add(new FerienDC() { Name = "Brückentag 2026", Start = new DateTime(2026, 5, 15), Ende = new DateTime(2026, 5, 15) }); //Brückentag Himmelfahrt
|
||
list.Add(new FerienDC() { Name = "Brückentag 2026", Start = new DateTime(2026, 5, 26), Ende = new DateTime(2026, 5, 26) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2026", Start = new DateTime(2026, 7, 2), Ende = new DateTime(2026, 8, 12) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2026", Start = new DateTime(2026, 10, 16), Ende = new DateTime(2026, 10, 30) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2026", Start = new DateTime(2026, 12, 23), Ende = new DateTime(2027, 1, 9) });
|
||
|
||
}
|
||
|
||
else if (bundesland.ToLower() == "hessen")
|
||
{
|
||
list.Add(new FerienDC() { Name = "Osterferien 2021", Start = new DateTime(2021, 4, 6), Ende = new DateTime(2021, 4, 16) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2021", Start = new DateTime(2021, 7, 19), Ende = new DateTime(2021, 8, 27) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2021", Start = new DateTime(2021, 10, 11), Ende = new DateTime(2021, 10, 23) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2021", Start = new DateTime(2021, 12, 23), Ende = new DateTime(2022, 1, 8) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2022", Start = new DateTime(2022, 4, 11), Ende = new DateTime(2022, 4, 23) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2022", Start = new DateTime(2022, 7, 25), Ende = new DateTime(2022, 9, 2) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2022", Start = new DateTime(2022, 10, 24), Ende = new DateTime(2022, 10, 29) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2022", Start = new DateTime(2022, 12, 22), Ende = new DateTime(2023, 1, 7) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2023", Start = new DateTime(2023, 4, 3), Ende = new DateTime(2023, 4, 22) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2023", Start = new DateTime(2023, 7, 24), Ende = new DateTime(2023, 9, 1) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2023", Start = new DateTime(2023, 10, 23), Ende = new DateTime(2023, 10, 28) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2023", Start = new DateTime(2023, 12, 27), Ende = new DateTime(2024, 1, 13) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2024", Start = new DateTime(2024, 3, 25), Ende = new DateTime(2024, 4, 13) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2024", Start = new DateTime(2024, 7, 15), Ende = new DateTime(2024, 8, 23) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2024", Start = new DateTime(2024, 10, 14), Ende = new DateTime(2024, 10, 25) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2024", Start = new DateTime(2024, 12, 23), Ende = new DateTime(2025, 1, 10) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2025", Start = new DateTime(2025, 4, 7), Ende = new DateTime(2025, 4, 21) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2025", Start = new DateTime(2025, 7, 7), Ende = new DateTime(2025, 8, 15) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2025", Start = new DateTime(2025, 10, 6), Ende = new DateTime(2025, 10, 18) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2025", Start = new DateTime(2025, 12, 22), Ende = new DateTime(2026, 1, 10) });
|
||
|
||
list.Add(new FerienDC() { Name = "Osterferien 2026", Start = new DateTime(2026, 3, 30), Ende = new DateTime(2026, 4, 10) });
|
||
list.Add(new FerienDC() { Name = "Sommerferien 2026", Start = new DateTime(2026, 6, 29), Ende = new DateTime(2026, 8, 7) });
|
||
list.Add(new FerienDC() { Name = "Herbstferien 2026", Start = new DateTime(2026, 10, 5), Ende = new DateTime(2026, 10, 17) });
|
||
list.Add(new FerienDC() { Name = "Weihnachtsferien 2026", Start = new DateTime(2026, 12, 23), Ende = new DateTime(2027, 1, 12) });
|
||
}
|
||
return list;
|
||
}
|
||
|
||
|
||
|
||
private void SetLokaleFeiertagListe(int year)
|
||
{
|
||
_Feiertage = GetFeiertage(year);
|
||
}
|
||
|
||
public virtual List<long> GetVacationReasonIDs()
|
||
{
|
||
var res = new List<long>();
|
||
var filters = new List<string> { "URLAUB" };
|
||
var reasons = DAOFactory.GenericDAO.GetAllActive<AbsenceReason>();
|
||
|
||
foreach (var reason in reasons)
|
||
{
|
||
var desc = reason.Description.ToUpper();
|
||
|
||
foreach (var filter in filters)
|
||
{
|
||
if (desc.Contains(filter))
|
||
{
|
||
res.Add(reason.Oid.Value);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
return res;
|
||
}
|
||
|
||
public virtual DateTime GetExpirationDate(int year)
|
||
{
|
||
return new DateTime(year, 3, 31);
|
||
}
|
||
|
||
public virtual decimal GetFeiertagsFaktor(DateTime start)
|
||
{
|
||
if (IstFeiertag(start))
|
||
{
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////
|
||
///////////// URLAUBSKONTO WAS MAN SIEHT///////////////////
|
||
///////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
// ------INHALTSVERZEICHNIS------
|
||
// 1. Vetragliche Urlaubstage für´s Jahr
|
||
// 2. Abzuziehende Tage wegen Vertragsbeginn mitten im Jahr
|
||
// 3. Geschenkte Urlaubstage im Jahr
|
||
// 4. Verfallener Resturlaub
|
||
// 5. Alle Urlaube, die Anfang oder Ende im gewählten Jahr haben
|
||
// 6. Anzahl der aus 1.-5. resultierenden Resturlaubstage fürs Jahr, also Resturlaub vom Urlaubskonto
|
||
// 7. Liste der DCs nach Datum sortieren, um eine zeitliche Hierarchie zu schaffen
|
||
|
||
public virtual List<UrlaubskontoDarstellungDC> BerechneUrlaubskontoZurDarstellung(EmployeeDC emp, int year)
|
||
{
|
||
List<UrlaubskontoDarstellungDC> dcs = new List<UrlaubskontoDarstellungDC>();
|
||
EmployeeServiceImp es = new EmployeeServiceImp();
|
||
|
||
// Urlaubskonto erstellen
|
||
var ent = DAOFactory.GenericDAO.LoadByID<Employee>((long)emp.EmployeeOid);
|
||
var urlaubskonten = BerechneUrlaubskonto(ent, year);
|
||
var aktuellesKonto = urlaubskonten.First(u => u.Key == year);
|
||
|
||
var geschenkteUrlaubstage = es.GetGeschenkteUrlaubstageForEmployee((long)emp.EmployeeOid);
|
||
|
||
|
||
// Benötigt werden:
|
||
// 1. Vetragliche Urlaubstage für´s Jahr
|
||
List<ContractDC> contracts = new List<ContractDC>();
|
||
Dictionary<ContractDC, int> contractsAndWeeklyDays = new Dictionary<ContractDC, int>();
|
||
|
||
// Vertrag für Jahr raussuchen
|
||
foreach (var c in emp.Contracts)
|
||
{
|
||
DateTime contractEndDate = new DateTime();
|
||
if (c.ContractEndDate == null)
|
||
contractEndDate = new DateTime(2099, 12, 31);
|
||
else
|
||
contractEndDate = c.ContractEndDate.Value;
|
||
|
||
DateTime contractStartDate = new DateTime();
|
||
if (c.EntryDate == null)
|
||
contractStartDate = new DateTime(year, 01, 01);
|
||
else
|
||
contractStartDate = c.EntryDate.Value;
|
||
|
||
if (year >= contractStartDate.Year && year <= contractEndDate.Year) // Wenn das ausgewählte Jahr zwischen Vertragsbeginn und -ende liegt
|
||
{
|
||
contracts.Add(c);
|
||
contractsAndWeeklyDays.Add(c, c.WeeklyDays);
|
||
}
|
||
}
|
||
if (contracts.Count == 0) // Kein Vertrag = kein Urlaubskonto
|
||
return null;
|
||
|
||
|
||
// 2. Abzuziehende Tage wegen Vertragsbeginn mitten im Jahr
|
||
foreach (var contractAndWeeklyDays in contractsAndWeeklyDays)
|
||
{
|
||
var contract = contractAndWeeklyDays.Key;
|
||
#region Vielleicht bald unnötig
|
||
// Zahlen für Darstellung in View
|
||
decimal tageNachAbzug = 0;
|
||
decimal abzuziehendeTage = 0;
|
||
|
||
int arbeitstage = contract.WeeklyDays; // Vertragliche Arbeitstage
|
||
DateTime? endDate = contract.ContractEndDate == null ? new DateTime(year, 12, 31) : contract.ContractEndDate; // Ende des Vertrags auf letzten Tag des Jahres setzen, wenn kein Ende
|
||
var leaveDays = contract.EmploymentType?.LeaveDays == null ? contract.LeaveDays : contract.EmploymentType.LeaveDays; // Vertragliche Urlaubstage
|
||
if (!leaveDays.HasValue)
|
||
{
|
||
leaveDays = 0;
|
||
}
|
||
if (contract.EntryDate.HasValue && (contract.EntryDate.Value.Year == year || endDate.Value.Year == year)) // Wenn Vertrag im gewählten Jahr beginnt oder endet
|
||
{
|
||
if (contract.EntryDate.Value.Year == year) // Wenn Vertrag im gewählten Jahr beginnt
|
||
{
|
||
if (endDate >= new DateTime(contract.EntryDate.Value.Year, 12, 31)) // Wenn Vertrag länger gilt als das gewählte Jahr
|
||
{
|
||
int restlicheTageImJahr = Convert.ToInt32((new DateTime(contract.EntryDate.Value.Year, 12, 31) - contract.EntryDate.Value.Date).TotalDays);
|
||
tageNachAbzug = CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, null, arbeitstage, restlicheTageImJahr, leaveDays);
|
||
}
|
||
else // Wenn Ende des Vertrags im gleichen Jahr vor Jahresende ist
|
||
{
|
||
int restlicheTageImJahr = Convert.ToInt32((contract.ContractEndDate.Value.Date - contract.EntryDate.Value.Date).TotalDays);
|
||
tageNachAbzug = CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, contract.ContractEndDate.Value.Date, arbeitstage, restlicheTageImJahr, leaveDays);
|
||
}
|
||
}
|
||
else if (endDate.Value.Year == year) // Wenn Vertrag im gewählten Jahr endet
|
||
{
|
||
int restlicheTageImJahr = Convert.ToInt32(((DateTime)endDate - new DateTime(year, 1, 1)).TotalDays);
|
||
tageNachAbzug = CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, endDate, arbeitstage, restlicheTageImJahr, leaveDays);
|
||
}
|
||
// Abzuziehende Tage = Vertragliche Urlaubstage - Tage, die nach Abzug der verfallenden Tage übrig bleiben
|
||
abzuziehendeTage = (decimal)leaveDays - tageNachAbzug;
|
||
}
|
||
#endregion
|
||
var contractStart = contract.EntryDate.Value.ToString().Split(' ');
|
||
var contractEnd = contract.ContractEndDate != null ? contract.ContractEndDate.Value.ToString().Split(' ') : null;
|
||
|
||
var anzahlTage = leaveDays - abzuziehendeTage;
|
||
|
||
var obereZeile = new UrlaubskontoDarstellungDC()
|
||
{
|
||
AnzahlTage = string.Format("{0:0.00}", anzahlTage),
|
||
Herkunft = string.Format("EmpOid:{0} ContractOid:{1}", emp.EmployeeOid, contract.ContractOid),
|
||
Tooltip = null,
|
||
IsDeletable = false,
|
||
DatumZurSortierung = null
|
||
};
|
||
obereZeile.Erlaeuterung = contractEnd == null ? "Urlaubstage laut Vertrag vom " + contractStart[0] + ":" : "Urlaubstage laut Vertrag vom " + contractStart[0] + " bis " + contractEnd[0] + ":";
|
||
dcs.Add(obereZeile);
|
||
|
||
#region Würde Code von 2. sparen, klappt aber leider nur dann, wenn es nicht mehr als einen Vertrag im Jahr gibt
|
||
//decimal anzGeschenkteTage = 0.0m;
|
||
//if (geschenkteUrlaubstage != null)
|
||
//{
|
||
// foreach (var item in geschenkteUrlaubstage)
|
||
// {
|
||
// if (item.Date.Year == year)
|
||
// anzGeschenkteTage += item.AnzahlTage;
|
||
// }
|
||
//}
|
||
//var testvar = aktuellesKonto.Value.Urlaubsanspruch - anzGeschenkteTage;
|
||
//var obereZeile = new UrlaubskontoDarstellungDC()
|
||
//{
|
||
// AnzahlTage = testvar,
|
||
// Herkunft = string.Format("EmpOid:{0} ContractOid:{1}", emp.EmployeeOid, contract.ContractOid),
|
||
// Tooltip = null,
|
||
// IsDeletable = false,
|
||
// DatumZurSortierung = null
|
||
//};
|
||
//obereZeile.Erlaeuterung = contractEnd == null ? "Urlaubstage laut Vertrag vom " + contractStart[0] + ":" : "Urlaubstage laut Vertrag vom " + contractStart[0] + " bis " + contractEnd[0] + ":";
|
||
//dcs.Add(obereZeile);
|
||
#endregion
|
||
}
|
||
|
||
// 3. Geschenkte Urlaubstage im Jahr
|
||
if (geschenkteUrlaubstage.Count > 0 && geschenkteUrlaubstage.Any(g => g.Date.Year == year))
|
||
{
|
||
// Einen Eintrag pro geschenktem Urlaubstag
|
||
foreach (var eintrag in geschenkteUrlaubstage)
|
||
{
|
||
if (eintrag.Date.Year == year)
|
||
{
|
||
var tempDate = eintrag.Date.ToString().Split(' ');
|
||
dcs.Add(new UrlaubskontoDarstellungDC()
|
||
{
|
||
Erlaeuterung = string.Format("Tage geschenkt am {0} von {1}", tempDate[0], eintrag.InsUser),
|
||
AnzahlTage = eintrag.AnzahlTage > 0 ? string.Format("+{0:0.00}", eintrag.AnzahlTage) : string.Format("{0:0.00}", eintrag.AnzahlTage),
|
||
Herkunft = string.Format("GeschenkterUrlaubstagOid:{0}", eintrag.GeschenkterUrlaubstagOid),
|
||
Tooltip = eintrag.GeschenkterUrlaubstagNotice,
|
||
IsDeletable = true,
|
||
DatumZurSortierung = eintrag.Date
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
// 4. Verfallener Resturlaub
|
||
// Verfallsdatum der Urlaubstage des letzten Jahres zur Darstellung (also ohne Uhrzeit)
|
||
var expDate = GetExpirationDate(year).ToString().Split(' ');
|
||
|
||
// Resturlaub und den verbleibenden Resturlaub nach Verfall erstellen
|
||
if (aktuellesKonto.Value.ResturlaubVorjahrTotal > 0) // Wenn Urlaub aus dem Vorjahr mitgenommen wurde
|
||
{
|
||
dcs.Add(new UrlaubskontoDarstellungDC()
|
||
{
|
||
Erlaeuterung = "Resturlaub aus " + (year - 1) + " :",
|
||
AnzahlTage = string.Format("+{0:0.00}", aktuellesKonto.Value.ResturlaubVorjahrTotal),
|
||
Herkunft = string.Format("EmpOid:{0} Urlaubskonto:{1}", emp.EmployeeOid, year),
|
||
Tooltip = null,
|
||
IsDeletable = false
|
||
}) ;
|
||
}
|
||
if (aktuellesKonto.Value.VerfallenerUrlaub > 0) // Wenn Urlaubstage verfallen sind
|
||
{
|
||
dcs.Add(new UrlaubskontoDarstellungDC()
|
||
{
|
||
Erlaeuterung = string.Format("Urlaub am {0} verfallen: ", expDate[0]),
|
||
AnzahlTage = string.Format("-{0:0.00}", aktuellesKonto.Value.VerfallenerUrlaub),
|
||
DatumZurSortierung = GetExpirationDate(year),
|
||
Tooltip = null,
|
||
IsDeletable = false
|
||
});
|
||
}
|
||
|
||
|
||
// 5. Alle Urlaube, die Anfang oder Ende im gewählten Jahr haben
|
||
var absReason = GetVacationReasonIDs();
|
||
var absences = emp.AbsenceTimes.Where(x => absReason.Contains(x.Reason.AbsenceReasonOid.Value) && (x.Start.HasValue && x.Start.Value.Year == year)
|
||
|| absReason.Contains(x.Reason.AbsenceReasonOid.Value) && (x.End.HasValue && x.End.Value.Year == year))
|
||
.OrderBy(x => x.Start).ToList();
|
||
|
||
if (absences.Count > 0) // Wenn es Urlaube in dem Jahr gibt
|
||
{
|
||
// Urlaube durchgehen und die Tage zählen
|
||
foreach (var spanne in absences)
|
||
{
|
||
if (spanne.End.HasValue && spanne.End.Value.Year > year)
|
||
spanne.End = new DateTime(year, 12, 31);
|
||
if (spanne.Start.HasValue && spanne.Start.Value.Year < year)
|
||
spanne.Start = new DateTime(year, 01, 01);
|
||
|
||
decimal summeTage = 0;
|
||
|
||
#region Urlaubstage zählen
|
||
if (emp.Arbeitszeiten != null && emp.Arbeitszeiten.Count > 0)
|
||
{
|
||
foreach (var az in emp.Arbeitszeiten)
|
||
{
|
||
if (az.GueltigVon.HasValue)
|
||
{
|
||
var azEnde = !az.GueltigBis.HasValue ? new DateTime(year, 12, 31) : az.GueltigBis.Value;
|
||
if (new DateTimeSpan(az.GueltigVon.Value, azEnde).ContainsDate(spanne.AbsenceSpan.StartDate) && az.Eintraege != null && az.Eintraege.Count > 0)
|
||
{
|
||
summeTage = CountUrlaubstageArbeitszeiten(spanne, year, az);
|
||
}
|
||
else
|
||
summeTage = CountUrlaubstageStandard(spanne, year, contractsAndWeeklyDays);
|
||
}
|
||
else
|
||
summeTage = CountUrlaubstageStandard(spanne, year, contractsAndWeeklyDays);
|
||
}
|
||
}
|
||
else
|
||
summeTage = CountUrlaubstageStandard(spanne, year, contractsAndWeeklyDays);
|
||
|
||
|
||
#endregion
|
||
|
||
// Start- und Enddatum des Urlaubs für Darstellung vorbereiten
|
||
var startAsArray = spanne.Start.Value.ToString().Split(' ');
|
||
var endAsArray = spanne.End.Value.ToString().Split(' ');
|
||
// Eintrag für Urlaubstag setzen (Erläuterung abhängig davon, ob Urlaub nur ein Tag geht oder über mehrere
|
||
dcs.Add(new UrlaubskontoDarstellungDC()
|
||
{
|
||
Erlaeuterung = startAsArray[0] == endAsArray[0] ? string.Format("Urlaub genommen am {0}", startAsArray[0]) :
|
||
string.Format("Urlaub genommen vom {0} bis {1}", startAsArray[0], endAsArray[0]),
|
||
AnzahlTage = string.Format("-{0:0.00}", summeTage),
|
||
AnzahlTageUrlaub = summeTage,
|
||
Herkunft = string.Format("AbsenceOid: {0}", spanne.AbsenceTimeOid),
|
||
Tooltip = spanne.Notice,
|
||
IsDeletable = false,
|
||
DatumZurSortierung = spanne.Start.Value
|
||
});
|
||
}
|
||
}
|
||
|
||
// 6. Anzahl der aus 1.-5. resultierenden Resturlaubstage fürs Jahr, also Resturlaub vom Urlaubskonto
|
||
var anzTage = aktuellesKonto.Value.ResturlaubVorjahrTotal > 0 && aktuellesKonto.Value.VerfallenerUrlaub <= 0 ? aktuellesKonto.Value.Resturlaub + aktuellesKonto.Value.ResturlaubVorjahr : aktuellesKonto.Value.Resturlaub;
|
||
dcs.Add(new UrlaubskontoDarstellungDC()
|
||
{
|
||
AnzahlTage = string.Format("={0:0.00}", anzTage),
|
||
Erlaeuterung = "Summe der verbleibenden Urlaubstage: ",
|
||
Herkunft = "UrlaubskontoEmpOid" + aktuellesKonto.Value.EmployeeOid,
|
||
Tooltip = null,
|
||
IsDeletable = false,
|
||
DatumZurSortierung = new DateTime(2999, 12, 31)
|
||
});
|
||
|
||
// 7. Liste der DCs nach Datum sortieren, um eine zeitliche Hierarchie zu schaffen
|
||
var sortierteDCs = dcs.OrderBy(dc => dc.DatumZurSortierung).ToList();
|
||
|
||
return sortierteDCs;
|
||
}
|
||
|
||
private decimal CountUrlaubstageStandard(AbsenceTimeDC spanne, int year, Dictionary<ContractDC, int> contractsAndWeeklyDays)
|
||
{
|
||
var summeTage = 0m;
|
||
if (spanne.End == null) // Wenn es kein Ende gibt, Ende auf letzten Tag im Jahr setzen
|
||
spanne.End = new DateTime(year, 12, 31);
|
||
|
||
if (spanne.Start.Value.Date == spanne.End.Value.Date && spanne.Start.Value.TimeOfDay == spanne.End.Value.TimeOfDay) // ein ganzer Tag Urlaub
|
||
summeTage++;
|
||
else if (spanne.Start.Value.Date == spanne.End.Value.Date && spanne.Start.Value.TimeOfDay != spanne.End.Value.TimeOfDay) // ein halber Tag Urlaub
|
||
summeTage += 0.5m;
|
||
else // Mehr als ein Tag Urlaub
|
||
{
|
||
DateTime startForLoop = (spanne.Start.Value.Year == year) ? spanne.Start.Value : new DateTime(year, 1, 1);
|
||
|
||
// Tage auf den Zähler addieren, solange das sich erhöhende Datum vor dem Enddatum ist und wenn das Datum kein Wochenend- oder Feiertag ist
|
||
|
||
#region neu
|
||
// Variable wird für jeden Tag hochgezählt und resettet, sobald wieder Montag ist. So kann vermieden werden, dass bei einer Arbeitswoche von unter 5 Tagen trotzdem 5 Tage Urlab abgezogen werden
|
||
var tageInDerWoche = 0;
|
||
#endregion
|
||
while (startForLoop <= spanne.End.Value)
|
||
{
|
||
if (startForLoop.DayOfWeek == DayOfWeek.Monday)
|
||
tageInDerWoche = 0;
|
||
|
||
var currentContract = contractsAndWeeklyDays.FirstOrDefault(c => startForLoop >= c.Key.EntryDate && startForLoop <= c.Key.ContractEndDate || startForLoop >= c.Key.EntryDate && c.Key.ContractEndDate == null);
|
||
if (currentContract.Key == null)
|
||
{
|
||
if (startForLoop.DayOfWeek != DayOfWeek.Saturday && startForLoop.DayOfWeek != DayOfWeek.Sunday && !_Feiertage.Contains(startForLoop))
|
||
summeTage++;
|
||
}
|
||
else
|
||
{
|
||
if (!CheckIstWochenende(currentContract.Value, startForLoop.DayOfWeek) && !IstFeiertag(startForLoop) && tageInDerWoche < currentContract.Value)
|
||
{
|
||
summeTage++;
|
||
tageInDerWoche++;
|
||
}
|
||
}
|
||
|
||
|
||
startForLoop = startForLoop.AddDays(1);
|
||
}
|
||
}
|
||
|
||
return summeTage;
|
||
}
|
||
private decimal CountUrlaubstageArbeitszeiten(AbsenceTimeDC spanne, int year, ArbeitszeitDC az)
|
||
{
|
||
//var feiertage = GetFeiertage(year);
|
||
var feiertage = GetFeiertage(year, Bundesland);
|
||
|
||
var summeTage = 0m;
|
||
if (spanne.End == null) // Wenn es kein Ende gibt, Ende auf letzten Tag im Jahr setzen
|
||
spanne.End = new DateTime(year, 12, 31);
|
||
|
||
if (spanne.Start.Value.Date == spanne.End.Value.Date && spanne.Start.Value.TimeOfDay == spanne.End.Value.TimeOfDay &&
|
||
az.Eintraege.Any(e => e.DayOfWeek == spanne.Start.Value.DayOfWeek) && !feiertage.Any(f => f.Datum == spanne.Start.Value.Date)) // ein ganzer Tag Urlaub
|
||
summeTage++;
|
||
else if (spanne.Start.Value.Date == spanne.End.Value.Date && spanne.Start.Value.TimeOfDay != spanne.End.Value.TimeOfDay &&
|
||
az.Eintraege.Any(e => e.DayOfWeek == spanne.Start.Value.DayOfWeek) && !feiertage.Any(f => f.Datum == spanne.Start.Value.Date)) // ein halber Tag Urlaub
|
||
summeTage += 0.5m;
|
||
else // Mehr als ein Tag Urlaub
|
||
{
|
||
DateTime startForLoop = (spanne.Start.Value.Year == year) ? spanne.Start.Value : new DateTime(year, 1, 1);
|
||
|
||
// Tage auf den Zähler addieren, solange das sich erhöhende Datum vor dem Enddatum ist und wenn das Datum kein Wochenend- oder Feiertag ist
|
||
|
||
#region neu
|
||
// Variable wird für jeden Tag hochgezählt und resettet, sobald wieder Montag ist. So kann vermieden werden, dass bei einer Arbeitswoche von unter 5 Tagen trotzdem 5 Tage Urlab abgezogen werden
|
||
var tageInDerWoche = 0;
|
||
#endregion
|
||
while (startForLoop <= spanne.End.Value)
|
||
{
|
||
if (!feiertage.Any(f => f.Datum == startForLoop.Date))
|
||
{
|
||
if (az.Eintraege.Any(e => e.DayOfWeek == startForLoop.DayOfWeek))
|
||
summeTage++;
|
||
}
|
||
|
||
if (startForLoop.DayOfWeek == DayOfWeek.Monday)
|
||
tageInDerWoche = 0;
|
||
|
||
|
||
startForLoop = startForLoop.AddDays(1);
|
||
}
|
||
}
|
||
|
||
return summeTage;
|
||
}
|
||
|
||
///////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////
|
||
///////////// URLAUBSKONTO IM HINTERGRUND /////////////////
|
||
///////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////
|
||
///////////////////////////////////////////////////////////
|
||
public virtual Dictionary<int, UrlaubskontoDC> BerechneUrlaubskonto(Employee emp, int year)
|
||
{
|
||
try
|
||
{
|
||
SetLokaleFeiertagListe(year);
|
||
|
||
// Alle Abwesenheiten bis zu dem Jahr raussuchen, für das man das Urlaubskonto berechnen will
|
||
var absReason = GetVacationReasonIDs();
|
||
var absences = emp.AbsenceTimes.Where(x => absReason.Contains(x.AbsenceReason.Oid.Value) &&
|
||
(x.Start.HasValue && x.Start.Value.Year <= year))
|
||
//(!x.End.HasValue || x.End.Value.Year >= year)
|
||
.OrderBy(x => x.Start);
|
||
|
||
var empService = new EmployeeServiceImp();
|
||
|
||
// Startzeitpunkt für Berechnung berechnen
|
||
var firstContractYear = emp.Contracts?.Min(x => x.EntryDate)?.Year ?? int.MaxValue; // Den Vetrag raussuchen, der am frühesten beginnt
|
||
var firstAbsenceTimeYear = absences.Min(x => x.Start)?.Year ?? int.MaxValue; // Jahr der ersten Abwesenheit
|
||
var firstYear = Math.Min(year, Math.Min(firstContractYear, firstAbsenceTimeYear)); // Erstes, für´s Urlaubskonto relevante Jahr
|
||
|
||
// Urlaubskonten erzeugen, eins für jedes Jahr ab dem ersten bis zum ausgewählten Jahr
|
||
var konten = new Dictionary<int, UrlaubskontoDC>();
|
||
for (int i = firstYear; i <= year; i++)
|
||
{
|
||
konten.Add(i, new UrlaubskontoDC());
|
||
}
|
||
|
||
int? workdays = 0;
|
||
List<ArbeitszeitDC> arbeitszeiten = new List<ArbeitszeitDC>();
|
||
Dictionary<ContractDC, int> contractsAndWeeklyDays = new Dictionary<ContractDC, int>();
|
||
|
||
// Jahresurlaubanspruch berechnen (noch kein Resturlaub Vorjahr in dieser Schleife, nur Jahresanspruch + Sonderfall Vertragsstart oder -ende mitten im Jahr)
|
||
foreach (var contract in emp.Contracts)
|
||
{
|
||
contractsAndWeeklyDays.Add(MapperFactory.ContractDC_Contract.MapToNewDC(contract), contract.WeeklyDays.HasValue ? contract.WeeklyDays.Value : 0);
|
||
|
||
var start = contract.EntryDate?.Year ?? firstYear;
|
||
var end = contract.ContractEndDate?.Year ?? year;
|
||
|
||
if (emp.Arbeitszeiten != null && emp.Arbeitszeiten.Count > 0)
|
||
arbeitszeiten = MapperFactory.ArbeitszeitDC_Arbeitszeit.MapToNewDCs(emp.Arbeitszeiten);
|
||
|
||
if (year >= start && year <= end)
|
||
workdays = contract.WeeklyDays;
|
||
// Durch jedes Jahr des Vertrags gehen
|
||
for (int i = start; i <= end; i++)
|
||
{
|
||
if (konten.ContainsKey(i))
|
||
{
|
||
// Konto für aktuelles Jahr in Schleife auswählen
|
||
var tmp = konten[i];
|
||
|
||
if (contract.EmploymentType?.LeaveDays != null)
|
||
contract.LeaveDays = contract.EmploymentType.LeaveDays;
|
||
|
||
//Hier wird nun der Urlaubsanspruch für ein Jahr errechnet, in dem der Vertrag beginnt oder aufhört. (Siehe CalcCorrectNumberOfLeaveDaysForSpecialContractSituation())
|
||
|
||
var urlaubsanspruchFuerVertragInLoop = contract.LeaveDays ?? 0;
|
||
|
||
int arbeitstage = contract.WeeklyDays != null ? (int)contract.WeeklyDays : 0;
|
||
DateTime? endDate = contract.ContractEndDate == null ? new DateTime(year, 12, 31) : contract.ContractEndDate;
|
||
|
||
if (contract != null && contract.EntryDate != null)
|
||
{
|
||
if (contract.EntryDate.Value.Year == i || endDate.Value.Year == i) // Endet oder beginnt Vertrag in gewähltem Jahr // HIER IST DAS PROBLEM
|
||
{
|
||
decimal errechneteTage = 0;
|
||
decimal weggefallen = 0;
|
||
if (contract.EntryDate.Value.Year == i)
|
||
{
|
||
if (endDate >= new DateTime(contract.EntryDate.Value.Year, 12, 31))
|
||
{
|
||
int restlicheTageImJahr = Convert.ToInt32((new DateTime(contract.EntryDate.Value.Year, 12, 31) - contract.EntryDate.Value.Date).TotalDays);
|
||
errechneteTage = CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, null, arbeitstage, restlicheTageImJahr, urlaubsanspruchFuerVertragInLoop);
|
||
}
|
||
else // Wenn Ende des Vertrags im gleichen Jahr vor Ende des Jahres ist
|
||
{
|
||
int restlicheTageImJahr = Convert.ToInt32((contract.ContractEndDate.Value.Date - contract.EntryDate.Value.Date).TotalDays);
|
||
errechneteTage += CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, contract.ContractEndDate.Value.Date, arbeitstage, restlicheTageImJahr, urlaubsanspruchFuerVertragInLoop);
|
||
}
|
||
}
|
||
else if (endDate.Value.Year == i)
|
||
{
|
||
int restlicheTageImJahr = Convert.ToInt32(((DateTime)endDate - new DateTime(i, 1, 1)).TotalDays);
|
||
errechneteTage += CalcCorrectNumberOfLeaveDaysForSpecialContractSituation((DateTime)contract.EntryDate, endDate, arbeitstage, restlicheTageImJahr, urlaubsanspruchFuerVertragInLoop);
|
||
}
|
||
|
||
// Resturlaub und Urlaubsanspruch auf errechnete Werte setzen
|
||
weggefallen = urlaubsanspruchFuerVertragInLoop - errechneteTage;
|
||
tmp.Resturlaub += errechneteTage;
|
||
tmp.Urlaubsanspruch += urlaubsanspruchFuerVertragInLoop - weggefallen;
|
||
}
|
||
else
|
||
{
|
||
tmp.Urlaubsanspruch += urlaubsanspruchFuerVertragInLoop;
|
||
tmp.Resturlaub = tmp.Urlaubsanspruch;
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
// Abwesenheiten in Jahr x zu einem Dictionary hinzufügen
|
||
var absencesYear = new List<Tuple<int, AbsenceTime>>();
|
||
foreach (var abs in absences)
|
||
{
|
||
var till = Math.Min(abs.End?.Year ?? year, year);
|
||
for (int i = abs.Start.Value.Year; i <= till; i++)
|
||
{
|
||
absencesYear.Add(new Tuple<int, AbsenceTime>(i, abs));
|
||
}
|
||
}
|
||
|
||
// Urlaubsanspruch berechnen
|
||
var berechnungsjahr = firstYear;
|
||
absencesYear = absencesYear.OrderBy(x => x.Item1).ToList();
|
||
|
||
Dictionary<int, decimal> zuVerfallZuAddieren = new Dictionary<int, decimal>();
|
||
var geschenkteUrlaubstage = empService.GetGeschenkteUrlaubstageForEmployee((long)emp.Oid);
|
||
|
||
// Alle Abwesenheiten durchlaufen, deren Dauer berechnen und vom Resturlaub + Geschenkte Tage Vorjahr abziehen, sofern es nicht nutzbaren Resturlaub vom Vorjahr gibt
|
||
// Tuple = Key-Value-Paar
|
||
foreach (var tuple in absencesYear)
|
||
{
|
||
var absYear = tuple.Item1;
|
||
var absence = tuple.Item2;
|
||
|
||
// Resturlaub aus Vorjahr übertragen
|
||
while (berechnungsjahr < absYear)
|
||
{
|
||
var geschenkteTageFuerAbrechnungsjahr = geschenkteUrlaubstage.Where(g => g.Date.Year == berechnungsjahr).ToList();
|
||
|
||
var tmp = konten[berechnungsjahr];
|
||
var tmp2 = konten[berechnungsjahr + 1];
|
||
|
||
tmp2.ResturlaubVorjahrTotal = tmp.Resturlaub + geschenkteTageFuerAbrechnungsjahr.Sum(g => g.AnzahlTage);
|
||
tmp2.ResturlaubVorjahr = tmp.Resturlaub + geschenkteTageFuerAbrechnungsjahr.Sum(g => g.AnzahlTage);
|
||
|
||
berechnungsjahr++;
|
||
}
|
||
|
||
var current = konten[absYear];
|
||
|
||
// Start und Ende auf Jahresanfang/-ende setzen, wenn Start des Urlaubs im Vorjahr oder Ende des Urlaubs im nächsten Jahr liegt
|
||
var start = DateTimeExtensions.GetMax(absence.Start, new DateTime(absYear, 1, 1));
|
||
var end = DateTimeExtensions.GetMin(absence.End, new DateTime(absYear, 12, 31));
|
||
|
||
// Dauer des Urlaubs unter Berücksichtigung von Wochenend- und Feiertagen berechnen
|
||
|
||
// Berücksichtigung von Arbeitszeiten
|
||
decimal dauer = 0;
|
||
|
||
var spanne = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDC(absence);
|
||
if (spanne.End.HasValue && spanne.End.Value.Year > absYear)
|
||
spanne.End = new DateTime(absYear, 12, 31);
|
||
if (spanne.Start.HasValue && spanne.Start.Value.Year < absYear)
|
||
spanne.Start = new DateTime(absYear, 01, 01);
|
||
|
||
if (arbeitszeiten.Count > 0)
|
||
{
|
||
foreach (var az in arbeitszeiten)
|
||
{
|
||
|
||
|
||
if (az.GueltigVon.HasValue)
|
||
{
|
||
var azEnde = !az.GueltigBis.HasValue ? new DateTime(year, 12, 31) : az.GueltigBis.Value;
|
||
if (new DateTimeSpan(az.GueltigVon.Value, azEnde).ContainsDate(spanne.AbsenceSpan.StartDate) && az.Eintraege != null && az.Eintraege.Count > 0)
|
||
{
|
||
dauer = CountUrlaubstageArbeitszeiten(spanne, absYear, az);
|
||
}
|
||
else
|
||
dauer = CountUrlaubstageStandard(spanne, absYear, contractsAndWeeklyDays);
|
||
}
|
||
else
|
||
dauer = CountUrlaubstageStandard(spanne, absYear, contractsAndWeeklyDays);
|
||
}
|
||
}
|
||
else
|
||
dauer = CountUrlaubstageStandard(spanne, absYear, contractsAndWeeklyDays);
|
||
//dauer = BerechneAnzahlUrlaubstage(absence, null, absYear, workdays); // HIER MÜSSEN PARAMETER FÜR ISTWOCHENENDE() MITGEGEBEN WERDEN
|
||
|
||
// Verfallsdatum des Urlaubs festlegen
|
||
var expiration = GetExpirationDate(absYear);
|
||
current.UrlaubsVerfallsdatum = expiration;
|
||
|
||
// Resturlaub vom Vorjahr verwenden, wenn Resturlaub aus dem Vorjahr existiert und der Urlaub vor dem Verfallsdatum beginnt
|
||
if (current.ResturlaubVorjahr > 0 && start <= expiration)
|
||
{
|
||
//var firstEnd = (DateTime)DateTimeExtensions.GetMin(end, expiration); // Ende von Urlaub oder Verfallsdatum, je nachdem was früher ist
|
||
var firstEnd = GetFirstEnd(end, expiration); // Ende von Urlaub oder Verfallsdatum, je nachdem was früher ist
|
||
|
||
var dauerVorjahr = 0;
|
||
DateTime zaehlerDatum = (DateTime)start;
|
||
|
||
// Urlaubstagzähler erhöhen, wenn aktueller Tag der Schleife weder ein Wochenend- noch ein Feiertag ist
|
||
while (zaehlerDatum <= firstEnd)
|
||
{
|
||
bool istWochenende = CheckIstWochenende(workdays, zaehlerDatum.DayOfWeek);
|
||
if (!istWochenende && !_Feiertage.Contains(zaehlerDatum))
|
||
dauerVorjahr++;
|
||
|
||
zaehlerDatum = zaehlerDatum.AddDays(1);
|
||
}
|
||
|
||
var bucheVorjahr = Math.Min(current.ResturlaubVorjahr, dauerVorjahr);
|
||
|
||
// Urlaub, der mit Resturlaub Vorjahr abgedeckt werden kann, von diesem abziehen
|
||
current.ResturlaubVorjahr -= bucheVorjahr;
|
||
// Die Anzahl der Tage, die der Urlaub geht, um die Anzahl Tage reduzieren, die vom Resturlaub genommen werden kann, da "dauer" vom Urlaubskontingent abgezogen wird
|
||
dauer -= bucheVorjahr;
|
||
if (dauer < 0)
|
||
{
|
||
if (!zuVerfallZuAddieren.ContainsKey(absYear))
|
||
zuVerfallZuAddieren.Add(absYear, 0);
|
||
|
||
zuVerfallZuAddieren[absYear] -= dauer;
|
||
}
|
||
}
|
||
else if (start > expiration) // Wenn der Urlaub nach dem Verfallsdatum beginnt, ist der verfallene Urlaub gleich dem Urlaub, der aus dem Vorjahr übrig ist
|
||
{
|
||
current.VerfallenerUrlaub = zuVerfallZuAddieren.ContainsKey(absYear) ? current.ResturlaubVorjahr + zuVerfallZuAddieren[absYear] : current.ResturlaubVorjahr;
|
||
}
|
||
|
||
// Restliche Dauer vom Urlaub abziehen
|
||
current.Resturlaub -= dauer < 0 ? 0 : dauer; // ausprobieren
|
||
}
|
||
|
||
// Als letztes geschenkte Urlaubstage draufrechnen auf aktuelles Jahr
|
||
foreach (var konto in konten)
|
||
{
|
||
var i = konto.Key;
|
||
|
||
// Wenn es geschenkte Tage gibt, Liste durchlaufen und für jeden Eintrag den Zähler entsprechend der Tage erhöhen
|
||
if (geschenkteUrlaubstage != null)
|
||
{
|
||
// Zähler für die Anzahl der geschenkten Tage für das ganze Jahr (i)
|
||
decimal anzGeschenkteTage = 0.0m;
|
||
|
||
foreach (var item in geschenkteUrlaubstage)
|
||
{
|
||
if (item.Date.Year == i)
|
||
anzGeschenkteTage += item.AnzahlTage;
|
||
}
|
||
// Geschenkte Tage auf Anspruch und Resturlaub addieren
|
||
konto.Value.Urlaubsanspruch += anzGeschenkteTage;
|
||
konto.Value.Resturlaub += anzGeschenkteTage;
|
||
}
|
||
}
|
||
|
||
|
||
return konten;
|
||
}
|
||
catch (Exception e)
|
||
{
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
public virtual DateTime GetFirstEnd(DateTime? end, DateTime expiration)
|
||
{
|
||
return (DateTime)DateTimeExtensions.GetMin(end, expiration);
|
||
}
|
||
|
||
private bool CheckIstWochenende(int? workdays, DayOfWeek tag)
|
||
{
|
||
bool istWochenende = tag == DayOfWeek.Saturday || tag == DayOfWeek.Sunday;
|
||
|
||
if (workdays == 6)
|
||
istWochenende = tag == DayOfWeek.Sunday;
|
||
else if (workdays > 6)
|
||
istWochenende = false;
|
||
|
||
return istWochenende;
|
||
}
|
||
|
||
internal decimal BerechneAnzahlUrlaubstageMitWeeklyDays(AbsenceTimeDC absenceDC, int year, int weeklyDays)
|
||
{
|
||
decimal tage = 0;
|
||
|
||
if (absenceDC.Start.HasValue)
|
||
{
|
||
DateTime start = (absenceDC.Start.Value.Year == year) ? absenceDC.Start.Value : new DateTime(year, 1, 1);
|
||
DateTime end = start;
|
||
DateTime maxend = new DateTime(year, 12, 31);
|
||
|
||
if (absenceDC.End.HasValue)
|
||
{
|
||
end = absenceDC.End.Value;
|
||
}
|
||
if (maxend < end)
|
||
{
|
||
end = maxend;
|
||
}
|
||
|
||
decimal tageInEinerWoche = 0; // Tage für die Ist- und Sollstunden
|
||
int wochentageVergangen = 0; // Vergangene Wochentage
|
||
while (start <= end)
|
||
{
|
||
// Wenn Wochentag Montag ist, werden Tage einer Woche resetted und die vergangenen Arbeitstage
|
||
var wochentag = start.DayOfWeek;
|
||
if (wochentag == DayOfWeek.Monday)
|
||
{
|
||
tageInEinerWoche = 0;
|
||
wochentageVergangen = 0;
|
||
}
|
||
|
||
if (!IstFeiertag(start))
|
||
{
|
||
if (wochentageVergangen < weeklyDays)
|
||
{
|
||
// Wenn nur ein halber Tag, dann..
|
||
if (start.Date == end.Date && start.TimeOfDay != end.TimeOfDay)
|
||
{
|
||
tageInEinerWoche += 0.5m;
|
||
if (tageInEinerWoche >= weeklyDays)
|
||
tage += tageInEinerWoche > weeklyDays ? 0 - tage + weeklyDays : 0.5m;
|
||
else
|
||
tage += 0.5m;
|
||
}
|
||
else
|
||
{
|
||
tageInEinerWoche++;
|
||
if (tageInEinerWoche >= weeklyDays)
|
||
tage += tageInEinerWoche > weeklyDays ? 0 - tage + weeklyDays : 1;
|
||
else
|
||
tage++;
|
||
}
|
||
}
|
||
wochentageVergangen++;
|
||
}
|
||
|
||
start = start.AddDays(1);
|
||
}
|
||
}
|
||
|
||
return tage;
|
||
}
|
||
|
||
// Methode zur Berechnung der Urlaubstage, wenn Vertrag mitten im Jahr beginnt oder endet.
|
||
// BSP: 30 Urlaubstage, Beginn am 01.06.; Dann entfallen eine bestimmte Anzahl an Tagen, das wird hier berechnet
|
||
public virtual decimal CalcCorrectNumberOfLeaveDaysForSpecialContractSituation(DateTime entryDate, DateTime? endDate, int anzahlArbeitstage, int restlicheTageImJahr, decimal? urlaubstageProJahr)
|
||
{
|
||
decimal urlaubstage = 0;
|
||
if (urlaubstageProJahr == null)
|
||
urlaubstageProJahr = 0m;
|
||
|
||
if (entryDate.Day == 1 && entryDate.Month == 1 || entryDate.Day == 2 && entryDate.Month == 1) //Erster Tag im Jahr
|
||
{
|
||
//Prüfen, ob Enddatum Ende des Jahres oder früher ist
|
||
if (endDate == null)
|
||
urlaubstage = (decimal)urlaubstageProJahr;
|
||
|
||
else if (endDate.Value.Day == 31 && endDate.Value.Month == 12)
|
||
urlaubstage = (decimal)urlaubstageProJahr;
|
||
|
||
else
|
||
{
|
||
if (anzahlArbeitstage < 5) // weniger als 5 Tage (Urlaubsanspruch / 12 Monate * Monate Arbeit) / 5 * Wochenarbeitstage
|
||
urlaubstage = (decimal)urlaubstageProJahr / 12 * (Convert.ToDecimal((endDate.Value - entryDate).TotalDays) / 30) / 5m * anzahlArbeitstage;
|
||
//urlaubstage = (decimal)urlaubstageProJahr / 5m * anzahlArbeitstage;
|
||
else
|
||
{
|
||
if (anzahlArbeitstage == 5 || anzahlArbeitstage == 6) // 5 oder 6 Tage
|
||
urlaubstage = (decimal)urlaubstageProJahr / 365m * restlicheTageImJahr;
|
||
}
|
||
}
|
||
|
||
}
|
||
else if (/*entryDate.Day > 1 && */anzahlArbeitstage < 5) // Mitten im Jahr, weniger als 5 Tage
|
||
{
|
||
urlaubstage = (decimal)urlaubstageProJahr / 5m * anzahlArbeitstage / 365m * restlicheTageImJahr;
|
||
}
|
||
else if (/*entryDate.Day > 1 && */anzahlArbeitstage >= 5) // Mitten im Jahr, 5 oder 6 Tage
|
||
{
|
||
urlaubstage = (decimal)urlaubstageProJahr / 365m * restlicheTageImJahr;
|
||
}
|
||
|
||
// Runden
|
||
urlaubstage = UrlaubstageRunden(urlaubstage);
|
||
|
||
return urlaubstage;
|
||
}
|
||
|
||
public virtual decimal UrlaubstageRunden(decimal urlaubstage)
|
||
{
|
||
if (urlaubstage - (int)urlaubstage <= 0.1m)
|
||
{
|
||
urlaubstage = Math.Round(urlaubstage, MidpointRounding.AwayFromZero);
|
||
}
|
||
else if (urlaubstage - (int)urlaubstage <= 0.5m)
|
||
{
|
||
decimal digits = urlaubstage - (int)urlaubstage;
|
||
urlaubstage = urlaubstage - digits + 0.5m;
|
||
}
|
||
else if (urlaubstage - (int)urlaubstage <= 1.0m)
|
||
{
|
||
urlaubstage = Math.Ceiling(urlaubstage);
|
||
}
|
||
|
||
return urlaubstage;
|
||
}
|
||
|
||
public decimal BerechneAnzahlUrlaubstage(AbsenceTime absence, AbsenceTimeDC absenceDC, int year, int? workdays)
|
||
{
|
||
if (absence != null)
|
||
{
|
||
if (absence.Start.HasValue)
|
||
{
|
||
decimal days = 0;
|
||
//int days = 0;
|
||
|
||
//DateTime start = absence.Start.Value;
|
||
DateTime start = (absence.Start.Value.Year == year) ? absence.Start.Value : new DateTime(year, 1, 1);
|
||
DateTime end = start;
|
||
DateTime maxend = new DateTime(year, 12, 31);
|
||
if (absence.End.HasValue)
|
||
{
|
||
end = absence.End.Value;
|
||
}
|
||
|
||
if (maxend < end)
|
||
{
|
||
end = maxend;
|
||
}
|
||
|
||
var tageInDerWoche = 0m;
|
||
while (start <= end)
|
||
{
|
||
if (start.DayOfWeek == DayOfWeek.Monday)
|
||
tageInDerWoche = 0;
|
||
if (!CheckIstWochenende(workdays, start.DayOfWeek) && !IstFeiertag(start) && tageInDerWoche < workdays.Value && tageInDerWoche + 1 <= workdays.Value)
|
||
{
|
||
if (start.Date == end.Date && start.TimeOfDay != end.TimeOfDay)
|
||
{
|
||
days += 0.5m;
|
||
tageInDerWoche += 0.5m;
|
||
}
|
||
else
|
||
{
|
||
days++;
|
||
tageInDerWoche++;
|
||
}
|
||
}
|
||
|
||
start = start.AddDays(1);
|
||
}
|
||
return (decimal)days;
|
||
}
|
||
}
|
||
|
||
else if (absenceDC != null)
|
||
{
|
||
if (absenceDC.Start.HasValue)
|
||
{
|
||
decimal days = 0;
|
||
//int days = 0;
|
||
|
||
//DateTime start = absence.Start.Value;
|
||
DateTime start = (absenceDC.Start.Value.Year == year) ? absenceDC.Start.Value : new DateTime(year, 1, 1);
|
||
DateTime end = start;
|
||
DateTime maxend = new DateTime(year, 12, 31);
|
||
if (absenceDC.End.HasValue)
|
||
{
|
||
end = absenceDC.End.Value;
|
||
}
|
||
|
||
if (maxend < end)
|
||
{
|
||
end = maxend;
|
||
}
|
||
|
||
|
||
while (start <= end)
|
||
{
|
||
if (!CheckIstWochenende(workdays, start.DayOfWeek) && !IstFeiertag(start))
|
||
{
|
||
if (start.Date == end.Date && start.TimeOfDay != end.TimeOfDay)
|
||
days += 0.5m;
|
||
else
|
||
days++;
|
||
}
|
||
|
||
start = start.AddDays(1);
|
||
}
|
||
return (decimal)days;
|
||
}
|
||
}
|
||
|
||
|
||
return 0;
|
||
}
|
||
public Dictionary<long?, decimal> BerechneAnzEinerAbwesenheitFuerMehrereMitarbeiter(List<long?> empOids, int year, string reason)
|
||
{
|
||
SetLokaleFeiertagListe(year);
|
||
|
||
EmployeeServiceImp es = new EmployeeServiceImp();
|
||
var absences = es.GetAllEmployeeAbsenceTimesForYear(year).Where(abs => abs.Reason.Description.ToLower().Contains(reason.ToLower()));
|
||
|
||
Dictionary<long?, decimal> urlaubGenommenProMitarbeiter = new Dictionary<long?, decimal>();
|
||
|
||
foreach (var oid in empOids)
|
||
{
|
||
var absencesForCurrentEmp = absences.Where(a => a.EmployeeOid == oid);
|
||
decimal tage = 0;
|
||
|
||
foreach (var abs in absencesForCurrentEmp)
|
||
{
|
||
var start = (DateTime)DateTimeExtensions.GetMax(abs.Start, new DateTime(year, 1, 1));
|
||
var end = (DateTime)DateTimeExtensions.GetMin(abs.End != null ? abs.End: new DateTime(year, 12, 31), new DateTime(year, 12, 31));
|
||
|
||
while (start <= end)
|
||
{
|
||
if (start.DayOfWeek != DayOfWeek.Saturday && start.DayOfWeek != DayOfWeek.Sunday && !_Feiertage.Contains(start))
|
||
{
|
||
if (start.Date == end.Date && start.TimeOfDay != end.TimeOfDay)
|
||
tage += 0.5m;
|
||
else
|
||
tage++;
|
||
}
|
||
|
||
|
||
start = start.AddDays(1);
|
||
}
|
||
}
|
||
|
||
urlaubGenommenProMitarbeiter.Add(oid, tage);
|
||
}
|
||
|
||
return urlaubGenommenProMitarbeiter;
|
||
}
|
||
}
|
||
}
|