1129 lines
44 KiB
C#
1129 lines
44 KiB
C#
using BeWo.Data.Access;
|
|
using BeWo.Data.Entities;
|
|
using BeWo.Service.Configuration;
|
|
using BeWo.Service.DCEntityMapper;
|
|
using BeWo.Service.Plugins;
|
|
using BeWo.Service.Reporting;
|
|
using BeWo.Service.ServiceContracts;
|
|
using BS.Shared;
|
|
using BS.Shared.Core;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.DataContracts.Reports;
|
|
using BS.Shared.Extensions;
|
|
using BS.Shared.Services;
|
|
using DevExpress.XtraRichEdit.Model;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices.ComTypes;
|
|
using System.ServiceModel;
|
|
using System.Threading;
|
|
using Utils = BeWo.Service.Core.Utils;
|
|
|
|
namespace BeWo.Service.ServiceImplementations
|
|
{
|
|
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Single)]
|
|
public class AnalysisServiceImp : IAnalysisService
|
|
{
|
|
public CompactCustomerDC CreateCompactCustomerDC(Customer c)
|
|
{
|
|
var dc = new CompactCustomerDC();
|
|
dc.CustomerOid = c.Oid.Value;
|
|
dc.FirstName = c.Person.FirstName;
|
|
dc.LastName = c.Person.LastName;
|
|
dc.DateOfBirth = c.Person.DateOfBirth;
|
|
dc.ActivationType = c.IsActive;
|
|
dc.Sex = c.Person.Sex;
|
|
|
|
return dc;
|
|
}
|
|
|
|
|
|
|
|
public List<AccountingAnalysisDC> GetAccountingAnalysis(DateTimeSpan pSpan)
|
|
{
|
|
try
|
|
{
|
|
// return MapperFactory.AccountingTransactionDC_AccountingTransaction.MapToNewDCs(
|
|
// DAOFactory.SearchDAO.FindAccoutingTransactions(pSpan));
|
|
return null;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<FLSAnalysisRootDC> GetFLSAnalysis(FLSAnalysisConfigDC config)
|
|
{
|
|
if (config.ReportType == FLSReportType.Employee)
|
|
{
|
|
if (config.EmployeeOid.HasValue)
|
|
{
|
|
return GetEmployeeFLSAnalysisForEmployee(config);
|
|
}
|
|
return GetEmployeeFLSAnalysis(config);
|
|
|
|
}
|
|
if (config.ReportType == FLSReportType.Customer)
|
|
{
|
|
if (config.CustomerOid.HasValue)
|
|
{
|
|
return GetCustomerFLSAnalysisForCustomer(config);
|
|
}
|
|
return GetCustomerFLSAnalysis(config);
|
|
|
|
}
|
|
if (config.ReportType == FLSReportType.Costbearer)
|
|
{
|
|
return GetCostBearerFLSAnalysis(config);
|
|
}
|
|
return GetTeamFLSAnalysis(config);
|
|
|
|
}
|
|
|
|
|
|
|
|
public List<FLSAnalysisRootDC> GetCostBearerFLSAnalysis(DateTime? startDate, DateTime? endDate,
|
|
bool fetchServiceRecordNotice, List<long> goalOids)
|
|
{
|
|
var config = new FLSAnalysisConfigDC
|
|
{
|
|
StartDate = startDate,
|
|
EndDate = endDate,
|
|
FetchServiceRecordNotice = fetchServiceRecordNotice,
|
|
GoalOids = goalOids
|
|
};
|
|
|
|
return GetCostBearerFLSAnalysis(config);
|
|
}
|
|
|
|
public List<FLSAnalysisRootDC> GetCostBearerFLSAnalysis(FLSAnalysisConfigDC config)
|
|
{
|
|
try
|
|
{
|
|
var plugin = PluginLoader.FindClass<StundenuebersichtAuswertung>();
|
|
|
|
return plugin.GetCostBearerFLSAnalysis(config);
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
|
|
public List<FLSAnalysisRootDC> GetCustomerFLSAnalysis(DateTime? startDate, DateTime? endDate, bool fetchApprovedFLS,
|
|
bool fetchServiceRecordNotice, long? employeeOid, List<long> goalOids)
|
|
{
|
|
var config = new FLSAnalysisConfigDC
|
|
{
|
|
StartDate = startDate,
|
|
EndDate = endDate,
|
|
FetchApprovedFLS = fetchApprovedFLS,
|
|
FetchServiceRecordNotice = fetchServiceRecordNotice,
|
|
EmployeeOid = employeeOid,
|
|
GoalOids = goalOids
|
|
};
|
|
|
|
return GetCustomerFLSAnalysis(config);
|
|
}
|
|
|
|
public List<FLSAnalysisRootDC> GetCustomerFLSAnalysis(FLSAnalysisConfigDC config)
|
|
{
|
|
try
|
|
{
|
|
var plugin = PluginLoader.FindClass<StundenuebersichtAuswertung>();
|
|
|
|
return plugin.GetCustomerFLSAnalysis(config);
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
|
|
public List<FLSAnalysisRootDC> GetCustomerFLSAnalysisForCustomer(long customerOid, DateTime? startDate, DateTime? endDate, bool fetchApprovedFLS, bool fetchServiceRecordNotice, long? employeeOid, List<long> goalOids)
|
|
{
|
|
var config = new FLSAnalysisConfigDC
|
|
{
|
|
CustomerOid = customerOid,
|
|
StartDate = startDate,
|
|
EndDate = endDate,
|
|
FetchApprovedFLS = fetchApprovedFLS,
|
|
FetchServiceRecordNotice = fetchServiceRecordNotice,
|
|
EmployeeOid = employeeOid,
|
|
GoalOids = goalOids
|
|
};
|
|
|
|
return GetCustomerFLSAnalysisForCustomer(config);
|
|
}
|
|
|
|
public List<FLSAnalysisRootDC> GetCustomerFLSAnalysisForCustomer(FLSAnalysisConfigDC config)
|
|
{
|
|
try
|
|
{
|
|
var plugin = PluginLoader.FindClass<StundenuebersichtAuswertung>();
|
|
|
|
return plugin.GetCustomerFLSAnalysisForCustomer(config);
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
|
|
public List<FLSAnalysisRootDC> GetEmployeeFLSAnalysis(DateTime? startDate, DateTime? endDate, bool fetchApprovedFLS, bool fetchServiceRecordNotice, long? customerOid, List<long> goalOids, String text1, String text2, String text3, String text4, String text5)
|
|
{
|
|
var config = new FLSAnalysisConfigDC
|
|
{
|
|
StartDate = startDate,
|
|
EndDate = endDate,
|
|
FetchApprovedFLS = fetchApprovedFLS,
|
|
FetchServiceRecordNotice = fetchServiceRecordNotice,
|
|
CustomerOid = customerOid,
|
|
GoalOids = goalOids,
|
|
Text1 = text1,
|
|
Text2 = text2,
|
|
Text3 = text3,
|
|
Text4 = text4,
|
|
Text5 = text5
|
|
};
|
|
|
|
return GetEmployeeFLSAnalysis(config);
|
|
}
|
|
|
|
public List<FLSAnalysisRootDC> GetEmployeeFLSAnalysis(FLSAnalysisConfigDC config)
|
|
{
|
|
try
|
|
{
|
|
var plugin = PluginLoader.FindClass<StundenuebersichtAuswertung>();
|
|
|
|
return plugin.GetEmployeeFLSAnalysis(config);
|
|
// var settings = AppSettings.CreateSettings();
|
|
|
|
// var employees = config.ShouldAnalyzeArchivedEmployees ? DAOFactory.GenericDAO.GetAllActiveAndArchived<Employee>() : DAOFactory.GenericDAO.GetAllActive<Employee>();
|
|
|
|
//// (Archiviert) hinter dem Vornamen archivierter Mitarbeiter anzeigen?
|
|
////if(config.ShouldAnalyzeArchivedEmployees)
|
|
//// foreach (var emp in employees)
|
|
//// {
|
|
//// if (emp.IsActive.Equals(ActivationTypeId.Archived))
|
|
//// emp.Person.FirstName += " (Archiviert)";
|
|
//// }
|
|
|
|
// return (from iEmployee in employees where CheckEmployeeTextProperties(iEmployee, config.Text1, config.Text2, config.Text3, config.Text4, config.Text5) select CreateEmployeeFLSRootDC(iEmployee, config, settings.ShowRoundedDurationInEmployeeAnalysis)).ToList();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<FLSAnalysisRootDC> GetEmployeeFLSAnalysisForEmployee(long employeeOid, DateTime? startDate, DateTime? endDate, bool fetchApprovedFLS, bool fetchServiceRecordNotice, long? customerOid, List<long> goalOids)
|
|
{
|
|
var config = new FLSAnalysisConfigDC
|
|
{
|
|
EmployeeOid = employeeOid,
|
|
StartDate = startDate,
|
|
EndDate = endDate,
|
|
FetchApprovedFLS = fetchApprovedFLS,
|
|
FetchServiceRecordNotice = fetchServiceRecordNotice,
|
|
CustomerOid = customerOid,
|
|
GoalOids = goalOids
|
|
};
|
|
|
|
return GetEmployeeFLSAnalysisForEmployee(config);
|
|
}
|
|
|
|
public List<FLSAnalysisRootDC> GetEmployeeFLSAnalysisForEmployee(FLSAnalysisConfigDC config)
|
|
{
|
|
try
|
|
{
|
|
var plugin = PluginLoader.FindClass<StundenuebersichtAuswertung>();
|
|
|
|
return plugin.GetEmployeeFLSAnalysisForEmployee(config);
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<FLSAnalysisRootDC> GetTeamFLSAnalysis(DateTime? startDate, DateTime? endDate, bool fetchServiceRecordNotice, List<long> goalOids, List<long> teamOids)
|
|
{
|
|
var config = new FLSAnalysisConfigDC
|
|
{
|
|
StartDate = startDate,
|
|
EndDate = endDate,
|
|
FetchServiceRecordNotice = fetchServiceRecordNotice,
|
|
GoalOids = goalOids,
|
|
TeamOids = teamOids
|
|
};
|
|
|
|
return GetTeamFLSAnalysis(config);
|
|
}
|
|
|
|
public List<FLSAnalysisRootDC> GetTeamFLSAnalysis(FLSAnalysisConfigDC config)
|
|
{
|
|
try
|
|
{
|
|
var plugin = PluginLoader.FindClass<StundenuebersichtAuswertung>();
|
|
|
|
return plugin.GetTeamFLSAnalysis(config);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw (BeWo.Service.Core.Utils.CreateBeWoFaultException(e));
|
|
}
|
|
}
|
|
|
|
public List<CompactSupportConceptDC> GetExpiringSupportConcepts(long? employeeOid, DateTime expiredUntil)
|
|
{
|
|
try
|
|
{
|
|
var hcg = PluginLoader.FindClass<HomeContentGenerator>();
|
|
|
|
return hcg.GetExpiringSupportConcepts(employeeOid, expiredUntil);
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<LoginDC> GetLastLogins(string loginName)
|
|
{
|
|
try
|
|
{
|
|
return MapperFactory.LoginDC_Login.MapToNewDCs(DAOFactory.SearchDAO.FindLastLogins(loginName, 10));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<FinanceOverviewItemDC> GetOutstandingReceivables(bool showOnlyOutstanding, bool showOnlyArchivedSCs)
|
|
{
|
|
return GetOutstandingReceivables(showOnlyOutstanding, showOnlyArchivedSCs, null, null);
|
|
}
|
|
|
|
public List<FinanceOverviewItemDC> GetOutstandingReceivables(bool showOnlyOutstanding, bool showOnlyArchivedSCs, DateTime? start, DateTime? end)
|
|
{
|
|
try
|
|
{
|
|
List<FinanceOverviewItemDC> result = new List<FinanceOverviewItemDC>();
|
|
var financeItemsByCb2scOid = new Dictionary<long, FinanceOverviewItemDC>();
|
|
IEnumerable<SupportConcept> scList = DAOFactory.SearchDAO.GetAllActiveAndArchivedSupportConcepts();
|
|
foreach (SupportConcept sc in scList)
|
|
{
|
|
foreach (CostBearer2SupportConcept cb2sc in sc.CostBearer2SupportConceptList)
|
|
{
|
|
if (!financeItemsByCb2scOid.ContainsKey(cb2sc.Oid.Value))
|
|
{
|
|
bool cont = true;
|
|
|
|
if (end.HasValue && cb2sc.StartDate.HasValue && cb2sc.StartDate > end)
|
|
{
|
|
cont = false;
|
|
}
|
|
|
|
if (cont)
|
|
{
|
|
DateTime? hilfeplanEnde = cb2sc.EndDate;
|
|
|
|
if (hilfeplanEnde.HasValue && cb2sc.SupportConcept.Customer.TerminationDate.HasValue &&
|
|
cb2sc.SupportConcept.Customer.TerminationDate < hilfeplanEnde)
|
|
{
|
|
hilfeplanEnde = cb2sc.SupportConcept.Customer.TerminationDate;
|
|
}
|
|
if (start.HasValue && hilfeplanEnde.HasValue && hilfeplanEnde < start)
|
|
{
|
|
cont = false;
|
|
}
|
|
}
|
|
if (cont)
|
|
{
|
|
FinanceOverviewItemDC dc = new FinanceOverviewItemDC();
|
|
result.Add(dc);
|
|
|
|
dc.SupportConcept = this.CreateCompactSupportConceptDC(sc);
|
|
dc.CostBearer = this.CreateCompactCostBearerDC(cb2sc);
|
|
//if (cb2sc.ApprovalPeriodList != null && cb2sc.ApprovalPeriodList.Count > 0)
|
|
//{
|
|
// foreach (var scap in cb2sc.ApprovalPeriodList)
|
|
// {
|
|
// dc.AmountTotal = this.GetTotalAmount(cb2sc);
|
|
// }
|
|
//}
|
|
dc.AmountTotal = this.GetTotalAmount(cb2sc);
|
|
financeItemsByCb2scOid.Add(cb2sc.Oid.Value, dc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
IEnumerable<AccountingTransaction> atList = DAOFactory.SearchDAO.GetAllAccountingTransactionsWithDetails();
|
|
|
|
foreach (AccountingTransaction at in atList)
|
|
{
|
|
if (at.CostBearer2SupportConcept == null ||
|
|
(at.CostBearer2SupportConcept.SupportConcept.IsActive != ActivationTypeId.Deleted &&
|
|
at.CostBearer2SupportConcept.SupportConcept.Customer.IsActive != ActivationTypeId.Deleted))
|
|
{
|
|
FinanceOverviewItemDC dc;
|
|
long oid = -1;
|
|
if (at.CostBearer2SupportConcept != null)
|
|
{
|
|
oid = at.CostBearer2SupportConcept.Oid.Value;
|
|
}
|
|
|
|
if (financeItemsByCb2scOid.ContainsKey(oid))
|
|
{
|
|
dc = financeItemsByCb2scOid[oid];
|
|
dc.AmountPaid += at.Amount;
|
|
|
|
//DateTime dt = at.BookingDate.Value;
|
|
//if (at.GueltigkeitsDatum.HasValue)
|
|
//{
|
|
// dt = at.GueltigkeitsDatum.Value;
|
|
//}
|
|
|
|
//if (start <= dt && dt <= end)
|
|
//{
|
|
// dc.AmountPaidInReportTimeSpan += at.Amount;
|
|
//}
|
|
//AccountingTransactionDC atdc = this.CreateAccountingTransactionDC(at);
|
|
//dc.AccountingTransactions.Add(atdc);
|
|
}
|
|
//else
|
|
//{
|
|
// dc = new FinanceOverviewItemDC();
|
|
// result.Add(dc);
|
|
|
|
// if (at.CostBearer2SupportConcept != null)
|
|
// {
|
|
// dc.SupportConcept =
|
|
// this.CreateCompactSupportConceptDC(at.CostBearer2SupportConcept.SupportConcept);
|
|
// dc.CostBearer = this.CreateCompactCostBearerDC(at.CostBearer2SupportConcept);
|
|
// dc.AmountTotal = this.GetTotalAmount(at.CostBearer2SupportConcept);
|
|
// }
|
|
|
|
// financeItemsByCb2scOid.Add(oid, dc);
|
|
//}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
return result.OrderBy(
|
|
item =>
|
|
{
|
|
if (item.SupportConcept == null || item.SupportConcept.Customer == null)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
return item.SupportConcept.Customer.LastName + ", " + item.SupportConcept.Customer.FirstName;
|
|
}).ToList();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<CompactPersonDC> GetPersonsHavingBirthday(DateTime birthdayUntil)
|
|
{
|
|
try
|
|
{
|
|
var hcg = PluginLoader.FindClass<HomeContentGenerator>();
|
|
|
|
return hcg.GetPersonsHavingBirthday(birthdayUntil);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
|
|
public List<SupportConceptOverviewDC> GetSupportConceptAnalysis(long? currentEmployeeOid,
|
|
bool showOnlyRelatedSCs,
|
|
bool showArchivedSCs,
|
|
DateTime? appointedDate)
|
|
{
|
|
return GetSupportConceptAnalysis2(currentEmployeeOid, null, appointedDate, null, showArchivedSCs);
|
|
}
|
|
|
|
public List<SupportConceptOverviewDC> GetSupportConceptAnalysis2(long? employeeOid, long? teamOid, DateTime? appointedDate, int? expiredMonths, bool showArchivedScs)
|
|
{
|
|
try
|
|
{
|
|
var ac = PluginLoader.FindClass<SupportConceptAnalysisCreator>();
|
|
|
|
return ac.GetSupportConceptAnalysis(null, employeeOid, teamOid, appointedDate, expiredMonths, showArchivedScs);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SupportConceptOverviewDC> GetSupportConceptAnalysis3(long? employeeOid, long? teamOid, long? catOid, DateTime? appointedDate, int? expiredMonths, bool showArchivedScs)
|
|
{
|
|
try
|
|
{
|
|
var ac = PluginLoader.FindClass<SupportConceptAnalysisCreator>();
|
|
|
|
return ac.GetSupportConceptAnalysis2(null, employeeOid, teamOid, catOid, null, appointedDate, expiredMonths, showArchivedScs);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SupportConceptOverviewDC> GetSupportConceptAnalysis4(long? employeeOid, long? teamOid, long? catOid, DateTime? startDate, DateTime? endDate, int? expiredMonths, bool showArchivedScs)
|
|
{
|
|
try
|
|
{
|
|
var ac = PluginLoader.FindClass<SupportConceptAnalysisCreator>();
|
|
|
|
return ac.GetSupportConceptAnalysis2(null, employeeOid, teamOid, catOid, startDate, endDate, expiredMonths, showArchivedScs);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<SupportConceptOverviewDC> GetSupportConceptAnalysisWithC2SOids(IList<long> c2sOids, DateTime? appointedDate)
|
|
{
|
|
try
|
|
{
|
|
var ac = PluginLoader.FindClass<SupportConceptAnalysisCreator>();
|
|
|
|
return ac.GetSupportConceptAnalysis(c2sOids, null, null, appointedDate, null, true);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
|
|
public List<CompactSupportConceptDC> GetSupportConceptsWithConferenceDate(long? employeeOid, DateTime conferenceDateUntil)
|
|
{
|
|
try
|
|
{
|
|
var g = PluginLoader.FindClass<HomeContentGenerator>();
|
|
|
|
return g.GetSupportConceptsWithConferenceDate(employeeOid, conferenceDateUntil);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<TaskDC> GetTasksForEmployee(long employeeOid)
|
|
{
|
|
try
|
|
{
|
|
var g = PluginLoader.FindClass<HomeContentGenerator>();
|
|
|
|
return g.GetTasksForEmployee(employeeOid);
|
|
|
|
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
public List<TaskDC> GetTasksForEmployeeByDate(long employeeOid, DateTime date)
|
|
{
|
|
try
|
|
{
|
|
return MapperFactory.TaskDC_Task.MapToNewDCs(DAOFactory.SearchDAO.GetTasksForEmployeeByDate(employeeOid, date));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
|
|
private AccountingTransactionDC CreateAccountingTransactionDC(AccountingTransaction at)
|
|
{
|
|
var dc = new AccountingTransactionDC();
|
|
|
|
dc.AccountingTransactionOid = at.Oid;
|
|
dc.AccountingTransactionVersion = at.Version;
|
|
dc.Amount = at.Amount;
|
|
dc.InsertedOn = at.InsTs;
|
|
dc.InsUser = at.InsUser;
|
|
|
|
var lCat = at.ValueList.SingleOrDefault(entry => entry.Entry.Type == ValueListEntryType.AccountingTransactionType);
|
|
if (lCat != null)
|
|
{
|
|
dc.Category = MapperFactory.ValueListEntryDC_ValueListEntry.MapToNewDC(lCat.Entry);
|
|
}
|
|
|
|
dc.Notice = at.Notice;
|
|
dc.BookingDate = at.BookingDate;
|
|
dc.ValidityDate = at.ValidityDate;
|
|
|
|
return dc;
|
|
}
|
|
|
|
private CompactCostBearerDC CreateCompactCostBearerDC(CostBearer2SupportConcept entity)
|
|
{
|
|
var dc = new CompactCostBearerDC();
|
|
|
|
if (entity.CostBearer != null && entity.CostBearer.Organisation != null)
|
|
{
|
|
var orgDC = new CompactOrganisationDC();
|
|
orgDC.Name = entity.CostBearer.Organisation.Name;
|
|
orgDC.OrganisationOid = entity.CostBearer.Organisation.Oid.Value;
|
|
dc.Organisation = orgDC;
|
|
|
|
dc.IsCalculatingWithFactor = entity.CostBearer.IsCalculatingWithFactor;
|
|
|
|
// dc.Street = entity.CostBearer.Organisation.Address.Street;
|
|
// dc.PostalCode = entity.CostBearer.Organisation.Address.PostalCode;
|
|
// dc.Town = entity.CostBearer.Organisation.Address.Town;
|
|
}
|
|
|
|
dc.CostBearer2SupportConceptOid = entity.Oid.Value;
|
|
dc.CustomerReferenceNumber = entity.CustomerReferenceNumber;
|
|
dc.RequestedStartDate = entity.RequestedStartDate;
|
|
dc.RequestedEndDate = entity.RequestedEndDate;
|
|
dc.ApprovedStartDate = entity.ApprovedStartDate;
|
|
dc.ApprovedEndDate = entity.ApprovedEndDate;
|
|
|
|
// dc.ApprovedFLS = entity.ApprovedFLS;
|
|
// dc.ApprovedFLSTotal = entity.ApprovedFLSTotal;
|
|
dc.SupportConceptStatus = entity.Status;
|
|
|
|
return dc;
|
|
}
|
|
|
|
private CompactSupportConceptDC CreateCompactSupportConceptDC(SupportConcept entity)
|
|
{
|
|
var dc = new CompactSupportConceptDC();
|
|
|
|
dc.SupportConceptOid = entity.Oid.Value;
|
|
dc.SupportConceptVersion = entity.Version.Value;
|
|
|
|
dc.ActivationType = entity.IsActive;
|
|
dc.ConferenceDate = entity.ConferenceDate;
|
|
|
|
dc.Customer = this.CreateCompactCustomerDC(entity.Customer);
|
|
|
|
return dc;
|
|
}
|
|
|
|
|
|
|
|
// private Dictionary<SupportConceptApprovalPeriod, DateTimeSpan> GetPeriodSpans(CostBearer2SupportConcept iCb2Sc)
|
|
// {
|
|
// var result = new Dictionary<SupportConceptApprovalPeriod, DateTimeSpan>();
|
|
|
|
// var ordered = iCb2Sc.ApprovalPeriodList.Where(i => i.EndDate.HasValue).OrderBy(i => i.EndDate).ToList();
|
|
// ordered.Add(iCb2Sc.ApprovalPeriodList.Single(i => !i.EndDate.HasValue));
|
|
|
|
// var currentStart = iCb2Sc.ApprovedStartDate.Value;
|
|
|
|
// foreach (var iPeriod in ordered)
|
|
// {
|
|
// var end = iPeriod.EndDate.HasValue
|
|
// ? iPeriod.EndDate.Value
|
|
// : iCb2Sc.ApprovedEndDate.Value;
|
|
// result.Add(iPeriod, new DateTimeSpan
|
|
// {
|
|
// StartDateTime = currentStart,
|
|
// EndDateTime = end
|
|
// });
|
|
// currentStart = end;
|
|
// }
|
|
|
|
// return result;
|
|
// }
|
|
|
|
private decimal GetTotalAmount(CostBearer2SupportConcept cb2sc)
|
|
{
|
|
var calc = PluginLoader.FindClass<Calculations>(cb2sc.CostBearer.ID) ?? Calculations.GetInstance(cb2sc.CostBearer.ID);
|
|
|
|
return calc.GetApprovedAmountTotal(cb2sc.MapToNewDC()) ?? 0m;
|
|
|
|
// decimal amount = 0;
|
|
|
|
// if (cb2sc != null)
|
|
// {
|
|
// CostBearer2SupportConceptData data = new CostBearer2SupportConceptData();
|
|
// data.RequestedStartDate = cb2sc.RequestedStartDate;
|
|
// data.RequestedEndDate = cb2sc.RequestedEndDate;
|
|
// data.ApprovedStartDate = cb2sc.ApprovedStartDate;
|
|
// data.ApprovedEndDate = cb2sc.ApprovedEndDate;
|
|
// data.MonthlyPayment = cb2sc.MonthlyPayment;
|
|
// //data.ApprovedFLS = cb2sc.ApprovedFLS;
|
|
// //data.ApprovedFLSTotal = cb2sc.ApprovedFLSTotal;
|
|
|
|
// if (cb2sc.CostBearer != null)
|
|
// {
|
|
// // data.IsCalculatingWithFactor = cb2sc.CostBearer.IsCalculatingWithFactor;
|
|
// }
|
|
|
|
// List<CostRate> crList = new List<CostRate>();
|
|
// foreach (var item in cb2sc.CostBearer.CostRatePeriods)
|
|
// {
|
|
// CostRate cr = new CostRate();
|
|
|
|
// cr.Amount = item.CostRateValue;
|
|
// cr.CostRateType = (CostRateType)item.CostRateType;
|
|
// cr.EndDate = item.EndDate;
|
|
// cr.StartDate = item.StartDate;
|
|
// crList.Add(cr);
|
|
// }
|
|
|
|
// data.CostRateList = crList;
|
|
// amount = CostRateCalculationService.GetAmountTotal(data);
|
|
// }
|
|
// return amount;
|
|
}
|
|
|
|
|
|
|
|
private ServiceRecordFLSOverviewDC CreateServiceRecordFLSOverviewDC(ServiceRecord sr, bool useGroupInfo, bool useRoundedDuration)
|
|
{
|
|
ServiceRecordFLSOverviewDC srDC = new ServiceRecordFLSOverviewDC();
|
|
|
|
srDC.Start = sr.Start;
|
|
srDC.End = sr.End;
|
|
srDC.DistanceInMeter = (int?)sr.DistanceInMeter;
|
|
srDC.DistanceInMeterDecimal = sr.DistanceInMeter;
|
|
srDC.Notice = sr.Notice;
|
|
srDC.Notice2 = sr.Notice2;
|
|
srDC.Notice3 = sr.Notice3;
|
|
srDC.Notice4 = sr.Notice4;
|
|
srDC.Notice5 = sr.Notice5;
|
|
srDC.InsertedOn = sr.InsTs;
|
|
srDC.InsUser = sr.InsUser;
|
|
if (useRoundedDuration)
|
|
{
|
|
srDC.RoundedDuration = sr.RoundedDuration;
|
|
}
|
|
else
|
|
{
|
|
srDC.RoundedDuration = (decimal)sr.End.Value.Subtract(sr.Start.Value).TotalMinutes;
|
|
}
|
|
if (sr.ServiceDescription != null)
|
|
srDC.ServiceDescription = MapperFactory.ServiceDescriptionDC_ServiceDescription.MapToNewDC(sr.ServiceDescription);
|
|
|
|
srDC.ServiceRecordOid = sr.Oid;
|
|
srDC.EmployeeOid = sr.EmployeeOid;
|
|
srDC.CustomerOid = sr.CustomerOid;
|
|
srDC.CostBearer2SupportConceptOid = sr.CostBearer2SupportConceptOid;
|
|
|
|
if (useGroupInfo)
|
|
{
|
|
srDC.GroupEmployeeCount = sr.GroupEmployeeCount;
|
|
srDC.GroupPersonCount = sr.GroupPersonCount;
|
|
srDC.GroupRoundedDuration = sr.GroupRoundedDuration;
|
|
srDC.GroupOid = sr.GroupOid;
|
|
}
|
|
return srDC;
|
|
}
|
|
|
|
public List<AuslastungAnalysisRootDC> GetAuslastungAnalysis(DateTime? startDate, DateTime? endDate, long? employeeOid, long? teamOid)
|
|
{
|
|
try
|
|
{
|
|
var lResult = new List<AuslastungAnalysisRootDC>();
|
|
|
|
var settings = AppSettings.CreateSettings();
|
|
|
|
AuslastungAnalysisRootDC root = new AuslastungAnalysisRootDC();
|
|
root.StartDate = startDate;
|
|
root.EndDate = endDate;
|
|
lResult.Add(root);
|
|
|
|
if (teamOid.HasValue)
|
|
{
|
|
Team team = DAOFactory.GenericDAO.LoadByID<Team>(teamOid.Value);
|
|
|
|
root.Team = MapperFactory.CompactTeamDC_Team.MapToNewDC(team);
|
|
foreach (var item in team.MemberList)
|
|
{
|
|
var a = CreateEmployeeAuslastung(item, startDate, endDate, settings.ShowRoundedDurationInEmployeeAnalysis);
|
|
root.EmployeeAnalysisList.Add(a);
|
|
root.TotalFLM += a.TotalFLM;
|
|
}
|
|
|
|
|
|
}
|
|
else if (employeeOid.HasValue)
|
|
{
|
|
var emp = DAOFactory.GenericDAO.LoadByID<Employee>(employeeOid.Value);
|
|
|
|
root.EmployeeAnalysisList.Add(CreateEmployeeAuslastung(emp, startDate, endDate, settings.ShowRoundedDurationInEmployeeAnalysis));
|
|
}
|
|
else
|
|
{
|
|
IList<Employee> list = DAOFactory.GenericDAO.GetAllActive<Employee>();
|
|
|
|
foreach (var emp in list)
|
|
{
|
|
root.EmployeeAnalysisList.Add(CreateEmployeeAuslastung(emp, startDate, endDate, settings.ShowRoundedDurationInEmployeeAnalysis));
|
|
}
|
|
|
|
}
|
|
if (root.EmployeeAnalysisList.Count > 1)
|
|
root.EmployeeAnalysisList.Sort((a, b) => (a.EmployeeLastName + ", " + a.EmployeeFirstName).CompareTo(b.EmployeeLastName + ", " + b.EmployeeFirstName));
|
|
return lResult;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw (BeWo.Service.Core.Utils.CreateBeWoFaultException(e));
|
|
}
|
|
}
|
|
|
|
private AuslastungAnalysisEmployeeDC CreateEmployeeAuslastung(Employee emp, DateTime? startDate, DateTime? endDate, bool useRoundedDuration)
|
|
{
|
|
AuslastungAnalysisEmployeeDC empDC = new AuslastungAnalysisEmployeeDC();
|
|
empDC.EmployeeOid = emp.Oid;
|
|
empDC.EmployeeFirstName = emp.Person.FirstName;
|
|
empDC.EmployeeLastName = emp.Person.LastName;
|
|
|
|
Contract contract = emp.LastContract;
|
|
if (contract != null && contract.WeeklyFLS.HasValue)
|
|
empDC.WeeklyTotalHours = contract.WeeklyTotalHours;
|
|
|
|
if (contract != null && contract.MonthlyTotalHours.HasValue)
|
|
empDC.MonthlyTotalHours = contract.MonthlyTotalHours;
|
|
|
|
IList<ServiceRecord> serviceRecords = null;
|
|
|
|
if (startDate != null && endDate != null)
|
|
{
|
|
var span = new DateTimeSpan();
|
|
span.StartDateTime = startDate.Value;
|
|
span.EndDateTime = endDate.Value;
|
|
serviceRecords = DAOFactory.SearchDAO.FindEmployeeServiceRecords(emp.Oid.Value, span, null, null);
|
|
}
|
|
else
|
|
{
|
|
serviceRecords = emp.ServiceRecordList;
|
|
}
|
|
|
|
//supportconcepts by costbearer2supportconceptoid
|
|
Dictionary<long, AuslastungAnalysisSupportConceptDC> supportConceptDict = new Dictionary<long, AuslastungAnalysisSupportConceptDC>();
|
|
if (emp.Employee2CustomerList != null)
|
|
{
|
|
foreach (Employee2Customer e2c in emp.Employee2CustomerList)
|
|
{
|
|
bool isMainAttendant = false;
|
|
if (e2c.ValueList.Count > 0)
|
|
{
|
|
SystemEntryID? id = e2c.ValueList[0].Entry.SystemEntryID;
|
|
if (id.HasValue && id.Value == SystemEntryID.EmployeeRoleMainAttendant)
|
|
isMainAttendant = true;
|
|
}
|
|
if (isMainAttendant && e2c.Customer != null)
|
|
{
|
|
if (e2c.Customer.IsActive != ActivationTypeId.Deleted && e2c.Customer.SupportConcepts != null)
|
|
{
|
|
foreach (SupportConcept sc in e2c.Customer.SupportConcepts)
|
|
{
|
|
if (sc.IsActive != ActivationTypeId.Deleted && sc.CostBearer2SupportConceptList != null)
|
|
{
|
|
foreach (CostBearer2SupportConcept cb2sc in sc.CostBearer2SupportConceptList)
|
|
{
|
|
bool inTimeRange = true;
|
|
|
|
if (startDate.HasValue && endDate.HasValue)
|
|
{
|
|
DateTime? start = cb2sc.ApprovedStartDate;
|
|
if (!start.HasValue)
|
|
start = cb2sc.RequestedStartDate;
|
|
|
|
DateTime? end = cb2sc.ApprovedEndDate;
|
|
if (!end.HasValue)
|
|
end = cb2sc.RequestedEndDate;
|
|
if (start.HasValue && end.HasValue)
|
|
{
|
|
if (start > endDate || end < startDate)
|
|
{
|
|
inTimeRange = false;
|
|
}
|
|
}
|
|
}
|
|
if (inTimeRange && !supportConceptDict.ContainsKey(cb2sc.Oid.Value))
|
|
{
|
|
|
|
//if (scStartDate == null || scEndDate == null || ())
|
|
AuslastungAnalysisSupportConceptDC scDC = new AuslastungAnalysisSupportConceptDC();
|
|
scDC.ServiceRecords = new List<ServiceRecordFLSOverviewDC>();
|
|
supportConceptDict.Add(cb2sc.Oid.Value, scDC);
|
|
CompactCustomerDC cdc = CreateCompactCustomerDC(e2c.Customer);
|
|
scDC.CustomerOid = cdc.CustomerOid;
|
|
scDC.CustomerFirstName = cdc.FirstName;
|
|
scDC.CustomerLastName = cdc.LastName;
|
|
|
|
scDC.CostBearer2SupportConcept = MapperFactory.SupportConceptCostBearerRelDC_CostBearer2SupportConcept.MapToNewDC(cb2sc);
|
|
empDC.SupportConceptAnalysisList.Add(scDC);
|
|
}
|
|
else
|
|
{
|
|
//AuslastungAnalysisSupportConceptDC scDCTemp = new AuslastungAnalysisSupportConceptDC();
|
|
|
|
//scDCTemp.Customer = CreateCompactCustomerDC(e2c.Customer);
|
|
//scDCTemp.CostBearer2SupportConcept = MapperFactory.SupportConceptCostBearerRelDC_CostBearer2SupportConcept.MapToNewDC(cb2sc);
|
|
|
|
|
|
//AuslastungAnalysisSupportConceptDC scDC2 = supportConceptDict[cb2sc.Oid.Value];
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
AuslastungAnalysisSupportConceptDC otherDC = null;
|
|
Dictionary<long, ServiceRecord> groupBookingDict = new Dictionary<long, ServiceRecord>();
|
|
foreach (ServiceRecord sr in serviceRecords)
|
|
{
|
|
bool cont = true;
|
|
if (sr.Customer != null && sr.Customer.IsActive == ActivationTypeId.Deleted)
|
|
cont = false;
|
|
if (cont && sr.SupportConcept != null && sr.SupportConcept.IsActive == ActivationTypeId.Deleted)
|
|
cont = false;
|
|
|
|
if (cont && sr.GroupOid != null && groupBookingDict.ContainsKey(sr.GroupOid.Value))
|
|
cont = false;
|
|
|
|
if (cont)
|
|
{
|
|
ServiceRecordFLSOverviewDC srDC = CreateServiceRecordFLSOverviewDC(sr, true, useRoundedDuration);
|
|
|
|
if (srDC.GroupOid != null)
|
|
{
|
|
groupBookingDict.Add(sr.GroupOid.Value, sr);
|
|
}
|
|
|
|
if (sr.CostBearer2SupportConceptOid != null && sr.CustomerOid != null)
|
|
{
|
|
AuslastungAnalysisSupportConceptDC scDC = null;
|
|
if (supportConceptDict.ContainsKey(sr.CostBearer2SupportConceptOid.Value))
|
|
{
|
|
scDC = supportConceptDict[sr.CostBearer2SupportConceptOid.Value];
|
|
|
|
//if (scDC == null)
|
|
//{
|
|
|
|
//scDC = new AuslastungAnalysisSupportConceptDC();
|
|
//supportConceptDict.Add(sr.CostBearer2SupportConceptOid.Value, scDC);
|
|
|
|
//Customer c = sr.Customer;
|
|
//if (c != null)
|
|
//{
|
|
// scDC.Customer = CreateCompactCustomerDC(c);
|
|
//}
|
|
|
|
//CostBearer2SupportConcept c2s = sr.CostBearer2SupportConcept;
|
|
//if (c2s != null)
|
|
//{
|
|
// scDC.CostBearer2SupportConcept = MapperFactory.SupportConceptCostBearerRelDC_CostBearer2SupportConcept.MapToNewDC(c2s);
|
|
//}
|
|
|
|
|
|
//empDC.SupportConceptAnalysisList.Add(scDC);
|
|
|
|
//}
|
|
scDC.ServiceRecords.Add(srDC);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (otherDC == null)
|
|
{
|
|
otherDC = new AuslastungAnalysisSupportConceptDC();
|
|
otherDC.ServiceRecords = new List<ServiceRecordFLSOverviewDC>();
|
|
|
|
}
|
|
otherDC.ServiceRecords.Add(srDC);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
empDC.SupportConceptAnalysisList.Sort((a, b) => (a.CustomerLastName + ", " + a.CustomerFirstName).CompareTo(b.CustomerLastName + ", " + b.CustomerFirstName));
|
|
|
|
if (otherDC != null)
|
|
empDC.SupportConceptAnalysisList.Add(otherDC);
|
|
return empDC;
|
|
}
|
|
|
|
public List<AnnualReportDC> CreateAnnualReport2(AnnualReportConfigDC config)
|
|
{
|
|
try
|
|
{
|
|
//AnnualReportFactory factory = null;
|
|
//CostBearer cb = null;
|
|
|
|
//if (config.CostbearerOid.HasValue)
|
|
//{
|
|
// cb = DAOFactory.GenericDAO.LoadByID<CostBearer>(config.CostbearerOid.Value);
|
|
|
|
// factory = PluginLoader.FindClass<AnnualReportFactory>(cb.ID) ?? AnnualReportFactory.GetInstance(cb.ID);
|
|
//}
|
|
//if (factory == null)
|
|
//{
|
|
// factory = PluginLoader.FindClass<AnnualReportFactory>() ?? new AnnualReportFactory();
|
|
//}
|
|
AnnualReportFactory factory = PluginLoader.FindClass<AnnualReportFactory>() ?? new AnnualReportFactory();
|
|
return factory.CreateAnnualReport2(config);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw Utils.CreateBeWoFaultException(e);
|
|
}
|
|
}
|
|
|
|
|
|
public List<AnnualReportDC> CreateAnnualReport(long? costbearerOid, long? teamOid, long? customerCareTypeValueListEntryOid, DateTime startDate, DateTime endDate)
|
|
{
|
|
var config = new AnnualReportConfigDC
|
|
{
|
|
CostbearerOid = costbearerOid,
|
|
TeamOid = teamOid,
|
|
CustomerCareTypeValueListEntryOid = customerCareTypeValueListEntryOid,
|
|
StartDate = startDate,
|
|
EndDate = endDate,
|
|
ShowOnlyApprovedSupportConcepts = true,
|
|
StichtagsbezogenAuswerten = true
|
|
};
|
|
return CreateAnnualReport2(config);
|
|
}
|
|
|
|
public static bool IsServiceRecordActive(ServiceRecord sr)
|
|
{
|
|
if (sr.Customer != null && sr.Customer.IsActive == ActivationTypeId.Deleted)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (sr.SupportConcept != null && sr.SupportConcept.IsActive == ActivationTypeId.Deleted)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static IList<ServiceRecord> FilterActiveServiceRecords(IList<ServiceRecord> records)
|
|
{
|
|
return records.Where(sr => IsServiceRecordActive(sr)).ToList();
|
|
}
|
|
|
|
public static IList<ServiceRecord> FilterGroupServiceRecords(IList<ServiceRecord> records)
|
|
{
|
|
Dictionary<long, bool> groupBookingDict = new Dictionary<long, bool>();
|
|
IList<ServiceRecord> groupFilteredRecords = new List<ServiceRecord>();
|
|
foreach (var item in records)
|
|
{
|
|
|
|
if (!item.GroupOid.HasValue || !groupBookingDict.ContainsKey(item.GroupOid.Value))
|
|
{
|
|
groupFilteredRecords.Add(item);
|
|
if (item.GroupOid.HasValue)
|
|
{
|
|
groupBookingDict.Add(item.GroupOid.Value, true);
|
|
}
|
|
}
|
|
}
|
|
return groupFilteredRecords;
|
|
}
|
|
|
|
public AccountingReportDC CreateAccountingReport(DateTime start, DateTime end)
|
|
{
|
|
var report = new AccountingReportDC
|
|
{
|
|
AccountingReportRows = new List<AccountingReportRowDC>(),
|
|
StartDate = start,
|
|
EndDate = end
|
|
};
|
|
|
|
var span = new DateTimeSpan {StartDate = start, EndDate = end.AddDays(1).AddTicks(-1)};
|
|
|
|
var serviceRecords = DAOFactory.SearchDAO.FindServiceRecordsInSpan(span, null);
|
|
|
|
var rowDict = new Dictionary<long, AccountingReportRowDC>();
|
|
|
|
foreach (var serviceRecord in serviceRecords)
|
|
{
|
|
|
|
if (serviceRecord.CostBearer2SupportConceptOid.HasValue)
|
|
{
|
|
AccountingReportRowDC row = null;
|
|
if (rowDict.ContainsKey(serviceRecord.CostBearer2SupportConceptOid.Value))
|
|
{
|
|
row = rowDict[serviceRecord.CostBearer2SupportConceptOid.Value];
|
|
}
|
|
else
|
|
{
|
|
row = new AccountingReportRowDC();
|
|
rowDict.Add(serviceRecord.CostBearer2SupportConceptOid.Value, row);
|
|
row.Customer = MapperFactory.CompactCustomerDC_Customer.MapToNewDC(serviceRecord.Customer);
|
|
|
|
row.SupportConceptStart = serviceRecord.SupportConcept.StartDate;
|
|
row.SupportConceptEnd = serviceRecord.SupportConcept.EndDate;
|
|
|
|
CostBearer2SupportConcept cb2sc = serviceRecord.CostBearer2SupportConcept;
|
|
var costBearer = new CompactCostBearerDC
|
|
{
|
|
IsCalculatingWithFactor = cb2sc.CostBearer.IsCalculatingWithFactor,
|
|
CostBearerID = cb2sc.CostBearer.ID,
|
|
CostBearerOid = cb2sc.CostBearer.Oid.Value,
|
|
CostBearer2SupportConceptOid = cb2sc.Oid.Value,
|
|
SupportConceptStatus = cb2sc.Status,
|
|
RequestedStartDate = cb2sc.RequestedStartDate,
|
|
RequestedEndDate = cb2sc.RequestedEndDate,
|
|
ApprovedStartDate = cb2sc.ApprovedStartDate,
|
|
ApprovedEndDate = cb2sc.ApprovedEndDate,
|
|
Organisation =
|
|
MapperFactory.CompactOrganisationDC_Organisation.MapToNewDC(
|
|
cb2sc.CostBearer.Organisation)
|
|
};
|
|
|
|
row.CostBearer = costBearer;
|
|
|
|
report.AccountingReportRows.Add(row);
|
|
}
|
|
|
|
row.TotalDuration += serviceRecord.RoundedDuration;
|
|
}
|
|
}
|
|
return report;
|
|
}
|
|
}
|
|
} |