384 lines
13 KiB
C#
384 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
using BeWo.Data.Access;
|
|
using BeWo.Data.Entities;
|
|
using BeWo.Service.DCEntityMapper;
|
|
|
|
using BS.Shared;
|
|
using BS.Shared.Core;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.Extensions;
|
|
using DevExpress.Mvvm.Native;
|
|
|
|
namespace BeWo.Service.Plugins
|
|
{
|
|
public class SchulbegleitenderDienstService : AbstractIDSpecificDefaultClass<SchulbegleitenderDienstService>
|
|
{
|
|
public virtual SbdConfigDC GetSbdConfig()
|
|
{
|
|
var feiertage = DAOFactory.GenericDAO.GetAllActive<Feiertag>();
|
|
var stundensaetze = DAOFactory.SearchDAO.FindDefaultHourlyRateCostRatePeriods();
|
|
|
|
var dc = new SbdConfigDC();
|
|
dc.FreieTage = MapperFactory.FeiertagDC_Feiertag.MapToNewDCs(feiertage);
|
|
|
|
//if (dc.FreieTage.Count == 0)
|
|
//{
|
|
dc.FreieTage.AddRange(ErstelleDefaultFeiertage(DateTime.Now.Year));
|
|
//}
|
|
|
|
dc.Stundensaetze = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(stundensaetze);
|
|
|
|
return dc;
|
|
}
|
|
|
|
public virtual List<FeiertagDC> ErstelleDefaultFeiertage(int year)
|
|
{
|
|
var vs = PluginLoader.FindClass<VacationService>();
|
|
|
|
var list = vs.GetFeiertage(year, "NRW");
|
|
foreach (var f in list)
|
|
{
|
|
f.FeiertagOid = 0;
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
public virtual void SaveSbdConfig(SbdConfigDC config)
|
|
{
|
|
var alteStundensaetze = DAOFactory.SearchDAO.FindDefaultHourlyRateCostRatePeriods();
|
|
|
|
if (config.Stundensaetze == null || config.Stundensaetze.Count == 0)
|
|
{
|
|
DAOFactory.GenericDAO.Delete(alteStundensaetze);
|
|
}
|
|
else
|
|
{
|
|
var toDelete = alteStundensaetze.Where(s => config.Stundensaetze.Count(a => a.CostRatePeriodOid.HasValue && a.CostRatePeriodOid.Value == s.Oid.Value) == 0);
|
|
DAOFactory.GenericDAO.Delete(toDelete);
|
|
|
|
foreach (var s in config.Stundensaetze)
|
|
{
|
|
if (!s.CostRatePeriodOid.HasValue)
|
|
{
|
|
var newEntity = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewEntity(s);
|
|
DAOFactory.GenericDAO.Insert(newEntity);
|
|
}
|
|
else
|
|
{
|
|
var oldEntity = alteStundensaetze.FirstOrDefault(a => a.Oid.Value == s.CostRatePeriodOid.Value);
|
|
MapperFactory.CostRatePeriodDC_CostRatePeriod.MergeWithEntity(s, oldEntity);
|
|
DAOFactory.GenericDAO.Update(oldEntity);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
var dbFeiertage = DAOFactory.GenericDAO.GetAllActive<Feiertag>();
|
|
|
|
var neueFeiertage = config.FreieTage.Where(f => !f.FeiertagOid.HasValue || f.FeiertagOid.Value > 0).ToList();
|
|
|
|
if (neueFeiertage.Count == 0)
|
|
{
|
|
DAOFactory.GenericDAO.Delete(dbFeiertage);
|
|
}
|
|
else
|
|
{
|
|
var toDelete = dbFeiertage.Where(s => neueFeiertage.Count(a => a.FeiertagOid.HasValue && a.FeiertagOid.Value == s.Oid.Value) == 0);
|
|
DAOFactory.GenericDAO.Delete(toDelete);
|
|
|
|
foreach (var s in neueFeiertage)
|
|
{
|
|
if (!s.FeiertagOid.HasValue)
|
|
{
|
|
var newEntity = MapperFactory.FeiertagDC_Feiertag.MapToNewEntity(s);
|
|
DAOFactory.GenericDAO.Insert(newEntity);
|
|
}
|
|
else
|
|
{
|
|
var oldEntity = dbFeiertage.FirstOrDefault(a => a.Oid.Value == s.FeiertagOid.Value);
|
|
MapperFactory.FeiertagDC_Feiertag.MergeWithEntity(s, oldEntity);
|
|
DAOFactory.GenericDAO.Update(oldEntity);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//oids = Liste von EmployeeOids
|
|
public virtual String CreateDefaultServiceRecords(DateTime monat, IList<long> oids)
|
|
{
|
|
int customerCount = 0;
|
|
String message = "";
|
|
var employees = DAOFactory.GenericDAO.LoadByIDs<Employee>(oids);
|
|
|
|
var vs = PluginLoader.FindClass<VacationService>();
|
|
foreach (var e in employees)
|
|
{
|
|
foreach (var e2c in e.Employee2CustomerList)
|
|
{
|
|
if (HasValidRelation(e2c))
|
|
{
|
|
var c = e2c.Customer;
|
|
|
|
foreach (var sc in c.SupportConcepts)
|
|
{
|
|
foreach (var c2s in sc.CostBearer2SupportConceptList)
|
|
{
|
|
if (c2s.ApprovedStartDate.HasValue && c2s.ApprovedEndDate.HasValue)
|
|
{
|
|
if (c2s.ApprovedStartDate < monat.AddMonths(1) && c2s.ApprovedEndDate >= monat)
|
|
{
|
|
if (CreateDefaultServiceRecords(monat, e, c, sc, c2s, vs) > 0)
|
|
{
|
|
customerCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
message = String.Format("Es wurden Einträge für {0} KlientInnen erstellt.", customerCount);
|
|
return message;
|
|
}
|
|
|
|
protected virtual bool HasValidRelation(Employee2Customer e2C)
|
|
{
|
|
foreach (var v2o in e2C.ValueList)
|
|
{
|
|
if (v2o.Entry.Type == ValueListEntryType.StaffRoleType && v2o.Entry.Value == "ehemalige Betreuung")
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected virtual int CreateDefaultServiceRecords(DateTime monat, Employee e, Customer c, SupportConcept sc, CostBearer2SupportConcept c2s, VacationService vs)
|
|
{
|
|
DateTimeSpan span = new DateTimeSpan();
|
|
span.StartDateTime = monat;
|
|
span.EndDateTime = monat.AddMonths(1).AddTicks(-1);
|
|
|
|
var srList = DAOFactory.SearchDAO.FindServiceRecordsInSpan(c2s.Oid.Value, span).ToList();
|
|
|
|
if (srList.Count == 0)
|
|
{
|
|
|
|
srList = ErstelleStundenplanEintraege(span.StartDateTime.Date, span.EndDate.Date, e, c, sc, c2s, vs);
|
|
|
|
DAOFactory.GenericDAO.Insert(srList);
|
|
|
|
return srList.Count;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
private List<ServiceRecord> ErstelleStundenplanEintraege(DateTime start, DateTime ende, Employee emp, Customer customer, SupportConcept sc, CostBearer2SupportConcept c2s, VacationService vs)
|
|
{
|
|
var stundenplan = GetStundenplan(customer, start, ende);
|
|
|
|
List<ServiceRecord> details = new List<ServiceRecord>();
|
|
|
|
var defaultSd = GetDefaultServiceDescription(emp, customer, c2s);
|
|
|
|
while (start <= ende)
|
|
{
|
|
var ferien = vs.GetFerien(start, "nrw");
|
|
var ft = vs.GetFeiertag(start);
|
|
|
|
if (ferien == null && ft == null)
|
|
{
|
|
var newServiceRecords = CreateServiceRecords(stundenplan, start, emp, customer, c2s, sc, defaultSd);
|
|
|
|
details.AddRange(newServiceRecords);
|
|
|
|
}
|
|
|
|
start = start.AddDays(1);
|
|
}
|
|
|
|
return details;
|
|
}
|
|
|
|
protected virtual IList<ServiceRecord> CreateServiceRecords(Arbeitszeit arbeitszeit, DateTime datum, Employee emp, Customer c, CostBearer2SupportConcept c2s, SupportConcept sc, ServiceDescription defaultSd)
|
|
{
|
|
var records = new List<ServiceRecord>();
|
|
|
|
if (arbeitszeit != null && arbeitszeit.ArbeitszeitEintraege != null)
|
|
{
|
|
foreach (var ae in arbeitszeit.ArbeitszeitEintraege)
|
|
{
|
|
if (IsSameWeekday(ae, datum.DayOfWeek))
|
|
{
|
|
ServiceRecord sr = new ServiceRecord();
|
|
sr.Start = GetDateTime(ae.UhrzeitVon, datum);
|
|
sr.End = GetDateTime(ae.UhrzeitBis, datum);
|
|
sr.RoundedDuration = (decimal)sr.End.Value.Subtract(sr.Start.Value).TotalMinutes;
|
|
|
|
if (ae.Employee != null)
|
|
{
|
|
sr.Employee = ae.Employee;
|
|
}
|
|
else
|
|
{
|
|
sr.Employee = emp;
|
|
}
|
|
|
|
sr.Customer = c;
|
|
sr.SupportConcept = sc;
|
|
sr.CostBearer2SupportConcept = c2s;
|
|
sr.ServiceDescription = defaultSd;
|
|
|
|
sr.ServiceRecordType = ServiceRecordTypeId.DefaultActivity;
|
|
sr.DistanceInMeter = 0;
|
|
sr.DurationInStunden = ZeiterfassungsDauer.Minuten;
|
|
sr.ServiceRecordFormat = ServiceRecordFormate.OriginaleZeiterfassung;
|
|
sr.Relevance = 0;
|
|
records.Add(sr);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return records;
|
|
|
|
|
|
}
|
|
|
|
public virtual ServiceDescription GetDefaultServiceDescription(Employee emp, Customer customer, CostBearer2SupportConcept c2s)
|
|
{
|
|
foreach (var ap in c2s.ApprovalPeriodList)
|
|
{
|
|
if (ap.ServiceCategory != null)
|
|
{
|
|
var desc = DAOFactory.SearchDAO.FindServiceDescriptionForCategory(ap.ServiceCategory.Oid.Value);
|
|
|
|
var sd = desc.OrderBy(a => a.Position).FirstOrDefault();
|
|
|
|
if (sd != null)
|
|
{
|
|
return sd;
|
|
}
|
|
}
|
|
}
|
|
return GetDefaultServiceDescription();
|
|
}
|
|
|
|
public virtual ServiceDescription GetDefaultServiceDescription()
|
|
{
|
|
return DAOFactory.GenericDAO.LoadByID<ServiceDescription>(1);
|
|
}
|
|
|
|
private Arbeitszeit GetStundenplan(Customer customer, DateTime start, DateTime ende)
|
|
{
|
|
if (customer == null)
|
|
{
|
|
return null;
|
|
}
|
|
var stundenplan = SucheStundenplan(customer.Arbeitszeiten, start, ende);
|
|
|
|
|
|
if (stundenplan == null)
|
|
{
|
|
//Kein Stundenplan hinterlegt, suche Stundenplan bei der Organisation (Schule)
|
|
var org = SucheSchule(customer);
|
|
|
|
if (org != null)
|
|
{
|
|
return SucheStundenplan(org.Arbeitszeiten, start, ende);
|
|
}
|
|
|
|
}
|
|
|
|
return stundenplan;
|
|
}
|
|
|
|
private static Arbeitszeit SucheStundenplan(IList<Arbeitszeit> arbeitszeiten, DateTime start, DateTime ende)
|
|
{
|
|
if (arbeitszeiten != null && arbeitszeiten.Count > 0)
|
|
{
|
|
foreach (var az in arbeitszeiten)
|
|
{
|
|
if ((!az.GueltigVon.HasValue || az.GueltigVon <= ende) && (!az.GueltigBis.HasValue || az.GueltigBis >= start))
|
|
{
|
|
return az;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static Organisation SucheSchule(Customer customer)
|
|
{
|
|
foreach (var c2o in customer.Customer2OrganisationList)
|
|
{
|
|
foreach (var v2o in c2o.ValueList)
|
|
{
|
|
if (v2o.Entry.Value != null && v2o.Entry.Value.Contains("Schule"))
|
|
{
|
|
return c2o.Organisation;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static bool IsSameWeekday(ArbeitszeitEintrag ae, DayOfWeek day)
|
|
{
|
|
if (day == DayOfWeek.Monday && ae.Tag == AppointmentDayOfWeek.Montag)
|
|
{
|
|
return true;
|
|
}
|
|
if (day == DayOfWeek.Tuesday && ae.Tag == AppointmentDayOfWeek.Dienstag)
|
|
{
|
|
return true;
|
|
}
|
|
if (day == DayOfWeek.Wednesday && ae.Tag == AppointmentDayOfWeek.Mittwoch)
|
|
{
|
|
return true;
|
|
}
|
|
if (day == DayOfWeek.Thursday && ae.Tag == AppointmentDayOfWeek.Donnerstag)
|
|
{
|
|
return true;
|
|
}
|
|
if (day == DayOfWeek.Friday && ae.Tag == AppointmentDayOfWeek.Freitag)
|
|
{
|
|
return true;
|
|
}
|
|
if (day == DayOfWeek.Saturday && ae.Tag == AppointmentDayOfWeek.Samstag)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static DateTime? GetDateTime(String timeAsString, DateTime date)
|
|
{
|
|
String dateStr = String.Format("{0:dd.MM.yyyy} {1}", date, timeAsString);
|
|
|
|
DateTime dateOut;
|
|
|
|
if (DateTime.TryParse(dateStr, out dateOut))
|
|
{
|
|
return dateOut;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
} |