526 lines
26 KiB
C#
526 lines
26 KiB
C#
using BeWo.Data.Access;
|
|
using BeWo.Data.Entities;
|
|
using BeWo.Service.DCEntityMapper;
|
|
using BeWo.Service.Invoicing;
|
|
using BeWo.Service.Plugins;
|
|
using BS.Shared;
|
|
using BS.Shared.Core;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.Extensions;
|
|
using BS.Shared.Services;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace PerspektivenEV.Invoicing
|
|
{
|
|
|
|
public class CustomInvoiceCreation : InvoiceCreation
|
|
{
|
|
//Anpassungen für Anfahrten und gefahrene Kilometer sowie Rechnungsempfänger bei Selbstzahler
|
|
|
|
private DateTime? accountingPeriodStart = null;
|
|
private DateTime? accountingPeriodEnd = null;
|
|
private const decimal AMOUNT_PER_KM = 0.35m;
|
|
private decimal AMOUNT_PER_KMQA = 0.0231m;
|
|
private decimal AMOUNT_PER_KMKA = 0.0108m;
|
|
bool bthg = false;
|
|
|
|
public override void SetInvoiceBaseData(int invoiceCounter, ServiceInvoice invoice, CostBearer costBearer, DateTimeSpan invoicePeriod,
|
|
IList<CompactSupportConceptDC> supportConceptList)
|
|
{
|
|
if (invoicePeriod != null)
|
|
{
|
|
accountingPeriodStart = invoicePeriod.StartDate;
|
|
accountingPeriodEnd = invoicePeriod.EndDate;
|
|
}
|
|
if (costBearer.Organisation.Function.Value.ToLower().Contains("bthg"))
|
|
{
|
|
bthg = true;
|
|
//Einmaliges Laden der Preise um nicht bei jeder Bewilligung neu zu starten
|
|
var preise = DAOFactory.GenericDAO.GetAllActive<Preis>();
|
|
var pauschVar = GetPreis(preise, "BW FFM SZ QA Fahrzeit pro Minute", (DateTime)accountingPeriodStart);
|
|
if (pauschVar != 0)
|
|
{
|
|
AMOUNT_PER_KMQA = pauschVar;
|
|
}
|
|
pauschVar = 0;
|
|
pauschVar = GetPreis(preise, "BW FFM SZ KA Fahrzeit pro Minute", (DateTime)accountingPeriodStart);
|
|
if (pauschVar != 0)
|
|
{
|
|
AMOUNT_PER_KMKA = pauschVar;
|
|
}
|
|
}
|
|
base.SetInvoiceBaseData(invoiceCounter, invoice, costBearer, invoicePeriod, supportConceptList);
|
|
}
|
|
|
|
public override void SetRecipientInformation(ServiceInvoice serviceInvoice, CostBearer costBearer)
|
|
{
|
|
if (costBearer.Organisation.Name.Contains("SELBSTZAHLER") || costBearer.Organisation.Name == "EIGENANTEIL")
|
|
{
|
|
serviceInvoice.InvoiceBase.RecipientDivision = costBearer.Organisation.Name2;
|
|
serviceInvoice.InvoiceBase.RecipientOrganisationOid = costBearer.Organisation.Oid;
|
|
serviceInvoice.InvoiceBase.RecipientOrganisation = costBearer.Organisation.Name;
|
|
serviceInvoice.InvoiceBase.RecipientContacts = costBearer.Organisation.Contacts.Select(i => i.CopyToNew()).ToList();
|
|
serviceInvoice.InvoiceBase.RecipientCostBearerOid = costBearer.Oid;
|
|
|
|
if (serviceInvoice.InvoiceBase.CostBearer2SupportConcept != null)
|
|
{
|
|
var cust = serviceInvoice.InvoiceBase.CostBearer2SupportConcept.SupportConcept.Customer;
|
|
|
|
if (cust.Person.InvoiceAddress != null)
|
|
{
|
|
serviceInvoice.InvoiceBase.RecipientAddress = cust.Person.InvoiceAddress.CopyToNew();
|
|
}
|
|
else if (cust.Person.Address != null)
|
|
{
|
|
serviceInvoice.InvoiceBase.RecipientAddress = cust.Person.Address.CopyToNew();
|
|
}
|
|
|
|
if (cust.Person.InvoiceAddress != null && cust.Person.InvoiceAddress.AddressLine1 != null)
|
|
{
|
|
serviceInvoice.InvoiceBase.RecipientPersonFirstName = cust.Person.InvoiceAddress.AddressLine1;
|
|
serviceInvoice.InvoiceBase.RecipientPersonLastName = "";
|
|
}
|
|
else
|
|
{
|
|
serviceInvoice.InvoiceBase.RecipientPersonFirstName = cust.Person.FirstName;
|
|
serviceInvoice.InvoiceBase.RecipientPersonLastName = cust.Person.LastName;
|
|
}
|
|
return;
|
|
}
|
|
if (costBearer.Organisation.InvoiceAddress != null)
|
|
{
|
|
serviceInvoice.InvoiceBase.RecipientAddress = costBearer.Organisation.InvoiceAddress.CopyToNew();
|
|
}
|
|
else if (costBearer.Organisation.Address != null)
|
|
{
|
|
serviceInvoice.InvoiceBase.RecipientAddress = costBearer.Organisation.Address.CopyToNew();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
base.SetRecipientInformation(serviceInvoice, costBearer);
|
|
}
|
|
}
|
|
|
|
public override void SetServiceInvoicePeriods(ServiceInvoice invoice, CostBearer2SupportConcept costBearer2SupportConcept, DateTimeSpan invoicePeriod, List<ServiceRecordDC> serviceRecords)
|
|
{
|
|
if (serviceRecords.Any(s => s.ServiceDescription.Category.Abbreviation != null && s.ServiceDescription.Category.Abbreviation.Contains("TS") && s.ServiceDescription.Category.Abbreviation.Contains("ANW")))
|
|
{
|
|
//var serviceRecordsTS = serviceRecords.Where(s => s.ServiceDescription.Category.Abbreviation.Contains("TS") && s.ServiceDescription.Category.Abbreviation.Contains("ANW") && !s.ServiceDescription.Category.Abbreviation.Contains("TS")).ToList();
|
|
serviceRecords = serviceRecords.Where(s => s.ServiceDescription.Category.Abbreviation.Contains("TS") && s.ServiceDescription.Category.Abbreviation.Contains("ANW") || !s.ServiceDescription.Category.Abbreviation.Contains("TS")).ToList();
|
|
}
|
|
base.SetServiceInvoicePeriods(invoice, costBearer2SupportConcept, invoicePeriod, serviceRecords);
|
|
}
|
|
|
|
public override IList<InvoiceItem> CreateSummaryInvoiceItems(IList<InvoiceItem> itemList, DateTimeSpan invoicePeriod, SupportConceptApprovalPeriod scap,
|
|
Calculations calc, bool summaryPerMonth, bool addRateFactorToUnitCount)
|
|
{
|
|
return base.CreateSummaryInvoiceItems(itemList, invoicePeriod, scap, calc, false, true);
|
|
}
|
|
|
|
public override void SetInvoiceItems(ServiceInvoice invoice,
|
|
ServiceInvoicePeriod serviceInvoicePeriod,
|
|
SupportConceptApprovalPeriodDC supportConceptApprovalPeriod,
|
|
CostBearer2SupportConcept cb2sc,
|
|
DateTimeSpan invoicePeriod,
|
|
List<ServiceRecordDC> serviceRecords)
|
|
{
|
|
if (!serviceInvoicePeriod.ApprovedFixedAmount.HasValue ||
|
|
serviceInvoicePeriod.ApprovedFixedAmount.HasValue && supportConceptApprovalPeriod.ServiceCategory != null && supportConceptApprovalPeriod.ServiceCategory.Name == "Handgeld")
|
|
{
|
|
Calculations calc = PluginLoader.FindClass<Calculations>(_SpecificID) ?? Calculations.GetInstance(_SpecificID);
|
|
|
|
List<ServiceRecordDC> serviceRecordsInPeriod = serviceRecords.Where(
|
|
i =>
|
|
{
|
|
bool valid = i.Start.Value.InBetween(serviceInvoicePeriod.Start.Value,
|
|
serviceInvoicePeriod.End.Value, true);
|
|
|
|
if (valid && serviceInvoicePeriod.SupportConceptApprovalPeriod != null && serviceInvoicePeriod.SupportConceptApprovalPeriod.ServiceCategory != null)
|
|
valid = serviceInvoicePeriod.SupportConceptApprovalPeriod.ServiceCategory.Oid ==
|
|
i.ServiceDescription.Category.ServiceCategoryOid;
|
|
return valid;
|
|
}).ToList();
|
|
|
|
if (serviceRecordsInPeriod.Count > 0)
|
|
{
|
|
var absenceTimes = MapperFactory.AbsenceTimeDC_AbsenceTime.MapToNewDCs(cb2sc.SupportConcept.Customer.AbsenceTimes);
|
|
Dictionary<DateTimeSpan, decimal> span2Hours = calc.GetAbsencesTimesNotBillable(absenceTimes);
|
|
|
|
serviceInvoicePeriod.HoursNotBillableAbsence +=
|
|
calc.GetHoursNotBillableDueToAbsenceTimes(supportConceptApprovalPeriod,
|
|
cb2sc.CostBearer.CostRatePeriods.MapToNewDCs(),
|
|
serviceRecordsInPeriod,
|
|
span2Hours,
|
|
true, true);
|
|
|
|
serviceInvoicePeriod.HoursNotBillableNotApproved +=
|
|
calc.GetHoursNotBillableDueToMoreThanApproved(supportConceptApprovalPeriod,
|
|
cb2sc.CostBearer.CostRatePeriods.MapToNewDCs(),
|
|
serviceRecordsInPeriod,
|
|
true, true);
|
|
|
|
var itemList = CreateInvoiceItems(serviceRecordsInPeriod, invoicePeriod, serviceInvoicePeriod.SupportConceptApprovalPeriod, calc);
|
|
serviceInvoicePeriod.InvoiceItemList.AddRange(itemList);
|
|
}
|
|
}
|
|
|
|
if (ShouldCreateFixedAmounts(serviceInvoicePeriod, supportConceptApprovalPeriod, cb2sc))
|
|
{
|
|
CreateFixedAmounts(serviceInvoicePeriod, supportConceptApprovalPeriod, cb2sc);
|
|
}
|
|
}
|
|
|
|
public override bool ShouldCreateFixedAmounts(ServiceInvoicePeriod serviceInvoicePeriod, SupportConceptApprovalPeriodDC supportConceptApprovalPeriod, CostBearer2SupportConcept cb2sc)
|
|
{
|
|
if (cb2sc.CostBearer.Organisation.Name.Contains("SELBSTZAHLER") && supportConceptApprovalPeriod.ServiceCategory.Abbreviation != null && supportConceptApprovalPeriod.ServiceCategory.Abbreviation.Contains("TS"))
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
return base.ShouldCreateFixedAmounts(serviceInvoicePeriod, supportConceptApprovalPeriod, cb2sc);
|
|
}
|
|
}
|
|
|
|
public override void CreateFixedAmounts(ServiceInvoicePeriod serviceInvoicePeriod, SupportConceptApprovalPeriodDC supportConceptApprovalPeriod, CostBearer2SupportConcept cb2sc)
|
|
{
|
|
var calc = PluginLoader.FindClass<Calculations>(_SpecificID) ?? Calculations.GetInstance(_SpecificID);
|
|
var data = calc.GetFixedBillingData(supportConceptApprovalPeriod, serviceInvoicePeriod.Start, serviceInvoicePeriod.End);
|
|
var cat = supportConceptApprovalPeriod.ServiceCategory;
|
|
if (cb2sc.CostBearer.Organisation.Function != null && cb2sc.CostBearer.Organisation.Function.Value.Contains("BTHG") && cb2sc.CostBearer.Organisation.Name == "SELBSTZAHLER")
|
|
{
|
|
if (cat.Abbreviation != null && cat.Abbreviation.Length > 2 && cat.Abbreviation.Substring(cat.Abbreviation.Length - 3) == "GVF")
|
|
{
|
|
DateTime start = accountingPeriodStart.Value;
|
|
DateTime end = accountingPeriodEnd.Value;
|
|
if (supportConceptApprovalPeriod.StartDate > start)
|
|
{
|
|
start = supportConceptApprovalPeriod.StartDate.Value;
|
|
}
|
|
if (supportConceptApprovalPeriod.EndDate < end)
|
|
{
|
|
end = supportConceptApprovalPeriod.EndDate.Value;
|
|
}
|
|
var price = Math.Round((decimal)data[0].AmountTotal, 2, MidpointRounding.AwayFromZero);
|
|
serviceInvoicePeriod.InvoiceItemList.Add(new InvoiceItem
|
|
{
|
|
ItemPeriodStart = start,
|
|
ItemPeriodEnd = end,
|
|
SupportConceptApprovalPeriodOid = supportConceptApprovalPeriod.SupportConceptApprovalPeriodOid,
|
|
AccountingInterval = AccountingIntervalType.Daily,
|
|
UnitCount = (decimal)(end - start).TotalDays + 1,
|
|
AmountPerUnit = Math.Round((decimal)data[0].AmountTotal, 2, MidpointRounding.AwayFromZero),
|
|
AmountTotal = ((decimal)(end - start).TotalDays + 1) * price,
|
|
GrossAmountTotal = ((decimal)(end - start).TotalDays + 1) * price,
|
|
ItemDescription = "Ges.vorgehaltene Flächen",
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string desc = "Monatl. Pauschale";
|
|
if (cb2sc.CostBearer.Organisation.Function != null && cb2sc.CostBearer.Organisation.Function.Value.Contains("BTHG") && cb2sc.CostBearer.Organisation.Name == "EIGENANTEIL")
|
|
{
|
|
desc = "Eigenanteil " + supportConceptApprovalPeriod.ServiceCategory.Name;
|
|
}
|
|
|
|
foreach (var billingData in data)
|
|
{
|
|
|
|
if (supportConceptApprovalPeriod.ServiceCategory != null && supportConceptApprovalPeriod.ServiceCategory.Name == "Handgeld")
|
|
{
|
|
desc = "Handgeld";
|
|
}
|
|
serviceInvoicePeriod.InvoiceItemList.Add(new InvoiceItem
|
|
{
|
|
AmountTotal = billingData.AmountTotal,
|
|
GrossAmountTotal = billingData.GrossAmountTotal,
|
|
ItemPeriodStart = billingData.BillingPeriodStart,
|
|
ItemPeriodEnd = billingData.BillingPeriodEnd,
|
|
AccountingInterval = billingData.AccountingInterval,
|
|
AmountPerUnit = billingData.AmountPerUnit,
|
|
UnitCount = billingData.UnitCount,
|
|
ItemDescription = desc
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public override void SetServiceInvoicePeriodAmounts(ServiceInvoice invoice)
|
|
{
|
|
foreach (ServiceInvoicePeriod iPeriod in invoice.ServiceInvoicePeriodList)
|
|
{
|
|
iPeriod.Claim = 0;
|
|
foreach (InvoiceItem item in iPeriod.InvoiceItemList)
|
|
{
|
|
if (item.GrossAmountTotal.HasValue)
|
|
iPeriod.Claim += item.GrossAmountTotal;
|
|
}
|
|
|
|
iPeriod.Claim = Math.Round(iPeriod.Claim.Value, 2, MidpointRounding.AwayFromZero);
|
|
}
|
|
}
|
|
|
|
public override IList<InvoiceItem> CreateInvoiceItems(List<ServiceRecordDC> serviceRecordsInPeriod, DateTimeSpan invoicePeriod, SupportConceptApprovalPeriod scap, Calculations calc)
|
|
{
|
|
IList<InvoiceItem> list = new List<InvoiceItem>();
|
|
if (serviceRecordsInPeriod.Any(s => s.ServiceDescription.Category.Abbreviation != null && s.ServiceDescription.Category.Abbreviation.StartsWith("TS") && s.ServiceDescription.Category.Abbreviation.Contains("ANW")))
|
|
{
|
|
var tsitem = CreateInvoiceItemsTagesstaette(serviceRecordsInPeriod, invoicePeriod, scap, calc);
|
|
if (tsitem != null)
|
|
{
|
|
list.Add(tsitem);
|
|
}
|
|
if (scap.CostBearer2SupportConcept.ApprovalPeriodList.Any(s => s.ServiceCategory.Abbreviation.StartsWith("TS")
|
|
&& s.ServiceCategory.Abbreviation.Substring(s.ServiceCategory.Abbreviation.Length - 3) == "GVF"
|
|
&& s.EndDate > invoicePeriod.StartDate))
|
|
{
|
|
scap = scap.CostBearer2SupportConcept.ApprovalPeriodList.Where(s => s.ServiceCategory.Abbreviation.StartsWith("TS") && s.ServiceCategory.Abbreviation.Substring(s.ServiceCategory.Abbreviation.Length - 3) == "GVF"
|
|
&& s.StartDate < invoicePeriod.EndDate && s.EndDate > invoicePeriod.StartDate).FirstOrDefault();
|
|
|
|
var gvfitem = CreateInvoiceItemsTagesstaette(serviceRecordsInPeriod, invoicePeriod, scap, calc);
|
|
if (gvfitem != null)
|
|
{
|
|
list.Add(gvfitem);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
list = base.CreateInvoiceItems(serviceRecordsInPeriod, invoicePeriod, scap, calc);
|
|
if (scap.CostBearer2SupportConcept.CostBearer.Organisation.Function != null && scap.CostBearer2SupportConcept.CostBearer.Organisation.Function.Value.Contains("BTHG"))
|
|
{
|
|
if (scap.CostBearer2SupportConcept.CostBearer.Organisation.Name.Contains("SELBSTZAHLER"))
|
|
{
|
|
var fpauitem = CreateFahrtpauschaleInvoiceItem(list, scap, serviceRecordsInPeriod);
|
|
if (fpauitem != null)
|
|
{
|
|
list.Add(fpauitem);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var fitem = CreateFahrkostenInvoiceItem(serviceRecordsInPeriod, scap, calc);
|
|
if (fitem != null)
|
|
list.Add(fitem);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
private InvoiceItem CreateInvoiceItemsTagesstaette(List<ServiceRecordDC> serviceRecordsInPeriod, DateTimeSpan invoicePeriod, SupportConceptApprovalPeriod scap, Calculations calc)
|
|
{
|
|
var cb2sc = scap.CostBearer2SupportConcept;
|
|
var scapDC = MapperFactory.SupportConceptApprovalPeriodDC_SupportConceptApprovalPeriod.MapToNewDC(scap);
|
|
var data = calc.GetFixedBillingData(scapDC, invoicePeriod.StartDate, invoicePeriod.EndDate);
|
|
var cat = scap.ServiceCategory;
|
|
|
|
if (cat.Abbreviation != null && cat.Abbreviation.Substring(cat.Abbreviation.Length - 3) == "GVF")
|
|
{
|
|
DateTime start = accountingPeriodStart.Value;
|
|
DateTime end = accountingPeriodEnd.Value;
|
|
if (scap.StartDate > start)
|
|
{
|
|
start = scap.StartDate.Value;
|
|
}
|
|
if (scap.EndDate < end)
|
|
{
|
|
end = scap.EndDate.Value;
|
|
}
|
|
var price = Math.Round((decimal)data[0].AmountTotal, 2, MidpointRounding.AwayFromZero);
|
|
var invoiceItem = new InvoiceItem();
|
|
invoiceItem.ItemPeriodStart = start;
|
|
invoiceItem.ItemPeriodEnd = end;
|
|
invoiceItem.SupportConceptApprovalPeriodOid = scap.Oid;
|
|
invoiceItem.AccountingInterval = AccountingIntervalType.Daily;
|
|
invoiceItem.UnitCount = (decimal)(end - start).TotalDays + 1;
|
|
invoiceItem.AmountPerUnit = Math.Round((decimal)data[0].AmountTotal, 2, MidpointRounding.AwayFromZero);
|
|
invoiceItem.AmountTotal = ((decimal)(end - start).TotalDays + 1) * price;
|
|
invoiceItem.GrossAmountTotal = ((decimal)(end - start).TotalDays + 1) * price;
|
|
invoiceItem.ItemDescription = "Ges. vorg. Flächen";
|
|
|
|
return invoiceItem;
|
|
}
|
|
else
|
|
{
|
|
decimal days = 0;
|
|
IList<InvoiceItem> list = new List<InvoiceItem>();
|
|
var crlist = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(scap.ServiceCategory.CostRatePeriods);
|
|
var cr = crlist.GetCostRatePeriodForDate(CostRatePeriodType.AmountOfMoney, invoicePeriod.StartDate);
|
|
serviceRecordsInPeriod.Sort((a, b) => a.Start.Value.CompareTo(b.Start.Value));
|
|
for (int i = 0; i < serviceRecordsInPeriod.Count; i++)
|
|
{
|
|
if (i == 0 || (i > 0 && serviceRecordsInPeriod[i].Start.Value.Date != serviceRecordsInPeriod[i - 1].Start.Value.Date))
|
|
{
|
|
days++;
|
|
}
|
|
}
|
|
if (days > 0)
|
|
{
|
|
var invoiceItem = new InvoiceItem();
|
|
invoiceItem.AmountPerUnit = cr.CostRateValue;
|
|
invoiceItem.UnitCount = days;
|
|
invoiceItem.UnitDescription = "Tage";
|
|
invoiceItem.AmountTotal = invoiceItem.UnitCount * invoiceItem.AmountPerUnit;
|
|
invoiceItem.RateFactor = null;
|
|
invoiceItem.ItemPeriodStart = accountingPeriodStart;
|
|
invoiceItem.ItemPeriodEnd = accountingPeriodEnd;
|
|
invoiceItem.GrossAmountTotal = invoiceItem.AmountTotal;
|
|
invoiceItem.ItemDescription = "Tagesstättentage";
|
|
if (scap != null)
|
|
invoiceItem.SupportConceptApprovalPeriodOid = scap.Oid;
|
|
|
|
return invoiceItem;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
public override InvoiceItem CreateInvoiceItem(ServiceRecordDC iServiceRecord, SupportConceptApprovalPeriod scap, Calculations calc)
|
|
{
|
|
var invoiceItem = new InvoiceItem();
|
|
|
|
BillingData bd = calc.GetBillingData(iServiceRecord);
|
|
|
|
invoiceItem.AmountPerUnit = bd.AmountPerUnit;
|
|
invoiceItem.UnitCount = bd.UnitCount;
|
|
invoiceItem.AmountTotal = bd.AmountTotal;
|
|
invoiceItem.ItemPeriodStart = bd.BillingPeriodStart;
|
|
invoiceItem.ItemPeriodEnd = bd.BillingPeriodEnd;
|
|
invoiceItem.RateFactor = bd.RateFactor;
|
|
invoiceItem.GrossAmountTotal = bd.GrossAmountTotal;
|
|
invoiceItem.AccountingInterval = bd.AccountingInterval;
|
|
invoiceItem.ItemDescription = iServiceRecord.ServiceDescription.Name; //iServiceRecord.Employee + " - " + iServiceRecord.ServiceDescription.Name;
|
|
invoiceItem.UnitDescription = iServiceRecord.ServiceDescription.CategoryName;
|
|
invoiceItem.Notice = iServiceRecord.SupportConcept.IsApproved.ToString();
|
|
invoiceItem.ServiceRecord = DAOFactory.GenericDAO.LoadByID<ServiceRecord>(iServiceRecord.ServiceRecordOid.Value);
|
|
if (scap != null)
|
|
invoiceItem.SupportConceptApprovalPeriodOid = scap.Oid;
|
|
|
|
return invoiceItem;
|
|
}
|
|
|
|
|
|
private InvoiceItem CreateFahrkostenInvoiceItem(List<ServiceRecordDC> serviceRecordsInPeriod, SupportConceptApprovalPeriod scap, Calculations calc)
|
|
{
|
|
int km = 0;
|
|
foreach (var sr in serviceRecordsInPeriod)
|
|
{
|
|
if (sr.DistanceInMeter.HasValue)
|
|
km += sr.DistanceInMeter.Value;
|
|
}
|
|
|
|
if (km > 0)
|
|
{
|
|
var invoiceItem = new InvoiceItem();
|
|
invoiceItem.AmountPerUnit = AMOUNT_PER_KM;
|
|
invoiceItem.UnitCount = km;
|
|
invoiceItem.UnitDescription = "km";
|
|
invoiceItem.AmountTotal = invoiceItem.UnitCount * invoiceItem.AmountPerUnit;
|
|
invoiceItem.RateFactor = null;
|
|
invoiceItem.ItemPeriodStart = accountingPeriodStart;
|
|
invoiceItem.ItemPeriodEnd = accountingPeriodEnd;
|
|
invoiceItem.GrossAmountTotal = invoiceItem.AmountTotal;
|
|
invoiceItem.ItemDescription = "gefahrene Kilometer";
|
|
if (scap != null)
|
|
invoiceItem.SupportConceptApprovalPeriodOid = scap.Oid;
|
|
|
|
return invoiceItem;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private InvoiceItem CreateFahrtpauschaleInvoiceItem(IList<InvoiceItem> list, SupportConceptApprovalPeriod scap, List<ServiceRecordDC> serviceRecordsInPeriod)
|
|
{
|
|
decimal gesamt = 0;
|
|
foreach (var sr in serviceRecordsInPeriod)
|
|
{
|
|
if (!sr.ServiceDescription.Name.Contains("Anfahrt"))
|
|
gesamt += sr.RoundedDuration;
|
|
}
|
|
|
|
if (gesamt > 0)
|
|
{
|
|
var invoiceItem = new InvoiceItem();
|
|
if (scap.ServiceCategory.Name.ToLower().Contains("qa"))
|
|
{
|
|
invoiceItem.AmountPerUnit = AMOUNT_PER_KMQA;
|
|
}
|
|
else
|
|
{
|
|
invoiceItem.AmountPerUnit = AMOUNT_PER_KMKA;
|
|
}
|
|
invoiceItem.UnitCount = gesamt;
|
|
invoiceItem.UnitDescription = "Prozent";
|
|
invoiceItem.AmountTotal = invoiceItem.UnitCount * invoiceItem.AmountPerUnit;
|
|
invoiceItem.RateFactor = null;
|
|
invoiceItem.ItemPeriodStart = accountingPeriodStart;
|
|
invoiceItem.ItemPeriodEnd = accountingPeriodEnd;
|
|
invoiceItem.GrossAmountTotal = invoiceItem.AmountTotal;
|
|
invoiceItem.ItemDescription = "Fahrtzeitenpauschale";
|
|
if (scap != null)
|
|
invoiceItem.SupportConceptApprovalPeriodOid = scap.Oid;
|
|
|
|
return invoiceItem;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public override void CheckMaxApprovedAmount(ServiceInvoice invoice, ServiceInvoicePeriod sip, SupportConceptApprovalPeriodDC scap, CostBearer2SupportConcept costBearer2SupportConcept, DateTimeSpan invoicePeriod, List<ServiceRecordDC> serviceRecords)
|
|
{
|
|
if (bthg || sip.InvoiceItemList.Any(i => i.ItemDescription.Contains("Tagesstättentage") || i.ItemDescription.Contains("vorgehaltene")))
|
|
{
|
|
// do nothing
|
|
}
|
|
|
|
else
|
|
{
|
|
if (sip.ApprovedHours.HasValue && !scap.IsApprovedBEShifting)
|
|
{
|
|
decimal totalHours = 0;
|
|
|
|
foreach (var ii in sip.InvoiceItemList.Where(ii => ii.UnitCount.HasValue))
|
|
{
|
|
if (totalHours + ii.UnitCount.Value > sip.ApprovedHours)
|
|
{
|
|
ii.UnitCount = Math.Round(sip.ApprovedHours.Value - totalHours, 2, MidpointRounding.AwayFromZero);
|
|
if (ii.AmountPerUnit.HasValue)
|
|
{
|
|
ii.AmountTotal = ii.AmountPerUnit.Value * ii.UnitCount;
|
|
ii.GrossAmountTotal = ii.AmountTotal;
|
|
}
|
|
totalHours = sip.ApprovedHours.Value;
|
|
}
|
|
else
|
|
{
|
|
totalHours += ii.UnitCount.Value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static decimal GetPreis(IList<Preis> allePreise, String name, DateTime datum)
|
|
{
|
|
var pausch = allePreise.Where(p => p.Name.Contains(name)).FirstOrDefault();
|
|
if (pausch != null)
|
|
{
|
|
var crlist = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(pausch.CostRatePeriods);
|
|
|
|
var cr = crlist.GetCostRatePeriodForDate(CostRatePeriodType.AmountOfMoney, datum);
|
|
if (cr != null && cr.CostRateValue.HasValue)
|
|
{
|
|
return cr.CostRateValue.Value;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
} |