BeWoPlaner/Report/ReportObjects/BewertungsstatistikRO.cs

using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Service.DCEntityMapper;
using BeWo.Service.ServiceImplementations;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace BeWo.Report.ReportObjects
{
    public class BewertungsstatistikRO : AbstractBeWoReportObject<BewertungsstatistikRO>
    {
        public List<BewertungsstatistikReportTabelle> BewertungsstatistikReportTabelleList { get; set; }
        public List<Wirkungskontrolle> Wirkungskontolle{ get; set; }


        public DateTime? StartDay { get; set; }
        public DateTime? EndDay { get; set; }
        public SupportConceptDC SupportConceptDC { get; set; }
        public bool ZeiterfassungEinbinden { get; set; }

        public class BewertungsstatistikReportTabelle
        {
            public string Zielname { get; set; }
            public double GesamtzeitInvestiert { get; set; }
            public double Durchschnitt { get; set; }
            public List<BewertungsstatistikZielDetail> BewertungsstatistikZielDetailList { get; set; }
        }

        public class BewertungsstatistikZielDetail
        {
            public double MinutenInvestiert { get; set; }
            public DateTime? Datum { get; set; }
            public int Note { get; set; }
        }
        public class Wirkungskontrolle
        {
            public string Benotung { get; set; }
            public decimal AnzahlVergeben { get; set; }
            public decimal AnzahlVergebenInProzent { get; set; }
        }
        public static BewertungsstatistikRO Create(DateTime? start, DateTime? end, SupportConceptDC supportConcept, bool inclZeiterfassung, List<ValueListEntryDC> ausgewaehlteZiele, List<RatingDC> scZiele)
        {
            var result = new BewertungsstatistikRO();
            result.Wirkungskontolle = new List<Wirkungskontrolle>();
            result.StartDay = start;
            result.EndDay = end;

            // Ist kein Hilfeplan gesetzt und die Listen null, dann wird für ALLE Hilfepläne erstellt
            if (supportConcept == null/* && ausgewaehlteZiele == null && scZiele == null*/)
            {
                // In diesem Dictionary wird jeder Benotung aus der Verwaltung die vergebene Menge im Zeitraum zugeordnet
                Dictionary<string, decimal> ratingTypeZuAnzahl = new Dictionary<string, decimal>();

                // Alle Ratings (Hilfeplanbewertungen) holen, die (im gewählten Zeitraum) gemacht wurden, und nachfolgend nur die GoalRatings (einzelne Zielbewertungen)
                // ins Dict holen, deren RatingOid hier drin sind
                List<RatingDC> allRatings = new List<RatingDC>();
                if (start != null && end != null)
                    allRatings = MapperFactory.RatingDC_Rating.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<Rating>())
                       .Where(r => r.StartDate >= start && r.StartDate <= end).ToList();
                else
                    allRatings = MapperFactory.RatingDC_Rating.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<Rating>());

                // Wurde in der RatingReportView kein Start- und Enddatum angegeben, dann hier die neuste und die älteste Bewertung als Datum setzen
                if (start == null && end == null && allRatings != null && allRatings.Count > 0)
                {
                    allRatings = allRatings.OrderBy(r => r.StartDate).ToList();
                    result.StartDay = allRatings[0].StartDate;
                    result.EndDay = allRatings[allRatings.Count - 1].StartDate;
                }

                // Zuerst GoalRatings (einzelne Zielbewertungen) aus Hilfeplanbewertungen in Liste packen 
                List<GoalRatingDC> allGoalRatings = new List<GoalRatingDC>();
                foreach (var rating in allRatings)
                    foreach (var goalRating in rating.GoalRatingList)
                        allGoalRatings.Add(goalRating);

                // Dann in oben genanntes Dictionary packen, um nach Bewertung zu gruppieren und die Anzahl der vergebenen Bewertung zu zählen
                foreach (var rating in allGoalRatings)
                {
                    if (rating.RatingType == null)
                        continue;

                    if (!ratingTypeZuAnzahl.ContainsKey(rating.RatingType.DisplayName))
                        ratingTypeZuAnzahl.Add(rating.RatingType.DisplayName, 0);

                    ratingTypeZuAnzahl[rating.RatingType.DisplayName]++;
                }

                // Gesamte Anzahl an Bewertungen im Zeitraum ausrechnen
                decimal gesamt = ratingTypeZuAnzahl.Sum(r => r.Value);

                // Für jede Benotung, die vergeben wurde, eine Spalte erstellen mit Name, Anzahl und %
                foreach (var pair in ratingTypeZuAnzahl)
                {
                    result.Wirkungskontolle.Add(new Wirkungskontrolle()
                    {
                        Benotung = pair.Key,
                        AnzahlVergeben = pair.Value,
                        AnzahlVergebenInProzent = gesamt > 0 ? (pair.Value / gesamt) * 100 : 0
                    });
                }
            }
            // Ist SupportConcept gesetzt, nur für einen Hilfeplan Auswertung erstellen
            else
            {
                result.ZeiterfassungEinbinden = inclZeiterfassung;
                result.SupportConceptDC = supportConcept;
                result.BewertungsstatistikReportTabelleList = new List<BewertungsstatistikReportTabelle>();


                List<GoalRatingDC> passendeZielBewertungen = new List<GoalRatingDC>();
                foreach (var item in scZiele)
                {

                    foreach (var item2 in item.GoalRatingList)
                    {
                        item2.ServiceRecord = new ServiceRecordDC
                        {
                            RoundedDuration = 0,
                            Start = item.StartDate
                        };
                        passendeZielBewertungen.Add(item2);
                    }
                }
                if (inclZeiterfassung)
                {
                    var osi = new OperationsServiceImp();
                    var serviceRecordRatings = osi.FetchServiceRecordRatings(supportConcept.SupportConceptOid, null, null, null, start, end);
                    foreach (var item in serviceRecordRatings)
                        passendeZielBewertungen.Add(item);
                }


                //List<ServiceRecord> serviceRecords = DAOFactory.SearchDAO.FindServiceRecordsForSupportConcept((long)supportConcept.SupportConceptOid);

                foreach (var ziel in ausgewaehlteZiele)
                {
                    int anzahl = 0; // Zähler für Schnittberechnung und scZiele-Index


                    var datensatz = new BewertungsstatistikReportTabelle();
                    datensatz.Zielname = ziel.DisplayName;
                    datensatz.GesamtzeitInvestiert = 0;
                    datensatz.BewertungsstatistikZielDetailList = new List<BewertungsstatistikZielDetail>();

                    foreach (var item in passendeZielBewertungen)
                    {

                        //if (item.ServiceRecord.Start.Value.Day >= start.Value.Day && item.ServiceRecord.Start <= end)
                        //{
                        if (item.GoalEntry != null && item.GoalEntry.Equals(ziel))
                        {
                            var detail = new BewertungsstatistikZielDetail();
                            if (item.RatingType != null)
                            {
                                detail.Note = item.RatingType.RatingId.Value;
                            }

                            detail.Datum = item.ServiceRecord.Start;
                            detail.MinutenInvestiert = (double)item.ServiceRecord.RoundedDuration;
                            datensatz.GesamtzeitInvestiert += detail.MinutenInvestiert;
                            anzahl++;
                            datensatz.Durchschnitt += detail.Note;
                            datensatz.BewertungsstatistikZielDetailList.Add(detail);

                        }
                    }

                    datensatz.Durchschnitt /= anzahl;
                    datensatz.Durchschnitt = Math.Round(datensatz.Durchschnitt, 2);
                    datensatz.BewertungsstatistikZielDetailList = datensatz.BewertungsstatistikZielDetailList.OrderBy(a => a.Datum).ToList<BewertungsstatistikZielDetail>();

                    //if(datensatz.GesamtzeitInvestiert != 0) //Falls Ziele ohne Zeitaufwand nicht dargestellt werden sollen
                    result.BewertungsstatistikReportTabelleList.Add(datensatz);
                }

                result.BewertungsstatistikReportTabelleList = result.BewertungsstatistikReportTabelleList.OrderBy(b => b.Zielname).ToList();
            }



            return result;
        }
    }
}