760 lines
36 KiB
C#
760 lines
36 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.Extensions;
|
|
using BS.Shared.Services;
|
|
|
|
namespace BeWo.Service.Plugins
|
|
{
|
|
public class ServiceRecordStatisticFactory : AbstractIDSpecificDefaultClass<ServiceRecordStatisticFactory>
|
|
{
|
|
public virtual ServiceRecordStatisticsInfoDC GetServiceRecordStatisticInfo(long costBearer2SupportConceptOid, DateTime statisticsDate)
|
|
{
|
|
return null;
|
|
//if (costBearer2SupportConceptOid == 1)
|
|
//{
|
|
// var dc = new ServiceRecordStatisticsInfoDC();
|
|
// dc.Header = new string[5];
|
|
// dc.Header[0] = "Bewilligungszeitraum:";
|
|
// dc.Header[1] = "Test1:";
|
|
// dc.Header[2] = "Test2:";
|
|
// dc.Header[3] = "Test3:";
|
|
// dc.Header[4] = "Test4:";
|
|
// dc.ForegroundColor = new string[5];
|
|
// dc.ForegroundColor[0] = "#FFFF00";
|
|
// dc.ForegroundColor[1] = "#FF0000";
|
|
// dc.ForegroundColor[2] = "#FF00FF";
|
|
// dc.ForegroundColor[3] = "#00FF00";
|
|
// dc.ForegroundColor[4] = "#0000FF";
|
|
|
|
// dc.PeriodStatisticInfos = new List<ServiceRecordPeriodStatisticsInfoDC>();
|
|
|
|
// var pdc = new ServiceRecordPeriodStatisticsInfoDC();
|
|
// dc.PeriodStatisticInfos.Add(pdc);
|
|
// pdc.LeftValues = new string[5];
|
|
// pdc.LeftValues[0] = "Überschrift blablabla";
|
|
// pdc.LeftValues[1] = "456";
|
|
// pdc.LeftValues[2] = "789";
|
|
// pdc.LeftValues[3] = "093";
|
|
// pdc.LeftValues[4] = "56352";
|
|
|
|
// pdc.RightValues = new string[5];
|
|
// pdc.RightValues[0] = "";
|
|
// pdc.RightValues[1] = "45,36";
|
|
// pdc.RightValues[2] = "789,00";
|
|
// pdc.RightValues[3] = "093";
|
|
// pdc.RightValues[4] = "56352";
|
|
|
|
// pdc.LeftValueColors = new string[5];
|
|
// pdc.LeftValueColors[0] = "#888800";
|
|
// pdc.LeftValueColors[1] = "#880000";
|
|
// pdc.LeftValueColors[2] = "#880088";
|
|
// pdc.LeftValueColors[3] = "#008800";
|
|
// pdc.LeftValueColors[4] = "#000088";
|
|
|
|
// pdc.RightValueColors = new string[5];
|
|
// pdc.RightValueColors[0] = "#888800";
|
|
// pdc.RightValueColors[1] = "#880000";
|
|
// pdc.RightValueColors[2] = "#880088";
|
|
// pdc.RightValueColors[3] = "#008800";
|
|
// pdc.RightValueColors[4] = "#000088";
|
|
|
|
// pdc = new ServiceRecordPeriodStatisticsInfoDC();
|
|
// dc.PeriodStatisticInfos.Add(pdc);
|
|
// pdc.LeftValues = new string[5];
|
|
// pdc.LeftValues[0] = "xxxx";
|
|
// pdc.LeftValues[1] = "456";
|
|
// pdc.LeftValues[2] = "789";
|
|
// pdc.LeftValues[3] = "093";
|
|
// pdc.LeftValues[4] = "56352";
|
|
|
|
// pdc.RightValues = new string[5];
|
|
// pdc.RightValues[0] = "yyyyy";
|
|
// pdc.RightValues[1] = "45,36";
|
|
// pdc.RightValues[2] = "789,00";
|
|
// pdc.RightValues[3] = "093";
|
|
// pdc.RightValues[4] = "56352";
|
|
|
|
// pdc.LeftValueColors = new string[5];
|
|
// pdc.LeftValueColors[0] = "#088800";
|
|
// pdc.LeftValueColors[1] = "#080000";
|
|
// pdc.LeftValueColors[2] = "#080088";
|
|
// pdc.LeftValueColors[3] = "#808800";
|
|
// pdc.LeftValueColors[4] = "#800088";
|
|
|
|
// pdc.RightValueColors = new string[5];
|
|
// pdc.RightValueColors[0] = "#488800";
|
|
// pdc.RightValueColors[1] = "#480000";
|
|
// pdc.RightValueColors[2] = "#480088";
|
|
// pdc.RightValueColors[3] = "#408800";
|
|
// pdc.RightValueColors[4] = "#400088";
|
|
|
|
// return dc;
|
|
//}
|
|
}
|
|
|
|
public virtual SupportConceptStatisticsDC CreateSupportConceptStatistics(long costBearer2SupportConceptOid, DateTime statisticsDate)
|
|
{
|
|
return CreateSupportConceptStatisticsImpl(costBearer2SupportConceptOid, statisticsDate);
|
|
}
|
|
|
|
public virtual SupportConceptStatisticsDC CreateSupportConceptStatisticsImpl(long costBearer2SupportConceptOid, DateTime statisticsDate)
|
|
{
|
|
return CreateSupportConceptStatisticsImpl(costBearer2SupportConceptOid, statisticsDate, null);
|
|
}
|
|
|
|
public virtual SupportConceptStatisticsDC CreateSupportConceptStatisticsImpl(long costBearer2SupportConceptOid, DateTime statisticsDate, long? ignoreServiceRecordOid)
|
|
{
|
|
|
|
var stats = new SupportConceptStatisticsDC();
|
|
stats.PeriodStatistics = new List<SupportConceptPeriodStatisticsDC>();
|
|
stats.DateOfCreation = statisticsDate;
|
|
|
|
var cb2sc = DAOFactory.GenericDAO.LoadByID<CostBearer2SupportConcept>(costBearer2SupportConceptOid);
|
|
if (cb2sc.SupportConcept.Customer.Person.FirstName == "Ilona ")
|
|
{
|
|
int test = 0;
|
|
}
|
|
var relDc = CreateCb2ScDC(cb2sc);
|
|
var calc = PluginLoader.FindClass<Calculations>(cb2sc.CostBearer.ID) ?? Calculations.GetInstance(cb2sc.CostBearer.ID);
|
|
|
|
stats.StatisticsStartDate = relDc.StartDate ?? DateTime.MinValue;
|
|
stats.StatisticsEndDate = relDc.EndDate ?? DateTime.MaxValue;
|
|
|
|
var serviceUnit = relDc.CostBearer.CostRatePeriods.GetCostRatePeriodForDate(CostRatePeriodType.MinutesPerServiceUnit, statisticsDate);
|
|
stats.ServiceUnitName = serviceUnit.UnitName;
|
|
|
|
var minutesApprovedTotal = (calc.GetApprovedHoursTotal(relDc, true) ?? 0m) * 60m;
|
|
stats.MinutesApprovedTotal = minutesApprovedTotal;
|
|
stats.MinutesApprovedPerWeek = (calc.GetApprovedHoursPerWeek(relDc, statisticsDate) ?? 0m) * 60m;
|
|
stats.ApprovedMinutesTillNow = calc.GetApprovedHoursTillNow(relDc, statisticsDate) * 60m;
|
|
|
|
// Hier die Periods zusammenfassen, die identische Zeiträume und identische Leistungskategorien haben.
|
|
foreach (var periodDC in relDc.ApprovalPeriodList)
|
|
{
|
|
var periodStats = CreatePeriodStatisticsDC(relDc, periodDC, calc, statisticsDate);
|
|
|
|
// Wenn Bewilligungdatum und Leistungskategorie identisch ist sollen die Statistiken zusammengefasst werden, anstatt getrennt ausgeschrieben
|
|
if (periodDC.StartDate != null && periodDC.EndDate != null)
|
|
{
|
|
var vorhandeneStatistik = stats.PeriodStatistics != null && stats.PeriodStatistics.Count > 0 ?
|
|
stats.PeriodStatistics.FirstOrDefault(ps => periodDC.StartDate >= ps.SupportConceptApprovalPeriod.StartDate &&
|
|
periodDC.EndDate <= ps.SupportConceptApprovalPeriod.EndDate && ps.SupportConceptApprovalPeriod.ServiceCategory == periodDC.ServiceCategory) : null;
|
|
|
|
if (vorhandeneStatistik != null)
|
|
{
|
|
vorhandeneStatistik = SummarizeStats(vorhandeneStatistik, periodStats);
|
|
}
|
|
else
|
|
{
|
|
stats.PeriodStatistics.Add(periodStats);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
stats.PeriodStatistics.Add(periodStats);
|
|
}
|
|
}
|
|
|
|
SortStatistics(stats);
|
|
var serviceRecords = GetServiceRecordsForStatistic(costBearer2SupportConceptOid);
|
|
var serviceRecordsProcessed = new Dictionary<long, bool>();
|
|
if (ignoreServiceRecordOid.HasValue)
|
|
{
|
|
serviceRecordsProcessed.Add(ignoreServiceRecordOid.Value, true);
|
|
}
|
|
|
|
foreach (var sr in serviceRecords)
|
|
{
|
|
if (!serviceRecordsProcessed.ContainsKey(sr.Oid.Value))
|
|
{
|
|
ProcessServiceRecord(sr, cb2sc, stats, statisticsDate, calc);
|
|
serviceRecordsProcessed.Add(sr.Oid.Value, true);
|
|
}
|
|
}
|
|
|
|
|
|
if (relDc.EndDate.HasValue)
|
|
{
|
|
DateTime dt = statisticsDate.Date;
|
|
if (relDc.StartDate.HasValue && relDc.StartDate > dt)
|
|
{
|
|
dt = relDc.StartDate.Value;
|
|
}
|
|
|
|
TimeSpan ts = relDc.EndDate.Value.Subtract(dt);
|
|
int days = ts.Days + 1;
|
|
if (days > 0)
|
|
{
|
|
stats.MinutesFreePerWeekAverage = (stats.MinutesApprovedTotal - stats.MinutesProvidedTotalRounded) / (days / 7m);
|
|
|
|
foreach (var ps in stats.PeriodStatistics)
|
|
{
|
|
if (ps.SupportConceptApprovalPeriod.StartDate.HasValue && ps.SupportConceptApprovalPeriod.EndDate.HasValue)
|
|
{
|
|
DateTime dtPeriod = statisticsDate.Date;
|
|
if (ps.SupportConceptApprovalPeriod.StartDate.HasValue && ps.SupportConceptApprovalPeriod.StartDate > dtPeriod)
|
|
{
|
|
dtPeriod = ps.SupportConceptApprovalPeriod.StartDate.Value;
|
|
}
|
|
TimeSpan tsPeriod = ps.SupportConceptApprovalPeriod.EndDate.Value.Subtract(dtPeriod);
|
|
int daysPeriod = tsPeriod.Days + 1;
|
|
if (daysPeriod < 0)
|
|
{
|
|
daysPeriod = 0;
|
|
}
|
|
// Standard - Stunden für ausgewähltes Intervall x/Woche etce
|
|
if (ps.SupportConceptApprovalPeriod.ApprovedBEPerInterval != null)
|
|
{
|
|
if (ps.SupportConceptApprovalPeriod.IsApprovedBEShifting) // Standardfall - Übertragbare Bewilligung mit Stunden für ausgewähltes Intervall x/Woche etc
|
|
{
|
|
if (daysPeriod != 0)
|
|
{
|
|
ps.MinutesFreePerWeek = (ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded) / (daysPeriod / 7m);
|
|
ps.MinutesFreePerWeekStatisticDate = (ps.MinutesApprovedTotal - ps.IstTotalUntilThisMonth - ps.MinutesProvidedThisMonth) / (daysPeriod / 7m);
|
|
ps.MinutesFreePerMonth = (ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded) / (daysPeriod / 7m) * (365m / 84m);
|
|
ps.MinutesFreePerMonthStatisticDate = (ps.MinutesApprovedTotal - ps.IstTotalUntilThisMonth - ps.MinutesProvidedThisMonth) / (daysPeriod / 7m) * (365m / 84m);
|
|
}
|
|
else // Bewilligung ist abgelaufen
|
|
{
|
|
ps.MinutesFreePerWeek = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
|
|
ps.MinutesFreePerWeekStatisticDate = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
|
|
ps.MinutesFreePerMonth = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
|
|
ps.MinutesFreePerMonthStatisticDate = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
|
|
}
|
|
}
|
|
else if (ps.SupportConceptApprovalPeriod.ApprovedBEInterval == SupportConceptApprovalInterval.Weekly)
|
|
{
|
|
ps.MinutesFreePerWeek = ps.MinutesApprovedPerWeek - ps.MinutesProvidedThisWeek;
|
|
ps.MinutesFreePerWeekStatisticDate = ps.MinutesFreePerWeek;
|
|
// den Wert pro Monat auszurechnen macht überhaupt keinen Sinn, da ich nur die angefangenen Std diese Woche kenne
|
|
// Rest wäre dann theoretisch Stunden * Anzahl der ganzen Wochen....
|
|
ps.MinutesFreePerMonth = ps.MinutesApprovedPerMonth - ps.MinutesProvidedThisMonth;
|
|
ps.MinutesFreePerMonthStatisticDate = ps.MinutesFreePerMonth;
|
|
}
|
|
else if (ps.SupportConceptApprovalPeriod.ApprovedBEInterval == SupportConceptApprovalInterval.Monthly)
|
|
{
|
|
ps.MinutesFreePerMonth = ps.MinutesApprovedPerMonth - ps.MinutesProvidedThisMonth;
|
|
ps.MinutesFreePerMonthStatisticDate = ps.MinutesFreePerMonth;
|
|
ps.MinutesFreePerWeek = ps.MinutesFreePerMonth / 4.33m;
|
|
ps.MinutesFreePerWeekStatisticDate = ps.MinutesFreePerWeek;
|
|
}
|
|
}
|
|
else if (ps.SupportConceptApprovalPeriod.ApprovedBETotal != null) // Gesamtbewilligung für einen beliebigen Zeitraum
|
|
{
|
|
decimal freeRest = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
|
|
if (daysPeriod != 0 && daysPeriod != 1)
|
|
{
|
|
ps.MinutesFreePerWeek = freeRest / (daysPeriod / 7m);
|
|
ps.MinutesFreePerWeekStatisticDate = (ps.MinutesApprovedTotal - ps.IstTotalUntilThisMonth - ps.MinutesProvidedThisMonth) / (daysPeriod / 7m);
|
|
ps.MinutesFreePerMonthStatisticDate = (ps.MinutesApprovedTotal - ps.IstTotalUntilThisMonth - ps.MinutesProvidedThisMonth) / (daysPeriod / 7m) * (365m / 84m);
|
|
ps.MinutesFreePerMonth = freeRest / (daysPeriod / 7m) * (365m / 84m);
|
|
|
|
}
|
|
else // Bewilligung ist abgelaufen
|
|
{
|
|
ps.MinutesFreePerWeek = freeRest;
|
|
ps.MinutesFreePerMonth = freeRest;
|
|
}
|
|
}
|
|
}
|
|
|
|
decimal freeTotalPeriod = ps.MinutesApprovedTotal - ps.MinutesProvidedTotalRounded;
|
|
if (ps.MinutesFreePerWeek > freeTotalPeriod)
|
|
{
|
|
ps.MinutesFreePerWeek = freeTotalPeriod;
|
|
}
|
|
if (ps.MinutesFreePerWeek < 0)
|
|
{
|
|
ps.MinutesFreePerWeek = 0;
|
|
}
|
|
if (ps.MinutesFreePerMonth > freeTotalPeriod)
|
|
{
|
|
ps.MinutesFreePerMonth = freeTotalPeriod;
|
|
}
|
|
if (ps.MinutesFreePerMonth < 0)
|
|
{
|
|
ps.MinutesFreePerMonth = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
decimal freeTotal = stats.MinutesApprovedTotal - stats.MinutesProvidedTotalRounded;
|
|
if (stats.MinutesFreePerWeekAverage > freeTotal)
|
|
{
|
|
stats.MinutesFreePerWeekAverage = freeTotal;
|
|
}
|
|
if (stats.MinutesFreePerWeekAverage < 0)
|
|
{
|
|
stats.MinutesFreePerWeekAverage = 0;
|
|
}
|
|
|
|
|
|
//Berechne bewilligte Stunden pro Monat und Soll
|
|
stats.MinutesApprovedPerMonth = GetApprovedMinutesPerMonth(stats);
|
|
if (relDc.StartDate.HasValue && relDc.EndDate.HasValue)
|
|
{
|
|
DateTime max = statisticsDate < relDc.EndDate.Value ? statisticsDate : relDc.EndDate.Value;
|
|
DateTime s = relDc.StartDate.Value;
|
|
decimal monthsUntilNow = 0;
|
|
|
|
if (s.Day == 1)
|
|
{
|
|
while ((s = s.AddMonths(1)) < max)
|
|
{
|
|
monthsUntilNow++;
|
|
}
|
|
|
|
stats.SollTotalUntilThisMonth = stats.MinutesApprovedPerMonth * monthsUntilNow;
|
|
}
|
|
else
|
|
{
|
|
DateTime nextMonth = s.AddMonths(1);
|
|
nextMonth = new DateTime(nextMonth.Year, nextMonth.Month, 1);
|
|
|
|
if (nextMonth <= max)
|
|
{
|
|
monthsUntilNow = (decimal)nextMonth.Subtract(s).TotalDays / DateTime.DaysInMonth(s.Year, s.Month);
|
|
}
|
|
|
|
while ((nextMonth = nextMonth.AddMonths(1)) < max)
|
|
{
|
|
monthsUntilNow++;
|
|
}
|
|
|
|
stats.SollTotalUntilThisMonth = stats.MinutesApprovedPerMonth * (decimal)monthsUntilNow;
|
|
}
|
|
}
|
|
|
|
return stats;
|
|
}
|
|
|
|
|
|
|
|
protected virtual IEnumerable<ServiceRecord> GetServiceRecordsForStatistic(long costBearer2SupportConceptOid)
|
|
{
|
|
return DAOFactory.SearchDAO.FindServiceRecordsDetailsForLastDays(costBearer2SupportConceptOid, null);
|
|
}
|
|
|
|
protected virtual void ProcessServiceRecord(ServiceRecord sr, CostBearer2SupportConcept cb2sc, SupportConceptStatisticsDC stats, DateTime statisticsDate, Calculations calc)
|
|
{
|
|
decimal minutesProvided = 0;
|
|
decimal minutesProvidedRounded = 0;
|
|
decimal minutesProvidedThisWeek = 0;
|
|
decimal minutesProvidedThisMonth = 0;
|
|
decimal minutesProvidedUntilLastMonth = 0;
|
|
|
|
bool billable = false;
|
|
if (sr.ServiceDescription != null && sr.ServiceDescription.ServiceCategory != null)
|
|
{
|
|
billable = sr.ServiceDescription.ServiceCategory.IsBillable;
|
|
}
|
|
|
|
bool outOfPeriod = true;
|
|
if (cb2sc.StartDate.HasValue && cb2sc.EndDate.HasValue)
|
|
{
|
|
outOfPeriod = false;
|
|
DateTime end = cb2sc.EndDate.Value;
|
|
if (end < DateTime.MaxValue.Date)
|
|
end = end.AddDays(1);
|
|
if (sr.Start < cb2sc.StartDate || sr.Start >= end)
|
|
{
|
|
outOfPeriod = true;
|
|
}
|
|
}
|
|
|
|
SupportConceptPeriodStatisticsDC periodStats =
|
|
GetPeriodDCFromServiceRecord(stats.PeriodStatistics, sr);
|
|
|
|
|
|
if (billable || (periodStats != null && periodStats.SupportConceptApprovalPeriod.ServiceCategory != null))
|
|
{
|
|
minutesProvided = (decimal)sr.DurationMinutes;
|
|
|
|
if (!billable && periodStats.SupportConceptApprovalPeriod.ServiceCategory != null &&
|
|
!periodStats.SupportConceptApprovalPeriod.ServiceCategory.IsBillable)
|
|
{
|
|
minutesProvidedRounded = minutesProvided;
|
|
}
|
|
else
|
|
{
|
|
var srDc = MapToServiceRecordDCForStatistic(sr);
|
|
minutesProvidedRounded = calc.GetBillableDurationInMinutes(srDc, false);
|
|
if (periodStats != null)
|
|
{
|
|
|
|
if (periodStats.ServiceRecords == null)
|
|
{
|
|
periodStats.ServiceRecords = new List<ServiceRecordDC>();
|
|
}
|
|
periodStats.ServiceRecords.Add(srDc);
|
|
}
|
|
}
|
|
|
|
|
|
var firstOfMonthDt = new DateTime(statisticsDate.Year, statisticsDate.Month, 1);
|
|
DateTime mondayDt = statisticsDate.GetLast(DayOfWeek.Monday).Date;
|
|
DateTime sundayDt = statisticsDate.GetNext(DayOfWeek.Sunday).Date;
|
|
|
|
if (sr.Start >= mondayDt && sr.Start < mondayDt.AddDays(7))
|
|
{
|
|
minutesProvidedThisWeek = minutesProvidedRounded;
|
|
}
|
|
if (sr.Start >= firstOfMonthDt && sr.Start < firstOfMonthDt.AddMonths(1))
|
|
{
|
|
minutesProvidedThisMonth = minutesProvidedRounded;
|
|
}
|
|
if (sr.Start >= stats.StatisticsStartDate && sr.Start < firstOfMonthDt)
|
|
{
|
|
minutesProvidedUntilLastMonth += minutesProvidedRounded;
|
|
}
|
|
|
|
CalculateFixedAmountBudget(sr, periodStats, statisticsDate);
|
|
|
|
|
|
}
|
|
|
|
if (outOfPeriod)
|
|
{
|
|
stats.MinutesOutOfApprovedPeriod += minutesProvidedRounded;
|
|
}
|
|
stats.MinutesProvidedTotal += minutesProvided;
|
|
stats.MinutesProvidedTotalRounded += minutesProvidedRounded;
|
|
stats.MinutesProvidedThisMonth += minutesProvidedThisMonth;
|
|
stats.IstTotalUntilThisMonth += minutesProvidedUntilLastMonth;
|
|
stats.MinutesProvidedThisWeek += minutesProvidedThisWeek;
|
|
|
|
|
|
if (periodStats != null)
|
|
{
|
|
if (outOfPeriod)
|
|
{
|
|
periodStats.MinutesOutOfApprovedPeriod += minutesProvidedRounded;
|
|
}
|
|
|
|
periodStats.MinutesProvidedTotal += minutesProvided;
|
|
periodStats.MinutesProvidedTotalRounded += minutesProvidedRounded;
|
|
periodStats.MinutesProvidedThisWeek += minutesProvidedThisWeek;
|
|
periodStats.MinutesProvidedThisMonth += minutesProvidedThisMonth;
|
|
periodStats.IstTotalUntilThisMonth += minutesProvidedUntilLastMonth;
|
|
}
|
|
}
|
|
|
|
protected virtual void CalculateFixedAmountBudget(ServiceRecord sr, SupportConceptPeriodStatisticsDC periodStats, DateTime statisticsDate)
|
|
{
|
|
//do nothing... Es wird kein fixes Budget im Standard berechnet
|
|
}
|
|
|
|
protected virtual void SortStatistics(SupportConceptStatisticsDC stats)
|
|
{
|
|
stats.PeriodStatistics.Sort((p1, p2) =>
|
|
{
|
|
int c = 0;
|
|
if (p1.SupportConceptApprovalPeriod.StartDate.HasValue && p2.SupportConceptApprovalPeriod.StartDate.HasValue)
|
|
{
|
|
c = p1.SupportConceptApprovalPeriod.StartDate.Value.CompareTo(p2.SupportConceptApprovalPeriod.StartDate.Value);
|
|
}
|
|
|
|
if (c == 0 && p1.SupportConceptApprovalPeriod.ServiceCategory != null && p2.SupportConceptApprovalPeriod.ServiceCategory != null)
|
|
c =
|
|
p1.SupportConceptApprovalPeriod.ServiceCategory.Name.CompareTo(
|
|
p2.SupportConceptApprovalPeriod.ServiceCategory.Name);
|
|
return c;
|
|
});
|
|
|
|
}
|
|
|
|
protected virtual SupportConceptPeriodStatisticsDC CreatePeriodStatisticsDC(SupportConceptCostBearerRelDC relDc, SupportConceptApprovalPeriodDC periodDC, Calculations calc, DateTime statisticsDate)
|
|
{
|
|
var periodStats = new SupportConceptPeriodStatisticsDC();
|
|
periodStats.SupportConceptApprovalPeriod = periodDC;
|
|
|
|
|
|
periodStats.MinutesApprovedTotal = (calc.GetApprovedHoursForPeriod(relDc, periodDC, relDc.CostBearer.CostRatePeriods, periodDC.StartDate, periodDC.EndDate, true) ?? 0m) * 60m;
|
|
periodStats.MinutesApprovedPerWeek = (calc.GetApprovedHoursPerWeek(relDc, periodDC, relDc.CostBearer.CostRatePeriods, true) ?? 0m) * 60m;
|
|
periodStats.ApprovedMinutesTillNow = calc.GetApprovedHoursTillNow(periodDC, relDc.CostBearer.CostRatePeriods, statisticsDate, relDc.CostBearer.IsCalculatingWithFactor) * 60m;
|
|
|
|
if (periodStats.MinutesApprovedPerWeek == 0 && relDc.EndDate.HasValue &&
|
|
relDc.EndDate < statisticsDate)
|
|
{
|
|
periodStats.MinutesApprovedPerWeek =
|
|
calc.GetApprovedHoursPerWeek(relDc, relDc.EndDate.Value) ?? 0m;
|
|
}
|
|
|
|
periodStats.MinutesApprovedPerMonth = GetApprovedMinutesPerMonth(periodStats);
|
|
|
|
if (periodDC.StartDate.HasValue && periodDC.EndDate.HasValue)
|
|
{
|
|
DateTime periodEnd = periodDC.EndDate.Value;
|
|
if (periodEnd < DateTime.MaxValue)
|
|
{
|
|
periodEnd = periodEnd.AddDays(1);
|
|
}
|
|
DateTime max = statisticsDate < periodEnd ? statisticsDate : periodEnd;
|
|
DateTime s = periodDC.StartDate.Value;
|
|
|
|
decimal monthsUntilNow = 0;
|
|
|
|
if (s.Day == 1)
|
|
{
|
|
while ((s = s.AddMonths(1)) <= max)
|
|
{
|
|
monthsUntilNow++;
|
|
}
|
|
|
|
periodStats.SollTotalUntilThisMonth = periodStats.MinutesApprovedPerMonth * monthsUntilNow;
|
|
}
|
|
else
|
|
{
|
|
DateTime nextMonth = s.AddMonths(1);
|
|
nextMonth = new DateTime(nextMonth.Year, nextMonth.Month, 1);
|
|
|
|
if (nextMonth <= max)
|
|
{
|
|
monthsUntilNow = (decimal)nextMonth.Subtract(s).TotalDays / DateTime.DaysInMonth(s.Year, s.Month);
|
|
}
|
|
while ((nextMonth = nextMonth.AddMonths(1)) < max)
|
|
{
|
|
monthsUntilNow++;
|
|
}
|
|
|
|
periodStats.SollTotalUntilThisMonth = periodStats.MinutesApprovedPerMonth * (decimal)monthsUntilNow;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return periodStats;
|
|
}
|
|
|
|
|
|
protected virtual SupportConceptCostBearerRelDC CreateCb2ScDC(CostBearer2SupportConcept cb2sc)
|
|
{
|
|
var pDataContract = new SupportConceptCostBearerRelDC();
|
|
|
|
if (cb2sc.CostBearer.Organisation != null)
|
|
{
|
|
pDataContract.CostBearer =
|
|
MapperFactory.CompactOrganisationDC_Organisation.MapToNewDC(cb2sc.CostBearer.Organisation);
|
|
}
|
|
|
|
pDataContract.CostBearer2SupportConceptOid = cb2sc.Oid;
|
|
pDataContract.CostBearer2SupportConceptVersion = cb2sc.Version;
|
|
pDataContract.Notice = cb2sc.Notice;
|
|
pDataContract.Status = cb2sc.Status;
|
|
//pDataContract.SupportConcept =
|
|
// MapperFactory.CompactSupportConceptDC_SupportConcept.MapToNewDC(pEntity.SupportConcept);
|
|
|
|
pDataContract.RequestedStartDate = cb2sc.RequestedStartDate;
|
|
pDataContract.RequestedEndDate = cb2sc.RequestedEndDate;
|
|
pDataContract.ApprovedStartDate = cb2sc.ApprovedStartDate;
|
|
pDataContract.ApprovedEndDate = cb2sc.ApprovedEndDate;
|
|
pDataContract.CustomerReferenceNumber = cb2sc.CustomerReferenceNumber;
|
|
|
|
pDataContract.MonthlyPayment = cb2sc.MonthlyPayment;
|
|
|
|
//if (cb2sc.CostBearerContactPerson != null)
|
|
// pDataContract.CostBearerContactPerson =
|
|
// MapperFactory.CompactPersonDC_Person.MapToNewDC(cb2sc.CostBearerContactPerson);
|
|
pDataContract.ApprovalPeriodList =
|
|
MapperFactory.SupportConceptApprovalPeriodDC_SupportConceptApprovalPeriod.MapToNewDCs(
|
|
cb2sc.ApprovalPeriodList);
|
|
if (pDataContract.ApprovalPeriodList != null)
|
|
{
|
|
foreach (var item in pDataContract.ApprovalPeriodList)
|
|
{
|
|
if (!item.StartDate.HasValue)
|
|
{
|
|
item.StartDate = cb2sc.ApprovedStartDate.HasValue
|
|
? cb2sc.ApprovedStartDate
|
|
: cb2sc.RequestedStartDate;
|
|
}
|
|
if (!item.EndDate.HasValue)
|
|
{
|
|
item.EndDate = cb2sc.ApprovedEndDate.HasValue
|
|
? cb2sc.ApprovedEndDate
|
|
: cb2sc.RequestedEndDate;
|
|
}
|
|
}
|
|
}
|
|
return pDataContract;
|
|
}
|
|
|
|
protected virtual SupportConceptPeriodStatisticsDC GetPeriodDCFromServiceRecord(List<SupportConceptPeriodStatisticsDC> stats, ServiceRecord sr)
|
|
{
|
|
|
|
foreach (var p in stats)
|
|
{
|
|
DateTime start = DateTime.MinValue;
|
|
DateTime end = DateTime.MaxValue;
|
|
|
|
if (p.SupportConceptApprovalPeriod.StartDate.HasValue)
|
|
start = p.SupportConceptApprovalPeriod.StartDate.Value;
|
|
if (p.SupportConceptApprovalPeriod.EndDate.HasValue && p.SupportConceptApprovalPeriod.EndDate.Value.Date < end)
|
|
end = p.SupportConceptApprovalPeriod.EndDate.Value.Date.AddDays(1);
|
|
|
|
if (sr.Start.Value.Second == 1 && sr.Start >= start && sr.Start < end)
|
|
{
|
|
if (p.SupportConceptApprovalPeriod.ServiceCategory != null && p.SupportConceptApprovalPeriod.ServiceCategory.ServiceCategoryOid == sr.ServiceDescription.ServiceCategory.Oid)
|
|
return p;
|
|
}
|
|
else
|
|
{
|
|
if (sr.Start >= start && sr.End < end)
|
|
{
|
|
if (p.SupportConceptApprovalPeriod.ServiceCategory != null &&
|
|
p.SupportConceptApprovalPeriod.ServiceCategory.ServiceCategoryOid ==
|
|
sr.ServiceDescription.ServiceCategory.Oid)
|
|
return p;
|
|
|
|
}
|
|
}
|
|
}
|
|
foreach (var p in stats)
|
|
{
|
|
DateTime start = DateTime.MinValue;
|
|
DateTime end = DateTime.MaxValue;
|
|
|
|
if (p.SupportConceptApprovalPeriod.StartDate.HasValue)
|
|
start = p.SupportConceptApprovalPeriod.StartDate.Value;
|
|
if (p.SupportConceptApprovalPeriod.EndDate.HasValue && p.SupportConceptApprovalPeriod.EndDate.Value.Date < end)
|
|
end = p.SupportConceptApprovalPeriod.EndDate.Value.Date.AddDays(1);
|
|
|
|
if (sr.Start.Value.Second == 1 && sr.Start >= start && sr.Start < end)
|
|
{
|
|
if (p.SupportConceptApprovalPeriod.ServiceCategory == null)
|
|
return p;
|
|
}
|
|
else
|
|
{
|
|
if (sr.Start >= start && sr.End < end)
|
|
{
|
|
if (p.SupportConceptApprovalPeriod.ServiceCategory == null)
|
|
return p;
|
|
|
|
}
|
|
}
|
|
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected virtual ServiceRecordDC MapToServiceRecordDCForStatistic(ServiceRecord pEntity)
|
|
{
|
|
var pDataContract = new ServiceRecordDC();
|
|
|
|
pDataContract.ServiceRecordOid = pEntity.Oid;
|
|
pDataContract.ServiceRecordVersion = pEntity.Version;
|
|
pDataContract.Start = pEntity.Start;
|
|
pDataContract.End = pEntity.End;
|
|
pDataContract.Notice = pEntity.Notice;
|
|
pDataContract.ServiceRecordType = pEntity.ServiceRecordType ?? ServiceRecordTypeId.DefaultActivity;
|
|
pDataContract.DistanceInMeterDecimal = pEntity.DistanceInMeter;
|
|
// ? pEntity.ServiceRecordType.Value
|
|
// : ServiceRecordTypeId.DefaultActivity;
|
|
|
|
if (pEntity.ServiceDescription != null)
|
|
{
|
|
pDataContract.ServiceDescription = MapperFactory.ServiceDescriptionDC_ServiceDescription.MapToNewDC(pEntity.ServiceDescription);
|
|
}
|
|
|
|
pDataContract.RoundedDuration = pEntity.RoundedDuration;
|
|
pDataContract.InsertedOn = pEntity.InsTs;
|
|
pDataContract.InsUser = pEntity.InsUser;
|
|
|
|
|
|
pDataContract.GroupEmployeeCount = pEntity.GroupEmployeeCount;
|
|
pDataContract.GroupPersonCount = pEntity.GroupPersonCount;
|
|
pDataContract.GroupRoundedDuration = pEntity.GroupRoundedDuration;
|
|
pDataContract.GroupOid = pEntity.GroupOid;
|
|
|
|
return pDataContract;
|
|
}
|
|
|
|
protected virtual ServiceRecordPeriodStatisticsInfoDC CreateDefaultServiceRecordPeriodStatisticsInfo(int rows)
|
|
{
|
|
var dc = new ServiceRecordPeriodStatisticsInfoDC
|
|
{
|
|
LeftValues = new string[rows],
|
|
RightValues = new string[rows],
|
|
LeftValueColors = new string[rows],
|
|
RightValueColors = new string[rows]
|
|
};
|
|
|
|
for (int i = 0; i < rows; i++)
|
|
{
|
|
dc.LeftValueColors[i] = "#FF2B508B";
|
|
dc.RightValueColors[i] = "#FF2B508B";
|
|
}
|
|
|
|
return dc;
|
|
}
|
|
|
|
public virtual decimal GetApprovedMinutesPerMonth(SupportConceptPeriodStatisticsDC periodStats)
|
|
{
|
|
return periodStats.MinutesApprovedPerWeek * (365m / 84m);
|
|
}
|
|
|
|
public virtual decimal GetApprovedMinutesPerMonth(SupportConceptStatisticsDC stats)
|
|
{
|
|
return stats.MinutesApprovedPerWeek * (365m / 84m);
|
|
}
|
|
|
|
|
|
protected bool TimeSpanIsEqual(SupportConceptStatisticsDC r)
|
|
{
|
|
if (r.PeriodStatistics != null && r.PeriodStatistics.Count > 1)
|
|
{
|
|
for (int i = 0; i < r.PeriodStatistics.Count - 1; i++)
|
|
{
|
|
var p1 = r.PeriodStatistics[i];
|
|
|
|
if (p1.SupportConceptApprovalPeriod.StartDate.HasValue && p1.SupportConceptApprovalPeriod.EndDate.HasValue)
|
|
{
|
|
for (int j = i + 1; j < r.PeriodStatistics.Count; j++)
|
|
{
|
|
var p2 = r.PeriodStatistics[j];
|
|
if (p2.SupportConceptApprovalPeriod.StartDate.HasValue && p2.SupportConceptApprovalPeriod.EndDate.HasValue)
|
|
{
|
|
if ((p1.SupportConceptApprovalPeriod.StartDate.Value.Date != p2.SupportConceptApprovalPeriod.StartDate.Value.Date) ||
|
|
(p1.SupportConceptApprovalPeriod.EndDate.Value.Date != p2.SupportConceptApprovalPeriod.EndDate.Value.Date))
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Bei selbem Zeitraum und Kategorie soll die neue Statistik einfach auf die alte draufaddiert werden
|
|
private SupportConceptPeriodStatisticsDC SummarizeStats(SupportConceptPeriodStatisticsDC vorhandeneStatistik, SupportConceptPeriodStatisticsDC neueStatistik)
|
|
{
|
|
vorhandeneStatistik.AmountConsumedThisInterval += neueStatistik.AmountConsumedThisInterval;
|
|
vorhandeneStatistik.AmountConsumedTotal += neueStatistik.AmountConsumedTotal;
|
|
vorhandeneStatistik.ApprovedMinutesTillNow += neueStatistik.ApprovedMinutesTillNow;
|
|
vorhandeneStatistik.FixedAmountApprovedPerInterval += neueStatistik.FixedAmountApprovedPerInterval;
|
|
vorhandeneStatistik.FixedAmountApprovedTotal += neueStatistik.FixedAmountApprovedTotal;
|
|
vorhandeneStatistik.IstTotalUntilThisMonth += neueStatistik.IstTotalUntilThisMonth;
|
|
vorhandeneStatistik.MinutesApprovedPerMonth += neueStatistik.MinutesApprovedPerMonth;
|
|
vorhandeneStatistik.MinutesApprovedPerWeek += neueStatistik.MinutesApprovedPerWeek;
|
|
vorhandeneStatistik.MinutesApprovedTotal += neueStatistik.MinutesApprovedTotal;
|
|
vorhandeneStatistik.MinutesFreePerWeek += neueStatistik.MinutesFreePerWeek;
|
|
vorhandeneStatistik.MinutesOutOfApprovedPeriod += neueStatistik.MinutesOutOfApprovedPeriod;
|
|
vorhandeneStatistik.MinutesProvidedThisMonth += neueStatistik.MinutesProvidedThisMonth;
|
|
vorhandeneStatistik.MinutesProvidedThisWeek += neueStatistik.MinutesProvidedThisWeek;
|
|
vorhandeneStatistik.MinutesProvidedTotal += neueStatistik.MinutesProvidedTotal;
|
|
vorhandeneStatistik.MinutesProvidedTotalRounded += neueStatistik.MinutesProvidedTotalRounded;
|
|
vorhandeneStatistik.SollTotalUntilThisMonth += neueStatistik.SollTotalUntilThisMonth;
|
|
|
|
return vorhandeneStatistik;
|
|
}
|
|
}
|
|
}
|