BeWoPlaner/ReportImp/LebenshilfeFrankfurtOder/Invoicing/BesondereWohnformInvoiceCreation.cs

using BeWo.Data;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.Invoicing;
using BeWo.Service.Plugins;
using BeWo.Service.ServiceImplementations;
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 LebenshilfeFrankfurtOder.Invoicing
{

	public class BesondereWohnformInvoiceCreation : InvoiceCreation
    {
        private const decimal AMOUNT_PER_KM = 0.4m;

        private DateTime? accountingPeriodStart = null;
        private DateTime? accountingPeriodEnd = null;

        public override void SetInvoiceId(ServiceInvoice invoice)
        {
            invoice.InvoiceBase.InvoiceId = "RechnungBesondereWohnform";
            invoice.InvoiceBase.InvoiceTypeText = "Besondere Wohnform";
        }

        public override List<ServiceInvoiceDC> GenerateServiceInvoices(long costBearerOid, DateTimeSpan invoicePeriod, Dictionary<CompactSupportConceptDC, List<ServiceRecordDC>> supportConcepts2ServiceRecords)
        {
            
            var invoiceList = new List<ServiceInvoice>();

            var invoiceCounter = 0;

            var sortedScs = supportConcepts2ServiceRecords.Keys.OrderBy(s => !String.IsNullOrEmpty(s.Customer.DebitorNumber) ? s.Customer.DebitorNumber : "zzzzz").ToList();

            
            foreach (var sc in sortedScs)
            {
                var serviceRecords = supportConcepts2ServiceRecords[sc];

                if (sc.CostBearerList.Count > 0)
                {
                    
                    var costBearer = DAOFactory.GenericDAO.LoadByID<CostBearer>(sc.CostBearerList[0].CostBearerOid);

                    var invoice = CreateSingleInvoice(invoiceCounter, costBearer, invoicePeriod, sc, serviceRecords);
                    if (invoice != null)
                    {
                        SetzeCategory(invoice, serviceRecords);
                        invoiceList.Add(invoice);
                        invoiceCounter++;
                    }
                    
                }
            }
            
            var result = invoiceList.Select(item => MapperFactory.ServiceInvoiceDC_ServiceInvoice.MapToNewDC(item)).ToList();

            //return result.Count > 1 ? result.OrderBy(i => i.InvoiceBase.CustomerLastName).ToList() : result;
            return result;
        }

        private void SetzeCategory(ServiceInvoice i, List<ServiceRecordDC> records)
        {
            foreach (var sr in records)
            {
                i.Notice = String.Format("{0}", sr.ServiceDescription.Category.ServiceCategoryOid);
            }
        }
        public override ServiceInvoice CreateSingleInvoice(int invoiceCounter, CostBearer costBearer, DateTimeSpan invoicePeriod, CompactSupportConceptDC supportConcept, List<ServiceRecordDC> serviceRecords)
        {
            var i = base.CreateSingleInvoice(invoiceCounter, costBearer, invoicePeriod, supportConcept, serviceRecords);

            if (i != null)
            {
                var claim = i.GetTotalClaim();

                if (!claim.HasValue || claim.Value == 0)
                {
                    return null;
                }
            }

            return i;
        }

        public override void SetInvoiceBaseData(int invoiceCounter, ServiceInvoice invoice, CostBearer costBearer, DateTimeSpan invoicePeriod,
            IList<CompactSupportConceptDC> supportConceptList)
        {
            if (invoicePeriod != null)
            {
                accountingPeriodStart = invoicePeriod.StartDate;
                accountingPeriodEnd = invoicePeriod.EndDate;
            }
            base.SetInvoiceBaseData(invoiceCounter, invoice, costBearer, invoicePeriod, supportConceptList);
        }

        public override void SetSenderInformation(ServiceInvoice serviceInvoice)
        {
            ApplicationUser user = null;
            if (LoggedInUserOperationContextExt.Current != null)
            {
                user = LoggedInUserOperationContextExt.Current.User;
            }
            else
            {
                user = SessionFacade.LoggedInUser;
            }

            var mandator = new OperationsServiceImp().GetMandator2(false);
            serviceInvoice.InvoiceBase.SenderAddress = new Address
            {
                Street = mandator.Street,
                PostalCode = mandator.PostalCode,
                Town = mandator.Town,
                State = mandator.State
            };

            if (user != null)
            {
                serviceInvoice.InvoiceBase.CreatorFirstName = serviceInvoice.InvoiceBase.SenderFirstName = user.Employee.Person.FirstName;
                serviceInvoice.InvoiceBase.CreatorLastName = serviceInvoice.InvoiceBase.SenderLastName = user.Employee.Person.LastName;
                serviceInvoice.InvoiceBase.SenderContacts = user.Employee.Person.Contacts.Select(i => i.CopyToNew()).ToList();

            }
        }

        public override void SetServiceInvoicePeriods(ServiceInvoice invoice, CostBearer2SupportConcept costBearer2SupportConcept,
            DateTimeSpan invoicePeriod, List<ServiceRecordDC> serviceRecords)
        {
            var invoiceAccountingPeriodSpan = new DateTimeSpan
            {
                StartDateTime = invoice.InvoiceBase.AccountingPeriodStart.Value,
                EndDateTime = invoice.InvoiceBase.AccountingPeriodEnd.Value
            };

            foreach (SupportConceptApprovalPeriod iPeriod in costBearer2SupportConcept.ApprovalPeriodList)
            {
                SupportConceptApprovalPeriodDC approvalPeriodDC = MapperFactory.SupportConceptApprovalPeriodDC_SupportConceptApprovalPeriod.MapToNewDC(iPeriod);


                if (approvalPeriodDC.Span.EndDateTime < invoiceAccountingPeriodSpan.StartDateTime || approvalPeriodDC.Span.StartDateTime > invoiceAccountingPeriodSpan.EndDate)
                {
                    continue;
                }

                ServiceInvoicePeriod serviceInvoicePeriod = CreateServiceInvoicePeriod(approvalPeriodDC, invoiceAccountingPeriodSpan);
                serviceInvoicePeriod.SupportConceptApprovalPeriod = iPeriod;
                serviceInvoicePeriod.Customer = costBearer2SupportConcept.SupportConcept.Customer;

                CostBearer costBearer = costBearer2SupportConcept.CostBearer;
                List<CostRatePeriodDC> costRates = MapperFactory.CostRatePeriodDC_CostRatePeriod.MapToNewDCs(costBearer.CostRatePeriods);

                CostRatePeriodDC serviceUnit = costRates.GetCostRatePeriodForDate(CostRatePeriodType.MinutesPerServiceUnit, DateTime.Now);
                serviceInvoicePeriod.ServiceUnitName = serviceUnit.UnitName;

                SetInvoiceItems(invoice, serviceInvoicePeriod, approvalPeriodDC, costBearer2SupportConcept, invoicePeriod, serviceRecords);

                if (serviceInvoicePeriod.InvoiceItemList.Count > 0)
                    invoice.ServiceInvoicePeriodList.Add(serviceInvoicePeriod);
            }
        }

        public virtual void SetInvoiceItems(ServiceInvoice invoice,
            ServiceInvoicePeriod serviceInvoicePeriod,
            SupportConceptApprovalPeriodDC supportConceptApprovalPeriod,
            CostBearer2SupportConcept cb2sc,
            DateTimeSpan invoicePeriod,
            List<ServiceRecordDC> serviceRecords)
        {
            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)
                    {

                        String cat = i.ServiceDescription.CategoryName.ToLower().Trim();
                        
                        valid = cat.Contains("besondere wohnform");
                        
                    }
                    return valid;
                }).ToList();

            if (serviceRecordsInPeriod.Count > 0)
            {
                var itemList = CreateInvoiceItems(serviceRecordsInPeriod, invoicePeriod, serviceInvoicePeriod.SupportConceptApprovalPeriod, calc);
                serviceInvoicePeriod.InvoiceItemList.AddRange(itemList);
            }
        }

        public override IList<InvoiceItem> CreateInvoiceItems(List<ServiceRecordDC> serviceRecordsInPeriod, DateTimeSpan invoicePeriod, SupportConceptApprovalPeriod scap,
            Calculations calc)
        {
            var list = new List<InvoiceItem>();
            foreach (ServiceRecordDC iServiceRecord in serviceRecordsInPeriod)
            {
                if (!iServiceRecord.AlreadyAccounted)
                {
                    InvoiceItem invoiceItem = CreateInvoiceItem(iServiceRecord, scap, calc);
                    if (invoiceItem != null)
                    {
                        list.Add(invoiceItem);
                    }
                    iServiceRecord.AlreadyAccounted = true;
                }
            }

            //Pro Tag an dem eine Leistung existiert darf eimal der Tagessatz abgerechnet werden.
            Dictionary<int, InvoiceItem> dict = new Dictionary<int, InvoiceItem>();
            decimal tagessatz = 0;
            foreach (var item in list)
            {
                if (!dict.ContainsKey(item.ItemPeriodStart.Value.Day))
                {
                    dict.Add(item.ItemPeriodStart.Value.Day, item);
                    tagessatz = item.AmountPerUnit ?? 0;
                }
            }

            var newList = new List<InvoiceItem>();

            if (dict.Count > 0)
            {
                

                var invoiceItem = new InvoiceItem();
                invoiceItem.AmountPerUnit = tagessatz;
                invoiceItem.UnitCount = dict.Count;
                invoiceItem.UnitDescription = "Tage";
                invoiceItem.AmountTotal = invoiceItem.UnitCount * invoiceItem.AmountPerUnit;
                invoiceItem.RateFactor = null;
                invoiceItem.ItemPeriodStart = accountingPeriodStart;
                invoiceItem.ItemPeriodEnd = accountingPeriodEnd;
                invoiceItem.GrossAmountTotal = invoiceItem.AmountTotal;
                invoiceItem.ItemDescription = "Besondere Wohnform";
                if (scap != null)
                    invoiceItem.SupportConceptApprovalPeriodOid = scap.Oid;

                newList.Add(invoiceItem);
            }
            



            

            return newList;
        }

        public override InvoiceItem CreateInvoiceItem(ServiceRecordDC iServiceRecord, SupportConceptApprovalPeriod scap, Calculations calc)
        {
            var ii = base.CreateInvoiceItem(iServiceRecord, scap, calc);
            
            ii.Notice = iServiceRecord.ServiceDescription.CategoryName;
            
            return ii;
        }

       
        
    }
}