933 lines
37 KiB
C#
933 lines
37 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using BeWo.Data.Access;
|
|
using BeWo.Data.Entities;
|
|
using BeWo.Report.ReportObjects;
|
|
using BeWo.Service.Dienstplanung;
|
|
using BS.Shared;
|
|
using BS.Shared.DataContracts;
|
|
|
|
namespace SHKServiceSBD
|
|
{
|
|
public class CustomMitarbeiterstundenkontoBerechnung : MitarbeiterstundenkontoBerechnung
|
|
{
|
|
private Dictionary<string, decimal> _SollStundenProTagDict = new Dictionary<string, decimal>(); //Speicher die Sollstunden aus den Betreuungszeiten des Kindes pro EmployeeOid und Tag (Key = {employee oid}_{datum])
|
|
private Organisation _Martinsschule = null;
|
|
private DateTime _BerichtsAnfang = DateTime.MinValue;
|
|
|
|
public override void CreateEmployeeDetails(MitarbeiterstundenkontoRO ro)
|
|
{
|
|
base.CreateEmployeeDetails(ro);
|
|
|
|
foreach (var ed in ro.EmployeeDetailList)
|
|
{
|
|
var c = ed.Employee.GetValidContractForDate(_BerichtsAnfang);
|
|
if (c != null)
|
|
{
|
|
ed.Custom14 = c.HourlyRate ?? 0;
|
|
ed.Custom15 = ed.Custom14 * Math.Round(ed.UeberstundenGesamt ?? 0, 2, MidpointRounding.AwayFromZero);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void StarteBerechnung(DateTime berichtsAnfang, DateTime berichtsEnde, MitarbeiterstundenkontoRO.EmployeeDetail empDetail)
|
|
{
|
|
_BerichtsAnfang = berichtsAnfang;
|
|
SucheMartinsschule();
|
|
SetzeBundesland(empDetail);
|
|
BerechneBewilligteSollZeitProWoche(empDetail, berichtsAnfang);
|
|
BerechneAlleSollZeiten(empDetail, berichtsAnfang, berichtsEnde);
|
|
|
|
}
|
|
|
|
private void SucheMartinsschule()
|
|
{
|
|
if (_Martinsschule == null)
|
|
{
|
|
_Martinsschule = DAOFactory.SearchDAO.FindOrganisation("Martinsschule", false).FirstOrDefault();
|
|
}
|
|
}
|
|
|
|
private void SetzeBundesland(MitarbeiterstundenkontoRO.EmployeeDetail empDetail)
|
|
{
|
|
string bundesland = "hessen";
|
|
|
|
//Ermittle Bundesland und geplante Sollzeit anhand der Schule des betreuten Kindes;
|
|
foreach (var e2c in empDetail.Employee.Employee2CustomerList)
|
|
{
|
|
var kind = e2c.Customer;
|
|
|
|
foreach (var c2o in kind.Customer2OrganisationList)
|
|
{
|
|
if (c2o.ValueList.Any(b => b.Entry.Type == ValueListEntryType.EnvironmentOrganisationType && IstSchule(b.Entry.Value)))
|
|
{
|
|
foreach (var vv in c2o.Organisation.VarFieldValueList)
|
|
{
|
|
if (vv.VarFieldDefOid == 1)
|
|
{
|
|
var varFieldValue = BS.Shared.Core.Utils.XMLDeserializeFromString(vv.SerializedValue, Type.GetType(vv.TypeName));
|
|
|
|
if (varFieldValue != null && varFieldValue.ToString() == "Bayern")
|
|
{
|
|
bundesland = "Bayern";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
this.vacationService.Bundesland = bundesland;
|
|
}
|
|
|
|
private bool IstTeamMartinsschule(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, DateTime stichtag)
|
|
{
|
|
var istImTeam = empDetail.Teams != null && empDetail.Teams.Any(t => t.Name == "Martinsschule");
|
|
|
|
if (istImTeam)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//Prüfe ob Vertragsart zum Stichtag "Martinsschule" ist
|
|
var c = empDetail.Employee.GetValidContractForDate(stichtag);
|
|
if (c != null && c.ContractTypeValueListEntry != null && c.ContractTypeValueListEntry.Value == "Martinsschule")
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//private IList<Arbeitszeit> GetSollArbeitszeiten(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, Customer customer)
|
|
//{
|
|
// //Prüfe ob Mitarbeiter zu Team Martinsschule gehört, dann nehme die Betreuungszeiten (Stundenplan) der Schule, sonst den des betreuten Klienten
|
|
// if (IstTeamMartinsschule(empDetail) && _Martinsschule != null)
|
|
// {
|
|
// return _Martinsschule.Arbeitszeiten;
|
|
// }
|
|
// else
|
|
// {
|
|
// return customer.Arbeitszeiten;
|
|
// }
|
|
|
|
//}
|
|
|
|
private void BerechneAlleSollZeiten(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, DateTime berichtsAnfang, DateTime berichtsEnde)
|
|
{
|
|
|
|
//Abesenheit "MA krank in der Schulzeit":
|
|
//Wenn ein Kind zugeordnet ist, dann wird die Zeit von dem entsprechenden Tag aus der Betreuungszeit genommen und bei Krank eingetragen
|
|
//Wenn ein die Ma der Martinschule zugeordnet sind, dann wird die Zeit genommen, die in der Organisation Martinschule hinterlegt ist und bei Krank eingetragen
|
|
//Wenn kein Kind zugeordnet ist, dann Vertragliche Arbeitszeit, und bei Krank eingetragen
|
|
|
|
//Prüfe Team Martinsschule
|
|
DateTime ersterVertragsStart = berichtsAnfang;
|
|
DateTime letzerVertragsEnde = berichtsEnde;
|
|
|
|
foreach (var c in empDetail.Employee.Contracts)
|
|
{
|
|
if (c.EntryDate.HasValue && c.EntryDate.Value < ersterVertragsStart)
|
|
{
|
|
ersterVertragsStart = c.EntryDate.Value;
|
|
}
|
|
}
|
|
|
|
DateTime vertragsStart = ersterVertragsStart;
|
|
DateTime vertragsEnde = letzerVertragsEnde;
|
|
|
|
var contract = empDetail.Employee.GetValidContractForDate(vertragsStart);
|
|
|
|
while (contract != null)
|
|
{
|
|
vertragsEnde = berichtsEnde;
|
|
if (contract.ContractEndDate.HasValue && contract.ContractEndDate < vertragsEnde)
|
|
{
|
|
vertragsEnde = contract.ContractEndDate.Value;
|
|
}
|
|
bool istTeamMartinsschule = IstTeamMartinsschule(empDetail, vertragsStart);
|
|
if (istTeamMartinsschule && _Martinsschule != null)
|
|
{
|
|
BerechneSollZeitenDictionary(_Martinsschule.Arbeitszeiten, empDetail, vertragsStart, vertragsEnde, false);
|
|
}
|
|
foreach (var e2c in empDetail.Employee.Employee2CustomerList)
|
|
{
|
|
var start = vertragsStart;
|
|
var ende = vertragsEnde;
|
|
|
|
if (e2c.StartDate.HasValue && e2c.StartDate > start)
|
|
{
|
|
start = e2c.StartDate.Value;
|
|
}
|
|
if (e2c.EndDate.HasValue && e2c.EndDate < ende)
|
|
{
|
|
ende = e2c.EndDate.Value;
|
|
}
|
|
|
|
if (start <= ende)
|
|
{
|
|
var kind = e2c.Customer;
|
|
|
|
BerechneSollZeitenDictionary(kind.Arbeitszeiten, empDetail, start, ende, false);
|
|
}
|
|
}
|
|
|
|
//Füge Soll für Kinder, die bei den Mitarbeiterarbeitszeiten eingetragen wurden hinzu:
|
|
BerechneSollZeitenDictionary(empDetail.Employee.Arbeitszeiten, empDetail, vertragsStart, vertragsEnde, true);
|
|
|
|
|
|
|
|
var ctemp = GetNextValidContractForDate(vertragsEnde.AddDays(1), empDetail.Employee);
|
|
if (ctemp != null && ctemp.Oid != contract.Oid)
|
|
{
|
|
contract = ctemp;
|
|
}
|
|
else
|
|
{
|
|
contract = null;
|
|
}
|
|
|
|
if (contract != null && contract.EntryDate.HasValue && contract.EntryDate >= vertragsStart)
|
|
{
|
|
vertragsStart = contract.EntryDate.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private void BerechneBewilligteSollZeitProWoche(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, DateTime datum)
|
|
{
|
|
decimal sollProWoche = 0;
|
|
if (IstTeamMartinsschule(empDetail, datum) && _Martinsschule != null)
|
|
{
|
|
sollProWoche = BerechneSollZeitFuerWoche(empDetail.Employee, _Martinsschule.Arbeitszeiten, datum);
|
|
}
|
|
foreach (var e2c in empDetail.Employee.Employee2CustomerList)
|
|
{
|
|
var kind = e2c.Customer;
|
|
sollProWoche += BerechneSollZeitFuerWoche(empDetail.Employee, kind.Arbeitszeiten, datum);
|
|
}
|
|
empDetail.Custom1 = sollProWoche;
|
|
|
|
}
|
|
|
|
private decimal BerechneSollZeitFuerWoche(Employee e, IList<Arbeitszeit> arbeitszeiten, DateTime datum)
|
|
{
|
|
decimal soll = 0;
|
|
if (arbeitszeiten != null)
|
|
{
|
|
foreach (var az in arbeitszeiten)
|
|
{
|
|
if ((!az.GueltigVon.HasValue || az.GueltigVon.Value <= datum) && (!az.GueltigBis.HasValue || az.GueltigBis.Value >= datum))
|
|
{
|
|
foreach (var ae in az.ArbeitszeitEintraege)
|
|
{
|
|
if (ae.Employee == null || ae.Employee.Oid == e.Oid)
|
|
{
|
|
soll += ae.BerechneStunden();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return soll;
|
|
|
|
}
|
|
|
|
private void BerechneSollZeitenDictionary(IList<Arbeitszeit> arbeitszeiten, MitarbeiterstundenkontoRO.EmployeeDetail empDetail, DateTime start, DateTime ende, bool arbeitszeitenSindVomMitarbeiter)
|
|
{
|
|
|
|
DateTime dt = start;
|
|
while (dt <= ende)
|
|
{
|
|
String key = String.Format("{0}_{1:yyyyMMdd}", empDetail.Employee.Oid, dt);
|
|
if (!_SollStundenProTagDict.ContainsKey(key))
|
|
{
|
|
decimal soll = 0;
|
|
bool gibtAz = false;
|
|
foreach (var az in arbeitszeiten)
|
|
{
|
|
|
|
if ((!az.GueltigVon.HasValue || az.GueltigVon.Value <= dt) && (!az.GueltigBis.HasValue || az.GueltigBis.Value >= dt))
|
|
{
|
|
if (!arbeitszeitenSindVomMitarbeiter)
|
|
{
|
|
gibtAz = true;
|
|
}
|
|
foreach (var ae in az.ArbeitszeitEintraege)
|
|
{
|
|
if (arbeitszeitenSindVomMitarbeiter)
|
|
{
|
|
//Wenn das Flag arbeitszeitenSindVomMitarbeiter gesetzt ist, werden nur Einträge geprüft, bei dem auch ein Klient zugeordnet ist
|
|
if (ae.Customer != null)
|
|
{
|
|
if (ae.IstAmGleichenWochentag(dt))
|
|
{
|
|
gibtAz = true;
|
|
soll += ae.BerechneStunden();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ae.Employee == null || ae.Employee.Oid == empDetail.Employee.Oid)
|
|
{
|
|
if (ae.IstAmGleichenWochentag(dt))
|
|
{
|
|
soll += ae.BerechneStunden();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (gibtAz)
|
|
{
|
|
_SollStundenProTagDict[key] = soll;
|
|
}
|
|
}
|
|
|
|
dt = dt.AddDays(1);
|
|
}
|
|
}
|
|
|
|
protected override decimal? GetSollNachArbeitszeiten(Employee emp, DateTime start, DateTime ende)
|
|
{
|
|
var soll = base.GetSollNachArbeitszeiten(emp, start, ende);
|
|
return soll;
|
|
if (soll == null)
|
|
{
|
|
DateTime startTemp = start;
|
|
|
|
while (startTemp < ende)
|
|
{
|
|
String key = String.Format("{0}_{1:yyyyMMdd}", emp.Oid, startTemp);
|
|
if (_SollStundenProTagDict.ContainsKey(key))
|
|
{
|
|
if (soll == null)
|
|
{
|
|
soll = 0;
|
|
}
|
|
soll += _SollStundenProTagDict[key];
|
|
}
|
|
startTemp = startTemp.AddDays(1);
|
|
}
|
|
}
|
|
|
|
return soll;
|
|
}
|
|
|
|
protected override decimal GetSollNachArbeitszeitenFuerTag(Employee emp, DateTime tag)
|
|
{
|
|
if (tag.Day == 24 && tag.Month == 12 && tag.Year == 2025)
|
|
{
|
|
|
|
}
|
|
|
|
decimal soll = 0;
|
|
var fak = GetFeiertagsFaktor(tag);
|
|
|
|
if (BerechneFeiertageAlsArbeitszeit())
|
|
{
|
|
if (fak == 1)
|
|
{
|
|
fak = 0;
|
|
}
|
|
}
|
|
|
|
if (fak < 1)
|
|
{
|
|
if (emp.Arbeitszeiten != null)
|
|
{
|
|
foreach (var az in emp.Arbeitszeiten)
|
|
{
|
|
if ((!az.GueltigVon.HasValue || az.GueltigVon.Value <= tag) &&
|
|
(!az.GueltigBis.HasValue || az.GueltigBis.Value >= tag))
|
|
{
|
|
var std = GetArbeitszeitStundenFuerTag(az, tag);
|
|
soll += (std * (1 - fak));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return soll;
|
|
}
|
|
|
|
public virtual bool IstSchule(String name)
|
|
{
|
|
if (!String.IsNullOrEmpty(name))
|
|
{
|
|
return name.ToLower().Contains("schule") || name.ToLower().Contains("kindergarten");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override bool AddServiceRecordToDuration(StundenkontoServiceRecord item)
|
|
{
|
|
if (item.ServiceDescription != null && item.ServiceDescription.Category != null)
|
|
{
|
|
if (!item.ServiceDescription.Name.Contains("Pause") && item.ServiceDescription.Name != "Zeitabzug")
|
|
{
|
|
if (item.ServiceDescription.Category.Name == "Arbeitszeit" || item.ServiceDescription.Category.Name == "Buchhaltung")
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (item.ServiceDescription.Name.Contains("Pause"))
|
|
{
|
|
int test = 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override decimal BerechneSollProWoche(Contract c, MitarbeiterstundenkontoRO.EmployeeDetail ed)
|
|
{
|
|
//if (c != null && c.MonthlyTotalHours.HasValue && c.MonthlyTotalHours.Value > 0)
|
|
//{
|
|
// if (ed != null && ed.Employee != null && ed.Employee.IsActive == ActivationTypeId.Active)
|
|
// {
|
|
// var name = ed.LastName;
|
|
// }
|
|
// var sollProWoche = Math.Round(c.MonthlyTotalHours.Value / 4.348m, 2, MidpointRounding.AwayFromZero);
|
|
// if (ed.SollProTag == 0)
|
|
// {
|
|
// ed.SollProTag = sollProWoche / 5;
|
|
// }
|
|
// return sollProWoche;
|
|
//}
|
|
|
|
return base.BerechneSollProWoche(c, ed);
|
|
}
|
|
|
|
public override void BerechneSollStundenFuerDayDetail(MitarbeiterstundenkontoRO.EmployeeDetail ed, MitarbeiterstundenkontoRO.DayDetail dd)
|
|
{
|
|
base.BerechneSollStundenFuerDayDetail(ed, dd);
|
|
|
|
}
|
|
|
|
protected override ServiceRecordSummary BerechneStunden(MitarbeiterstundenkontoRO.EmployeeDetail empDetail, IList<StundenkontoServiceRecord> groupFilteredRecords, DateTime berichtsAnfang,
|
|
DateTime berichtsEnde)
|
|
{
|
|
decimal flsGesamt = 0;
|
|
decimal arbeitszeit = 0;
|
|
|
|
var sum = new ServiceRecordSummary();
|
|
sum.RecordsImBerichtszeitraum = new List<StundenkontoServiceRecord>();
|
|
//base.CorrectOverlappingTimes(groupFilteredRecords);
|
|
|
|
foreach (var item in groupFilteredRecords)
|
|
{
|
|
if (!IsServiceRecordFehlzeit(item))
|
|
{
|
|
if (item.Start >= berichtsAnfang && item.Start < berichtsEnde)
|
|
{
|
|
//if (AddServiceRecordToDuration(item))
|
|
//{
|
|
var duration = GetDuration(item, empDetail);
|
|
|
|
|
|
if (item.ServiceDescription != null &&
|
|
item.ServiceDescription.Category != null)
|
|
{
|
|
if (item.ServiceDescription.Category.Name == "Arbeitszeit" || item.ServiceDescription.Category.Name == "Buchhaltung")
|
|
{
|
|
if (!item.ServiceDescription.Name.Contains("Pause"))
|
|
{
|
|
arbeitszeit += duration;
|
|
}
|
|
else
|
|
{
|
|
//arbeitszeit -= duration;
|
|
}
|
|
}
|
|
else if (item.ServiceDescription.Category.IsBillable)
|
|
{
|
|
flsGesamt += duration;
|
|
}
|
|
|
|
}
|
|
sum.RecordsImBerichtszeitraum.Add(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
sum.IstAbrechenbar = flsGesamt;
|
|
sum.IstNichtAbrechenbar = arbeitszeit - flsGesamt;
|
|
|
|
return sum;
|
|
}
|
|
|
|
|
|
public override IList<MitarbeiterstundenkontoRO.DayDetail> CreateDayDetails(DateTime berichtStart, DateTime berichtEnde, MitarbeiterstundenkontoRO.EmployeeDetail ed, IList<StundenkontoServiceRecord> recordsAll)
|
|
{
|
|
var list = base.CreateDayDetails(berichtStart, berichtEnde, ed, recordsAll);
|
|
foreach (var dd in list)
|
|
{
|
|
dd.PauseInMinuten = 0;
|
|
|
|
foreach (var sr in recordsAll)
|
|
{
|
|
if (sr.Start >= berichtStart && sr.Start < berichtEnde && sr.Start.Day == dd.Date.Day)
|
|
{
|
|
decimal duration = GetDuration(sr, ed);
|
|
|
|
if (sr.ServiceDescription.Name.Contains("Pause"))
|
|
{
|
|
dd.PauseInMinuten += duration;
|
|
dd.MinutesTotal -= duration;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
var absenceTimes = ed.Employee.AbsenceTimes;
|
|
|
|
if (dd.AbsenceTimes == null && absenceTimes != null)
|
|
{
|
|
foreach (var absenceTime in absenceTimes)
|
|
{
|
|
if (absenceTime.Start < dd.Date.AddDays(1) && (!absenceTime.End.HasValue || absenceTime.End >= dd.Date))
|
|
{
|
|
if (dd.AbsenceTimes == null)
|
|
{
|
|
dd.AbsenceTimes = new List<AbsenceTime>();
|
|
}
|
|
dd.AbsenceTimes.Add(absenceTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool feiertagAnrechnen = true;
|
|
if (dd.AbsenceTimes != null)
|
|
{
|
|
if (dd.Date.Year == 2024 && dd.Date.Month == 12 && dd.Date.Day == 24)
|
|
{
|
|
int test = 0;
|
|
}
|
|
foreach (var at in dd.AbsenceTimes)
|
|
{
|
|
if (IstAnrechenbareAbsenceTime(at))
|
|
{
|
|
var sollProTag = BerechneSollAmTag(ed, dd.Date);
|
|
|
|
if (at.AbsenceReason.Description.ToLower().Contains("krank in der schulzeit") ||
|
|
at.AbsenceReason.Description.ToLower().Contains("mutterschutz"))
|
|
{
|
|
if (at.AbsenceReason.Description.ToLower().Contains("mutterschutz") && IstTeamMartinsschule(ed, dd.Date))
|
|
{
|
|
//sollProTag unverändert laut Frau Hildmann am 22.04.2025
|
|
}
|
|
else
|
|
{
|
|
var key = String.Format("{0}_{1:yyyyMMdd}", ed.Employee.Oid, dd.Date);
|
|
if (_SollStundenProTagDict.ContainsKey(key))
|
|
{
|
|
sollProTag = _SollStundenProTagDict[key];
|
|
}
|
|
}
|
|
}
|
|
var faktor = GetFeiertagsFaktor(dd.Date);
|
|
if (faktor > 0)
|
|
{
|
|
if (at.AbsenceReason.Description.ToLower().Contains("krankengeld") || at.AbsenceReason.Description.ToLower().Contains("elternzeit") || at.AbsenceReason.Description.ToLower().Contains("krank ohne lohnfortzahlung"))
|
|
{
|
|
feiertagAnrechnen = false;
|
|
dd.HoursSick = sollProTag;
|
|
}
|
|
}
|
|
|
|
if (faktor < 1 && dd.Date.DayOfWeek != DayOfWeek.Saturday && dd.Date.DayOfWeek != DayOfWeek.Sunday)
|
|
{
|
|
if (IsKrankheitAbsenceTime(at))
|
|
{
|
|
dd.HoursSick = sollProTag;
|
|
}
|
|
else if (IsUrlaubAbsenceTime(at))
|
|
{
|
|
dd.HoursInVacation = sollProTag;
|
|
|
|
if (faktor > 0)
|
|
{
|
|
dd.HoursInVacation *= faktor;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dd.MinutesTotal = sollProTag * 60;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (at.AbsenceReason.Description.ToLower().Contains("eigenes kind krank") ||
|
|
at.AbsenceReason.Description.ToLower().Contains("ohne lohnfortzahlung") ||
|
|
at.AbsenceReason.Description.ToLower().Contains("elternzeit") ||
|
|
at.AbsenceReason.Description.ToLower().Contains("mutterschutz") ||
|
|
at.AbsenceReason.Description.ToLower().Contains("krankengeld") ||
|
|
at.AbsenceReason.Description.ToLower().Contains("unbezahlter urlaub"))
|
|
{
|
|
dd.Custom1 = "x"; // String.Format("{0:0.00}", ed.SollProTag * 60);
|
|
}
|
|
if (at.AbsenceReason.Description.ToLower().Contains("krankengeld") || at.AbsenceReason.Description.ToLower().Contains("elternzeit") || at.AbsenceReason.Description.ToLower().Contains("krank ohne lohnfortzahlung"))
|
|
{
|
|
feiertagAnrechnen = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (dd.Feiertag == null)
|
|
{
|
|
//var ft = GetFerienTag(dd.Date);
|
|
//if (ft != null)
|
|
//{
|
|
// dd.Feiertag = new FeiertagDC();
|
|
// dd.Feiertag.Datum = dd.Date;
|
|
// dd.Feiertag.Name = ft.Name;
|
|
//}
|
|
}
|
|
|
|
if (dd.IstFeiertag && dd.Date.DayOfWeek != DayOfWeek.Saturday && dd.Date.DayOfWeek != DayOfWeek.Sunday)
|
|
{
|
|
if (feiertagAnrechnen && HatVertrag(ed, dd.Date))
|
|
{
|
|
var soll = BerechneSollAmTag(ed, dd.Date) * 60;
|
|
soll *= GetFeiertagsFaktor(dd.Date);
|
|
if (dd.MinutesTotal <= soll)
|
|
{
|
|
dd.MinutesTotal = soll;
|
|
}
|
|
else
|
|
{
|
|
int test = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dd.MinutesTotal = 0;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public override decimal BerechneSollStundenFuerTag(MitarbeiterstundenkontoRO.EmployeeDetail ed, DateTime date)
|
|
{
|
|
if (date == new DateTime(2024, 12, 24))
|
|
{
|
|
int test = 0;
|
|
}
|
|
var soll = base.BerechneSollStundenFuerTag(ed, date);
|
|
|
|
if (soll > 0 && IstFeiertag(date))
|
|
{
|
|
var at = GetAbsenceTimeForDate(ed, date);
|
|
if (at != null)
|
|
{
|
|
if (at.AbsenceReason.Description.ToLower().Contains("krankengeld") || at.AbsenceReason.Description.ToLower().Contains("elternzeit") || at.AbsenceReason.Description.ToLower().Contains("krank ohne lohnfortzahlung"))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return soll;
|
|
}
|
|
|
|
private bool HatVertrag(MitarbeiterstundenkontoRO.EmployeeDetail ed, DateTime date)
|
|
{
|
|
return ed.Employee.GetValidContractForDate(date) != null;
|
|
}
|
|
|
|
protected override bool HatArbeitszeitImZeitraum(IList<Arbeitszeit> arbeitszeiten, DateTime start, DateTime ende)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//protected override decimal? GetSollNachArbeitszeiten(Employee emp, DateTime start, DateTime ende)
|
|
//{
|
|
// return null;
|
|
//}
|
|
|
|
//public override AbsenceTimeDays GetAbsenceTimeDaysWithWorkWeeks(Employee emp, DateTime start, DateTime end, int arbeitstageProWoche)
|
|
//{
|
|
// return base.GetAbsenceTimeDaysWithWorkWeeks(emp.AbsenceTimes, start, end, arbeitstageProWoche);
|
|
|
|
//}
|
|
|
|
public override bool IstAnrechenbareAbsenceTime(AbsenceTime item)
|
|
{
|
|
if (item.AbsenceReason.Description.ToLower().Contains("freizeitausgleich") ||
|
|
item.AbsenceReason.Description.ToLower().Contains("krank in der freistellung") ||
|
|
item.AbsenceReason.Description.ToLower().Contains("krank beweglicher ") ||
|
|
item.AbsenceReason.Description.ToLower().Contains("unbezahlter urlaub") ||
|
|
item.AbsenceReason.Description.ToLower().Contains("interner termin") ||
|
|
item.AbsenceReason.Description.ToLower().Contains("krankengeld") ||
|
|
//item.AbsenceReason.Description.ToLower().Contains("mutterschutz") ||
|
|
item.AbsenceReason.Description.ToLower().Contains("elternzeit"))
|
|
{
|
|
return false;
|
|
}
|
|
return base.IstAnrechenbareAbsenceTime(item);
|
|
}
|
|
|
|
public override bool IsKrankheitAbsenceTime(AbsenceTime item)
|
|
{
|
|
if (item.AbsenceReason.Description.ToLower().Contains("beschäftigungsverbot"))
|
|
{
|
|
return true;
|
|
}
|
|
if (item.AbsenceReason.Description.ToLower().IndexOf("unbezahlter urlaub") >= 0)
|
|
{
|
|
return false;
|
|
}
|
|
if (item.AbsenceReason.Description.ToLower().IndexOf("krankengeld") >= 0)
|
|
{
|
|
return false;
|
|
}
|
|
return base.IsKrankheitAbsenceTime(item);
|
|
}
|
|
|
|
public override bool IsUrlaubAbsenceTime(AbsenceTime item)
|
|
{
|
|
if ((item.AbsenceReason.Description.ToLower().IndexOf("krank") >= 0))
|
|
{
|
|
return false;
|
|
}
|
|
return base.IsUrlaubAbsenceTime(item);
|
|
}
|
|
|
|
public override bool SollPauseBerechnen()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public override bool ShouldCreateDayDetails()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public override bool BerechneFeiertageAlsArbeitszeit()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public override bool AbsenceTimeAufIstStundenAddieren(AbsenceTime at)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override decimal GetArbeitstageImBereich(DateTime von, DateTime bis, Employee emp)
|
|
{
|
|
DateTime start = von;
|
|
DateTime end = bis;
|
|
|
|
TimeSpan ts = end.Subtract(start);
|
|
|
|
var maxDays = (decimal)ts.TotalDays;
|
|
|
|
while (start < end)
|
|
{
|
|
int arbeitstageProWoche = 5;
|
|
|
|
var c = GetContractForDate(emp, start, start);
|
|
|
|
if (c != null && c.WeeklyDays.HasValue && c.WeeklyDays > 0)
|
|
{
|
|
arbeitstageProWoche = c.WeeklyDays.Value;
|
|
}
|
|
|
|
|
|
if (arbeitstageProWoche <= 5 && (start.DayOfWeek == DayOfWeek.Saturday || start.DayOfWeek == DayOfWeek.Sunday))
|
|
{
|
|
maxDays -= 1;
|
|
}
|
|
else if (arbeitstageProWoche == 6 && start.DayOfWeek == DayOfWeek.Sunday)
|
|
{
|
|
maxDays -= 1;
|
|
}
|
|
else
|
|
{
|
|
var istArbeitstag = true;
|
|
|
|
if (arbeitstageProWoche < 5)
|
|
{
|
|
//Wenn Tage < 5 hole die zu arbeitenden Wochentage aus dem Stundenplan des betreuten Kindes
|
|
|
|
decimal stundenAnDiesemTag = 0;
|
|
foreach (var e2c in emp.Employee2CustomerList)
|
|
{
|
|
if ((!e2c.StartDate.HasValue || e2c.StartDate.Value.Date <= start.Date) && (!e2c.EndDate.HasValue || e2c.EndDate.Value.Date >= start.Date))
|
|
{
|
|
var kind = e2c.Customer;
|
|
|
|
foreach (var az in kind.Arbeitszeiten)
|
|
{
|
|
if ((!az.GueltigVon.HasValue || az.GueltigVon.Value.Date <= start.Date) && (!az.GueltigBis.HasValue || az.GueltigBis.Value.Date >= start.Date))
|
|
{
|
|
istArbeitstag = false;
|
|
foreach (var ae in az.ArbeitszeitEintraege)
|
|
{
|
|
if (ae.Customer == null || ae.Customer.Oid == kind.Oid)
|
|
{
|
|
if (ae.IstAmGleichenWochentag(start))
|
|
{
|
|
stundenAnDiesemTag += ae.BerechneStunden();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (stundenAnDiesemTag > 0)
|
|
{
|
|
istArbeitstag = true;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
if (!istArbeitstag)
|
|
{
|
|
maxDays--; // Kein Arbeitstag, also Anzahl um eins verringern
|
|
}
|
|
}
|
|
|
|
if (istArbeitstag)
|
|
{
|
|
foreach (var at in emp.AbsenceTimes)
|
|
{
|
|
if (at.AbsenceReason.Description.ToLower().Contains("unbezahlter urlaub") || at.AbsenceReason.Description.ToLower().Contains("krankengeld") || at.AbsenceReason.Description.ToLower().Contains("elternzeit"))
|
|
{
|
|
if (at.Start.Value <= start && (!at.End.HasValue || at.End.Value >= start))
|
|
{
|
|
if (maxDays >= 1)
|
|
{
|
|
maxDays--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
start = start.AddDays(1);
|
|
}
|
|
return maxDays;
|
|
|
|
|
|
}
|
|
|
|
public override decimal? GetSollStundenForAbsenceTime(MitarbeiterstundenkontoRO.EmployeeDetail ed, AbsenceTime at, DateTime datum)
|
|
{
|
|
if (at.AbsenceReason.Description.Contains("krank in der Schulzeit") || at.AbsenceReason.Description.Contains("Mutterschutz"))
|
|
{
|
|
var key = String.Format("{0}_{1:yyyyMMdd}", ed.Employee.Oid, datum);
|
|
if (_SollStundenProTagDict.ContainsKey(key))
|
|
{
|
|
return _SollStundenProTagDict[key];
|
|
}
|
|
}
|
|
|
|
return base.GetSollStundenForAbsenceTime(ed, at, datum);
|
|
|
|
}
|
|
|
|
public override decimal BerechneStundenDurchAbwesenheiten(AbsenceTimeDays ath, DateTime start, DateTime ende, Contract c, MitarbeiterstundenkontoRO.EmployeeDetail ed)
|
|
{
|
|
if (ath.StundenGesamt.HasValue)
|
|
{
|
|
return ath.StundenGesamt.Value;
|
|
}
|
|
return base.BerechneStundenDurchAbwesenheiten(ath, start, ende, c, ed);
|
|
}
|
|
|
|
public override MitarbeiterstundenkontoRO.DayDetail CreateDayDetail(DateTime date, MitarbeiterstundenkontoRO.EmployeeDetail ed)
|
|
{
|
|
var dd = base.CreateDayDetail(date, ed);
|
|
dd.MaxHoursUntilBreak = null;
|
|
dd.MaxHoursUntilBreak2 = null;
|
|
dd.BreakMinutes = null;
|
|
dd.BreakMinutes2 = null;
|
|
return dd;
|
|
}
|
|
|
|
protected override decimal GetDuration(StundenkontoServiceRecord sr, MitarbeiterstundenkontoRO.EmployeeDetail ed)
|
|
{
|
|
var d = base.GetDuration(sr, ed);
|
|
|
|
if (sr.ServiceDescription.Category.Name == "Buchhaltung" && sr.ServiceDescription.Name.Contains("negativ"))
|
|
{
|
|
d *= -1;
|
|
}
|
|
|
|
if (sr.ServiceDescription.Name.Contains("Pause"))
|
|
{
|
|
int test = 0;
|
|
}
|
|
|
|
return d;
|
|
}
|
|
|
|
public override decimal GetFeiertagsFaktor(DateTime start)
|
|
{
|
|
//if (GetFerienTag(start) != null)
|
|
//{
|
|
// return 1;
|
|
//}
|
|
if (start.Month == 12)
|
|
{
|
|
if (start.Day == 24 || start.Day == 31)
|
|
{
|
|
return 0.5m;
|
|
}
|
|
}
|
|
|
|
return base.GetFeiertagsFaktor(start);
|
|
}
|
|
|
|
public override decimal BerechnePauseMinuten(IList<StundenkontoServiceRecord> srListAlle)
|
|
{
|
|
var srList = srListAlle.Where(s => s.ServiceDescription.Category.Name == "Arbeitszeit");
|
|
decimal pausenZeit = 0;
|
|
|
|
List<StundenkontoServiceRecord> pausen = new List<StundenkontoServiceRecord>();
|
|
List<StundenkontoServiceRecord> nichtpausen = new List<StundenkontoServiceRecord>();
|
|
|
|
foreach (var sr in srList)
|
|
{
|
|
if (sr.ServiceDescription.Name.Contains("Pause"))
|
|
{
|
|
pausen.Add(sr);
|
|
}
|
|
else
|
|
{
|
|
nichtpausen.Add(sr);
|
|
}
|
|
}
|
|
|
|
foreach (var pause in pausen)
|
|
{
|
|
pausenZeit += pause.RoundedDuration;
|
|
}
|
|
return pausenZeit;
|
|
}
|
|
|
|
protected override bool StundenDurchAbwesenheitenDuerfenNegativSein()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public FerienDC GetFerienTag(DateTime start)
|
|
{
|
|
return vacationService.GetFerien(start, vacationService.Bundesland);
|
|
}
|
|
|
|
}
|
|
} |