BeWoPlaner/ReportImp/LebenshilfeAhrweiler/ServicesOverviewReport.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using DevExpress.XtraReports.UI;
using BeWo.Report.ReportObjects;
using BeWo.Report;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.Plugins;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.Extensions;
using LebenshilfeAhrweiler.Calculations;

namespace LebenshilfeAhrweiler
{
    public partial class Stundenzettel : DevExpress.XtraReports.UI.XtraReport, IBeWoReport<ServicesOverviewRO>
    {
        private Dictionary<long, ValueListEntryDC> goalDict = null;
        public Stundenzettel()
        {
            InitializeComponent();
        }

        public void SetReportDataSource(ServicesOverviewRO pRO)
        {
            DateTime dt = DateTime.Now.Date.AddHours(pRO.TotalFLS);

            InitGoalDict(pRO);

            //lblGeleisteteStunden.Text = String.Format("(geleistete Std.:    {0} Std. {1:00} Min.)", dt.TimeOfDay.Hours,dt.TimeOfDay.Minutes);

            decimal minutenFl = 0;
            decimal minutenAh = 0;

            List<ServicesOverviewRO.ServiceDetail> servicesList = new List<ServicesOverviewRO.ServiceDetail>();

            foreach (var sr in pRO.Services)
            {
                SetGoals(sr);

                sr.Notice2 = String.Format("{0:0}", sr.Minutes);


                if (sr.ServiceDescription == "FL-Stunde")
                {
                    sr.Notice3 = "Fl";
                    minutenFl += (decimal)sr.Minutes;
                    servicesList.Add(sr);
                }
                else if (sr.ServiceDescription == "AH-Stunde")
                {
                    sr.Notice3 = "aH";
                    minutenAh += (decimal)sr.Minutes;
                    servicesList.Add(sr);
                }
                if (sr.IsGroup)
                {
                    sr.Notice3 = String.Format("{0} / {1}", sr.Notice3, sr.CustomerCount);
                }
            }
            pRO.Services = servicesList;

            cellGesamtFl.Text = String.Format("{0:0.00}", minutenFl / 60);
            cellGesamtAh.Text = String.Format("{0:0.00}", minutenAh / 60);

            
	        //Stunden gesamtBewilligungVormonat = BerechneGesamtBewilligungVormonat(pRO);
	        //Stunden bewilligungDiesenMonat = BerechneBewilligungDiesenMonat(pRO);
			//Stunden uebertragVormonat = BerechneUebertragAusVormonaten(pRO);

            var c2s = GetCostBearer2SupportConcept(pRO);
            Stunden bewilligungDiesenMonat = Berechnungen.BerechneBewilligungDiesenMonat(c2s, pRO.StartDate, pRO.EndDate);
            Stunden uebertragVormonat = Berechnungen.BerechneUebertragAusVormonaten(c2s, pRO.StartDate);



            //Stunden test1 = Berechnungen.BerechneUebertragAusVormonaten(c2s, new DateTime(2020, 1, 1));
            //Stunden test = Berechnungen.BerechneUebertragAusVormonaten(c2s, new DateTime(2020, 2, 1));


            Stunden zuLeisten = new Stunden();
	        zuLeisten.Fl = bewilligungDiesenMonat.Fl + uebertragVormonat.Fl;
	        zuLeisten.Ah = bewilligungDiesenMonat.Ah + uebertragVormonat.Ah;

			Stunden uebertragNaechstenMonat = new Stunden();

	        uebertragNaechstenMonat.Fl = Berechnungen.BerechneDifferenzMitEinDrittelRegelung(zuLeisten.Fl, (minutenFl / 60), bewilligungDiesenMonat.Fl);
	        uebertragNaechstenMonat.Ah = Berechnungen.BerechneDifferenzMitEinDrittelRegelung(zuLeisten.Ah, (minutenAh / 60), bewilligungDiesenMonat.Ah);


			//uebertragNaechstenMonat.Fl = zuLeisten.Fl -
			//	= (sollFl + bewilligteFl) - ((geleistetFlVormonat/60) + (minutenFl/60));
			//var uebertragNaechstenMonatAh = (sollAh + bewilligteAh) - ((geleistetAhVormonat / 60) + (minutenAh / 60));

			cellBewilligtFl.Text = String.Format("{0:0.00}", bewilligungDiesenMonat.Fl);
            cellBewilligtAh.Text = String.Format("{0:0.00}", bewilligungDiesenMonat.Ah);
			
            cellUebertragFl.Text = String.Format("{0:0.00}", uebertragVormonat.Fl);
            cellUebertragAh.Text = String.Format("{0:0.00}", uebertragVormonat.Ah);

	        cellZuLeistenFl.Text = String.Format("{0:0.00}", zuLeisten.Fl);
	        cellZuLeistenAh.Text = String.Format("{0:0.00}", zuLeisten.Ah);

			lblUebertragNachstenMonatFl.Text = String.Format("{0:0.00}", uebertragNaechstenMonat.Fl);
            lblUebertragNachstenMonatAh.Text = String.Format("{0:0.00}", uebertragNaechstenMonat.Ah);

            this.bindingSource1.DataSource = pRO;
        }

        private CostBearer2SupportConcept GetCostBearer2SupportConcept(ServicesOverviewRO pRo)
        {
            if (pRo.CostBearer2SupportConceptList != null && pRo.CostBearer2SupportConceptList.Count > 0)
            {
                foreach (var c2s in pRo.CostBearer2SupportConceptList)
                {
                    if (c2s.StartDate <= pRo.EndDate && c2s.EndDate >= pRo.StartDate)
                    {
                        return c2s;
                    }
                }
                
            }

            var customer = DAOFactory.GenericDAO.LoadByID<Customer>(pRo.CustomerOid);

            foreach (var sc in customer.SupportConcepts)
            {
                if (sc.IsActive != ActivationTypeId.Deleted)
                {
                    foreach (var c2s in sc.CostBearer2SupportConceptList)
                    {
                        if (c2s.StartDate <= pRo.EndDate && c2s.EndDate >= pRo.StartDate)
                        {
                            return c2s;
                        }
                    }
                }
            }
            return null;
        }

   //     private Stunden BerechneBewilligungDiesenMonat(ServicesOverviewRO pRo)
	  //  {
		 //   Stunden std = new Stunden();
            
			//var c2s = GetCostBearer2SupportConcept(pRo);

   //         if (c2s != null)
   //         { 
   //             foreach (var scap in c2s.ApprovalPeriodList)
			//    {
			//	    if (scap.ServiceCategory != null)
			//	    {
			//			var bewilligt = BerechneBewilligung(scap, pRo.StartDate, pRo.EndDate);

			//		    if (scap.ServiceCategory.Name == "Direkte Leistung FL")
			//		    {
			//			    std.Fl += bewilligt;
			//		    }
			//		    else if (scap.ServiceCategory.Name == "Direkte Leistung aH")
			//		    {
			//			    std.Ah += bewilligt;
			//		    }
			//	    }
			//    }

			//    Customer c = GetGustomer(pRo);
			//    var at = BerechneAbwesenheitsTage(c, pRo.StartDate, pRo.EndDate);

			//    if (at > 0)
			//    {
			//	    std.Fl -= (std.Fl / 30) * at;
			//	    std.Ah -= (std.Ah / 30) * at;

			//	    if (std.Fl < 0) std.Fl = 0;
			//	    if (std.Ah < 0) std.Ah = 0;
			//	}
			    
			//}

		 //   return std;
	  //  }

	  //  private Stunden BerechneUebertragAusVormonaten(ServicesOverviewRO pRo)
	  //  {
		 //   Stunden std = new Stunden();

	  //      var c2s = GetCostBearer2SupportConcept(pRo);

	  //      if (c2s != null)
	  //      {

   //             foreach (var scap in c2s.ApprovalPeriodList)
			//	{
			//		if (scap.ServiceCategory != null && scap.StartDate.HasValue)
			//		{
			//			var stdVormonat = BerechneUebertragAusVormonaten(pRo, c2s, scap);

			//			std.Fl += stdVormonat.Fl;
			//			std.Ah += stdVormonat.Ah;
			//		}
			//	}
			//}

		 //   return std;
	  //  }

		//private Stunden BerechneUebertragAusVormonaten(ServicesOverviewRO pRo, CostBearer2SupportConcept c2s, SupportConceptApprovalPeriod scap)
		//{
		//	Stunden bewilligteStundenKumuliert = new Stunden();
		//	Stunden diffVormonat = new Stunden();


		//	if (scap.StartDate < pRo.StartDate)
		//	{
		//		IList<ServiceRecord> allServiceRecords = c2s.ServiceRecords;
		//		Customer c = GetGustomer(pRo);

		//		DateTime start = scap.StartDate.Value;
		//		DateTime end = pRo.StartDate.AddDays(-1);

		//		if (scap.EndDate.HasValue && scap.EndDate < end)
		//		{
		//			end = scap.EndDate.Value;
		//		}

		//		while (start <= end)
		//		{
		//			DateTime monatsEnde = new DateTime(start.Year, start.Month, DateTime.DaysInMonth(start.Year, start.Month));
		//			if (end < monatsEnde)
		//			{
		//				monatsEnde = end;
		//			}
		//			var bewilligteStunden = BerechneBewilligung(scap, start, monatsEnde);
		//			var at = BerechneAbwesenheitsTage(c, start, monatsEnde);

		//			if (at > 0)
		//			{
		//				bewilligteStunden -= (bewilligteStunden / 30) * at;
		//			}

		//			var ist = BerechneIst(allServiceRecords, start, monatsEnde);


					
		//			if (scap.ServiceCategory.Name == "Direkte Leistung FL")
		//			{
		//				bewilligteStundenKumuliert.Fl += bewilligteStunden;

		//				diffVormonat.Fl = (bewilligteStunden + diffVormonat.Fl) - ist.Fl;

		//				diffVormonat.Fl = BerechneDifferenz(diffVormonat.Fl, 0, bewilligteStunden);
						
		//			}
		//			else if (scap.ServiceCategory.Name == "Direkte Leistung aH")
		//			{
		//				bewilligteStundenKumuliert.Ah += bewilligteStunden;

		//				diffVormonat.Ah = (bewilligteStunden + diffVormonat.Ah) - ist.Ah;

		//				diffVormonat.Ah = BerechneDifferenz(diffVormonat.Ah, 0, bewilligteStunden);
						
		//			}

					
					

		//			start = start.AddMonths(1);
		//			start = new DateTime(start.Year, start.Month, 1);
		//		}
		//	}

		//	return diffVormonat;
		//}

  //      private decimal BerechneDifferenz(decimal soll, decimal ist, decimal bewilligtMax)
  //      {
  //          var diff = soll - ist;

  //          if (Math.Abs(diff) > bewilligtMax / 3)
  //          {
  //              if (diff >= 0)
  //              {
  //                  diff = bewilligtMax / 3;
  //              }
  //              else
  //              {
  //                  diff = -1 * (bewilligtMax / 3);
  //              }
  //          }

  //          return diff;
  //      }

  //      private Stunden BerechneIst(IList<ServiceRecord> allServiceRecords, DateTime start, DateTime end)
  //      {
  //          Stunden std = new Stunden();

  //          Dictionary<long, bool> groupBookingDict = new Dictionary<long, bool>();
  //          foreach (var item in allServiceRecords)
  //          {
  //              if (!item.GroupOid.HasValue || !groupBookingDict.ContainsKey(item.GroupOid.Value))
  //              {
  //                  if (item.Start != null && item.Start >= start && item.Start.Value < end.Date.AddDays(1))
  //                  {
  //                      if (item.ServiceDescription.Name == "FL-Stunde")
  //                      {
  //                          std.Fl += item.RoundedDuration;
  //                      }
  //                      else if (item.ServiceDescription.Name == "AH-Stunde")
  //                      {
  //                          std.Ah += item.RoundedDuration;
  //                      }

  //                      if (item.GroupOid.HasValue)
  //                          groupBookingDict.Add(item.GroupOid.Value, true);

  //                  }
  //              }
  //          }

  //          std.Fl /= 60;
  //          std.Ah /= 60;

  //          return std;
  //      }

        private Customer GetGustomer(ServicesOverviewRO pRO)
	    {
	        var c2s = GetCostBearer2SupportConcept(pRO);

	        if (c2s != null)
	        {

                return c2s.SupportConcept.Customer;
		    }

		    return null;
	    }


	    //private decimal BerechneAbwesenheitsTage(Customer customer, DateTime start, DateTime end)
	    //{
		   // decimal abwesenheit = 0;
     //       foreach (var absenceTime in customer.AbsenceTimes)
     //       {
     //           if (absenceTime.Start.HasValue && absenceTime.Start <= end)
     //           {
     //               //if (absenceTime.Start < start)
     //               //{
     //               //    DateTimeSpan spanvormonat = new DateTimeSpan();

     //               //    spanvormonat.StartDate = absenceTime.Start.Value;
     //               //    if (c2s.StartDate.HasValue && c2s.StartDate.Value > spanvormonat.StartDate)
     //               //    {
     //               //        spanvormonat.StartDate = c2s.StartDate.Value;
     //               //    }

     //               //    spanvormonat.EndDate = pRO.StartDate.AddDays(-1);

     //               //    if (absenceTime.End.HasValue && absenceTime.End < spanvormonat.EndDate)
     //               //    {
     //               //        spanvormonat.EndDate = absenceTime.End.Value;
     //               //    }

     //               //    var daysVormonat = spanvormonat.EndDate.Subtract(spanvormonat.StartDate).Days + 1;
     //               //    abwesenheitVormonate += daysVormonat;
     //               //}

     //               if (absenceTime.Start < end && (!absenceTime.End.HasValue || absenceTime.End >= start))
     //               {
     //                   DateTimeSpan span = new DateTimeSpan();

	    //                span.StartDate = start;
     //                   if (absenceTime.Start > span.StartDate)
     //                   {
	    //                    span.StartDate = absenceTime.Start.Value;
     //                   }
	    //                span.EndDate = end;

     //                   if (absenceTime.End.HasValue && absenceTime.End < span.EndDate)
     //                   {
	    //                    span.EndDate = absenceTime.End.Value;
     //                   }


     //                   var days = span.EndDate.Subtract(span.StartDate).Days + 1;
	    //                abwesenheit += days;
     //               }
     //           }
     //       }

		   // return abwesenheit;
	    //}
		
     //   private decimal BerechneBewilligung(SupportConceptApprovalPeriod scap, DateTime start, DateTime end)
     //   {
     //       decimal bewilligt = 0;

     //       if (scap.ApprovedBEPerInterval.HasValue && scap.ApprovedBEInterval.HasValue)
     //       {

	    //        if (scap.StartDate <= end && (!scap.EndDate.HasValue || scap.EndDate >= start))
	    //        {
		   //         DateTimeSpan span = new DateTimeSpan();

		   //         span.StartDate = start;
		   //         if (scap.StartDate > span.StartDate)
		   //         {
			  //          span.StartDate = scap.StartDate.Value;
		   //         }
		   //         span.EndDate = end;

		   //         if (scap.EndDate < span.EndDate)
		   //         {
			  //          span.EndDate = scap.EndDate.Value;
		   //         }

		   //         decimal bpi = scap.ApprovedBEPerInterval.Value;

		   //         switch (scap.ApprovedBEInterval.Value)
		   //         {
			  //          case SupportConceptApprovalInterval.Daily:
				 //           bewilligt = bpi * 30;
				 //           break;
			  //          case SupportConceptApprovalInterval.Weekly:
				 //           bewilligt = bpi * 4.34m;
				 //           break;
			  //          case SupportConceptApprovalInterval.Fortnightly:
				 //           bewilligt = bpi * (4.34m / 2);
				 //           break;
			  //          case SupportConceptApprovalInterval.Monthly:
				 //           bewilligt = bpi;
				 //           break;
			  //          case SupportConceptApprovalInterval.Quarterly:
				 //           bewilligt = bpi / 3m;
				 //           break;
			  //          case SupportConceptApprovalInterval.HalfYearly:
				 //           bewilligt = bpi / 6m;
				 //           break;
			  //          case SupportConceptApprovalInterval.Yearly:
				 //           bewilligt = bpi / 12m;
				 //           break;

		   //         }

					//int days = (int)span.EndDate.Subtract(span.StartDate).TotalDays + 1;

		   //         if (days != DateTime.DaysInMonth(span.StartDate.Year, span.StartDate.Month))
		   //         {
			  //          bewilligt = (bewilligt / 30) * days;
		   //         }
	    //        }
     //       }

     //       return bewilligt;
     //   }

	    private void InitGoalDict(ServicesOverviewRO pRo)
	    {
		    goalDict = new Dictionary<long, ValueListEntryDC>();
		    var vle = DAOFactory.GenericDAO.GetAllActive<ValueListEntry>();

		    var vleDc = MapperFactory.ValueListEntryDC_ValueListEntry.MapToNewDCs(vle);

		    foreach (var valueListEntryDc in vleDc)
		    {
			    goalDict.Add(valueListEntryDc.ValueListEntryOid.Value, valueListEntryDc);
		    }
	    }

	    private void SetGoals(ServicesOverviewRO.ServiceDetail sd)
	    {

		    var serviceRecord = DAOFactory.GenericDAO.LoadByID<ServiceRecord>(sd.ServiceRecordOid);

		    var srDc = MapperFactory.ServiceRecordDC_ServiceRecord.MapToNewDC(serviceRecord);

		    Dictionary<String, bool> resultDict = new Dictionary<string, bool>();
		    sd.GoalList = String.Empty;
		    if (srDc.Goals != null && srDc.Goals.Count > 0)
		    {

			    foreach (var goal in srDc.Goals)
			    {
				    AddMainGoalToDict(goal, resultDict);
			    }

			    foreach (var goalDictKey in resultDict.Keys)
			    {
				    if (sd.GoalList.Length > 0)
					    sd.GoalList += ", ";
				    sd.GoalList += goalDictKey;
			    }
		    }

	    }

	    private void AddMainGoalToDict(ValueListEntryDC goal, Dictionary<string, bool> resultDict)
	    {
		    if (goal.ParentOid.HasValue)
		    {
			    if (goalDict.ContainsKey(goal.ParentOid.Value))
			    {
				    AddMainGoalToDict(goalDict[goal.ParentOid.Value], resultDict);
			    }
		    }
		    else
		    {
			    if (!resultDict.ContainsKey(goal.TypeDescription))
			    {
				    resultDict.Add(goal.TypeDescription, true);
			    }
		    }
	    }
		
    }
	public class Stunden
	{

		public decimal Fl { get; set; }

		public decimal Ah { get; set; }

	    public decimal FlOhneDrittelRegelung { get; set; }

	    public decimal AhOhneDrittelRegelung { get; set; }

        public override string ToString()
	    {
	        return String.Format("FL: {0:0.00}, AH: {1:0.00}", Fl, Ah);
	    }
	}
}