BeWoPlaner/Service/Plugins/OperationService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using BeWo.Data;
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.DataContracts.Compact;
using BS.Shared.Extensions;

namespace BeWo.Service.Plugins
{
	public class OperationService : AbstractIDSpecificDefaultClass<OperationService>
	{
        protected String ReturnMessage { get; set; }

        protected virtual bool CreateServiceRecordsIfAnyExistInDateRange { get { return false; } }

        public virtual String CreateDefaultCustomerServiceRecords(DateTime start, DateTime end, IList<long> cb2scOids)
        {

            var vs = PluginLoader.FindClass<VacationService>();
            ReturnMessage = "";

            DateTimeSpan span = new DateTimeSpan();
            span.StartDateTime = start;
            span.EndDateTime = end.AddDays(1).AddTicks(-1);

            var c2sList = DAOFactory.GenericDAO.LoadByIDs<CostBearer2SupportConcept>(cb2scOids);

            foreach (var c2s in c2sList)
            {
                var srList = DAOFactory.SearchDAO.FindServiceRecordsInSpan(c2s.Oid.Value, span).ToList();

                if (srList.Count == 0 || CreateServiceRecordsIfAnyExistInDateRange)
                {
                    var newSrList = ErstelleStundenplanEintraege(span.StartDateTime.Date, span.EndDate.Date, c2s, vs, srList);

                    DAOFactory.GenericDAO.Insert(newSrList);
                    if (ReturnMessage.Length > 0)
                    {
                        ReturnMessage += "\n";
                    }
                    ReturnMessage += String.Format("Es wurden {0} Einträge erstellt.", newSrList.Count);
                }
                else
                {
                    if (srList.Count > 1)
                    {
                        ReturnMessage = String.Format("In dem ausgewählten Zeitraum sind bereits {0} Einträge vorhanden, daher können keine weiteren Einträge automatisch erstellt werden.", srList.Count);
                    }
                    else
                    {
                        ReturnMessage = String.Format("In dem ausgewählten Zeitraum ist bereits ein Eintrag vorhanden, daher können keine weiteren Einträge automatisch erstellt werden.");
                    }
                    
                }
                
            }

            
            return ReturnMessage;
        }

        public virtual List<ServiceRecord> ErstelleStundenplanEintraege(DateTime start, DateTime ende, CostBearer2SupportConcept c2s, VacationService vs, List<ServiceRecord> existingList)
        {
            var customer = c2s.SupportConcept.Customer;

            List<ServiceRecord> serviceRecords = new List<ServiceRecord>();

            var defaultSd = GetDefaultServiceDescription(c2s);
            if (defaultSd == null)
            {
                ReturnMessage = "Es konnte keine passende Leistung ermittelt werden.";
                return serviceRecords;
            }
            while (start <= ende)
            {
                //var ferien = vs.GetFerien(start, "nrw");
                var stundenplan = GetStundenplan(customer, start, start);

                var ft = vs.GetFeiertag(start);

                //if (ferien == null && ft == null)
                if (ft == null && !HatAbwesenheit(start, customer))
                {
                    var newServiceRecords = CreateServiceRecords(stundenplan, start, c2s, defaultSd, existingList);

                    serviceRecords.AddRange(newServiceRecords);

                }

                start = start.AddDays(1);
            }

            return serviceRecords;
        }

        private bool HatAbwesenheit(DateTime start, Customer customer)
        {
            foreach (var at in customer.AbsenceTimes)
            {
                if (at.Start <= start && (!at.End.HasValue || at.End >= start))
                {
                    return true;
                }
            }
            return false;
        }

        protected virtual IList<ServiceRecord> CreateServiceRecords(Arbeitszeit arbeitszeit, DateTime datum, CostBearer2SupportConcept c2s, ServiceDescription defaultSd, List<ServiceRecord> existingList)
        {
            var records = new List<ServiceRecord>();

            if (arbeitszeit != null && arbeitszeit.ArbeitszeitEintraege != null)
            {
                foreach (var ae in arbeitszeit.ArbeitszeitEintraege)
                {
                    if (IsSameWeekday(ae, datum.DayOfWeek))
                    {
                        if (existingList == null || existingList.Count(s => s.Start.Value.Date == datum.Date) == 0)
                        {
                            var sr = CreateServiceRecord(ae, datum, c2s, defaultSd);

                            records.Add(sr);
                        }
                    }
                }

            }

            return records;


        }

        public virtual ServiceRecord CreateServiceRecord(ArbeitszeitEintrag ae, DateTime datum, CostBearer2SupportConcept c2s, ServiceDescription defaultSd)
        {
            ServiceRecord sr = new ServiceRecord();
            sr.Start = GetDateTime(ae.UhrzeitVon, datum);
            sr.End = GetDateTime(ae.UhrzeitBis, datum);
            sr.RoundedDuration = (decimal)sr.End.Value.Subtract(sr.Start.Value).TotalMinutes;

            if (ae.Employee != null)
            {
                sr.Employee = ae.Employee;
            }
            else
            {
                sr.Employee = GetHauptbetreuung(c2s.SupportConcept.Customer, datum);
            }

            if (sr.Employee == null)
            {
                sr.Employee = LoggedInUserOperationContextExt.Current.User.Employee;
            }

            sr.Customer = c2s.SupportConcept.Customer;
            sr.SupportConcept = c2s.SupportConcept;
            sr.CostBearer2SupportConcept = c2s;
            sr.ServiceDescription = defaultSd;

            sr.ServiceRecordType = ServiceRecordTypeId.DefaultActivity;
            sr.DistanceInMeter = 0;
            sr.DurationInStunden = ZeiterfassungsDauer.Minuten;
            sr.ServiceRecordFormat = ServiceRecordFormate.OriginaleZeiterfassung;
            sr.Relevance = 0;

            return sr;
        }

        public virtual Employee GetHauptbetreuung(Customer customer, DateTime date)
        {
            return customer.Employee2CustomerList.FirstOrDefault(e2c => e2c.IsActive == ActivationTypeId.Active &&
                                            (!e2c.StartDate.HasValue || e2c.StartDate.Value.Date <= date) && (!e2c.EndDate.HasValue || e2c.EndDate.Value.Date >= date) &&
                                            e2c.ValueList.Any(b => b.Entry.Type.Equals(ValueListEntryType.StaffRoleType) && 
                                            b.Entry.SystemEntryID.HasValue && b.Entry.SystemEntryID.Value == SystemEntryID.EmployeeRoleMainAttendant))?.Employee;
        }

        public virtual ServiceDescription GetDefaultServiceDescription(CostBearer2SupportConcept c2s)
        {
            foreach (var ap in c2s.ApprovalPeriodList)
            {
                if (ap.ServiceCategory != null)
                {
                    var desc = DAOFactory.SearchDAO.FindServiceDescriptionForCategory(ap.ServiceCategory.Oid.Value);

                    var sd = desc.OrderBy(a => a.Position).FirstOrDefault();

                    if (sd != null)
                    {
                        return sd;
                    }
                }
            }
            return GetDefaultServiceDescription();
        }

        public virtual ServiceDescription GetDefaultServiceDescription()
        {
            return null;
        }

        private Arbeitszeit GetStundenplan(Customer customer, DateTime start, DateTime ende)
        {
            if (customer == null)
            {
                return null;
            }
            var stundenplan = SucheStundenplan(customer.Arbeitszeiten, start, ende);
            
            return stundenplan;
        }

        private static Arbeitszeit SucheStundenplan(IList<Arbeitszeit> arbeitszeiten, DateTime start, DateTime ende)
        {
            if (arbeitszeiten != null && arbeitszeiten.Count > 0)
            {
                foreach (var az in arbeitszeiten)
                {
                    if ((!az.GueltigVon.HasValue || az.GueltigVon <= ende) && (!az.GueltigBis.HasValue || az.GueltigBis >= start))
                    {
                        return az;
                    }
                }
            }

            return null;
        }

        public static bool IsSameWeekday(ArbeitszeitEintrag ae, DayOfWeek day)
        {
            if (day == DayOfWeek.Monday && ae.Tag == AppointmentDayOfWeek.Montag)
            {
                return true;
            }
            if (day == DayOfWeek.Tuesday && ae.Tag == AppointmentDayOfWeek.Dienstag)
            {
                return true;
            }
            if (day == DayOfWeek.Wednesday && ae.Tag == AppointmentDayOfWeek.Mittwoch)
            {
                return true;
            }
            if (day == DayOfWeek.Thursday && ae.Tag == AppointmentDayOfWeek.Donnerstag)
            {
                return true;
            }
            if (day == DayOfWeek.Friday && ae.Tag == AppointmentDayOfWeek.Freitag)
            {
                return true;
            }
            if (day == DayOfWeek.Saturday && ae.Tag == AppointmentDayOfWeek.Samstag)
            {
                return true;
            }
            return false;
        }

        public static DateTime? GetDateTime(String timeAsString, DateTime date)
        {
            String dateStr = String.Format("{0:dd.MM.yyyy} {1}", date, timeAsString);

            DateTime dateOut;

            if (DateTime.TryParse(dateStr, out dateOut))
            {
                return dateOut;
            }

            return null;
        }
    }
}