2328 lines
76 KiB
C#
2328 lines
76 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.ComponentModel;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using System.Windows.Threading;
|
|
|
|
using BeWo.Core;
|
|
using BeWo.Core.Commands;
|
|
using BeWo.Core.Service;
|
|
using BeWo.ServiceProxy;
|
|
using BeWo.View.Controls.AI;
|
|
using BeWo.ViewModel.View.AI;
|
|
using BS.Shared;
|
|
using BS.Shared.Core;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.DataContracts.Feature.AI.Functions.ServiceRecords;
|
|
using BS.Shared.Extensions;
|
|
using BS.Shared.Services;
|
|
using DevExpress.Mvvm;
|
|
using DevExpress.Xpf.Editors.ExpressionEditor;
|
|
using Microsoft.VisualBasic;
|
|
using Newtonsoft.Json;
|
|
using DispatcherObject = System.Windows.Threading.DispatcherObject;
|
|
|
|
namespace BeWo.ViewModel.ListViewModel
|
|
{
|
|
public class ServiceRecordListVM : AbstractDCListMapperVM<ServiceRecordDC, ServiceRecordVM>
|
|
{
|
|
public static string PropertyName_CustomerNodes = "CustomerNodes";
|
|
public static string PropertyName_Information = "Information";
|
|
public static string PropertyName_PrototypeVM = "PrototypeVM";
|
|
public static string PropertyName_RecordCountInformationString = "RecordCountInformationString";
|
|
public static string PropertyName_RecordingDays = "RecordingDays";
|
|
public static string PropertyName_ServiceRecordsForSelectedCustomer = "ServiceRecordsForSelectedCustomer";
|
|
public static string PropertyName_IsCustomerWarningActive = "IsCustomerWarningActive";
|
|
public static string PropertyName_CustomerWarning = "CustomerWarning";
|
|
public static string PropertyName_Statistics = "Statistics";
|
|
public static string PropertyName_ServiceRecordTimeInterval = "ServiceRecordTimeInterval";
|
|
public static string PropertyName_Wohnheimbuchungen = "Wohnheimbuchungen";
|
|
public static string PropertyName_SelectedWohnheimbuchung = "SelectedWohnheimbuchung";
|
|
public static string PropertyName_BedarfsMedViewModel = "BedarfsMedViewModel";
|
|
public static string PropertyName_MedRecordCreationEnabled = "MedRecordCreationEnabled";
|
|
|
|
|
|
public event EventHandler StatisticInfosLoaded;
|
|
|
|
private readonly List<ValueListEntryDC> _AllGoalCategories;
|
|
|
|
private readonly Dictionary<ServiceCategoryDC, List<ServiceDescriptionDC>> _Category2Services;
|
|
|
|
private readonly Dictionary<long, SupportConceptTreeNodeDetailInfoDC> _CostBearer2SupportConceptOid2BookingInfoDict = new Dictionary<long, SupportConceptTreeNodeDetailInfoDC>();
|
|
|
|
//private readonly Dictionary<String, long> _ServiceRecordsLoaded = new Dictionary<String, long>();
|
|
|
|
//private readonly Dictionary<CompactEmployeeDC, bool> _EmployeeServiceRecordsLoaded = new Dictionary<CompactEmployeeDC, bool>();
|
|
|
|
private readonly BindingList<ServiceRecordVM> _ServiceRecordsForSelectedCustomer;
|
|
|
|
private List<ValueListEntryDC> _AllGoals;
|
|
|
|
private ObservableSortCollection<FlatSupportConceptTreeNodeDC> _CustomerNodes;
|
|
|
|
private ServiceRecordVM _PrototypeVM;
|
|
|
|
private string _RecordCountInformationString;
|
|
|
|
private ObservableCollection<DayOfWeek> _RecordingDays;
|
|
|
|
private FlatSupportConceptTreeNodeDC _SelectedCustomerNode;
|
|
|
|
private CompactEmployeeDC mSelectedEmployee;
|
|
|
|
private bool _IsCustomerWarningActive;
|
|
|
|
private string _CustomerWarning;
|
|
|
|
private ServiceRecordTimeInterval _ServiceRecordTimeInterval = ServiceRecordTimeInterval.LastWeek;
|
|
|
|
private bool _ShowOnlyContentServiceRecords;
|
|
|
|
private List<SupportConceptPeriodStatisticsVM> _Statistics;
|
|
|
|
//meins
|
|
private DateTime? _XTageVon;
|
|
|
|
private DateTime? _XTageBis;
|
|
|
|
private int _XTage;
|
|
|
|
private int _SelectedMonthIndex;
|
|
|
|
private int _SelectedYear;
|
|
//private WohnheimbuchungsVM selectedWohnheimbuchung;
|
|
|
|
//private static List<DarreichungsformDC> _AllDosageForms;
|
|
|
|
private List<string> _AiActionHistory;
|
|
private int _AiActionHistoryIndex;
|
|
private AiConversationButtonState _AiConversationButtonState;
|
|
|
|
public ICommand UndoAiActionCommand { get; set; }
|
|
public ICommand RedoAiActionCommand { get; set; }
|
|
|
|
private List<string> _EditAiActionHistory;
|
|
private int _EditAiActionHistoryIndex;
|
|
|
|
public ICommand UndoEditAiActionCommand { get; set; }
|
|
public ICommand RedoEditAiActionCommand { get; set; }
|
|
|
|
public ServiceRecordListVM(
|
|
Dictionary<ServiceCategoryDC, List<ServiceDescriptionDC>> pCategory2Services,
|
|
IEnumerable<ValueListEntryDC> pAllGoalCategories,
|
|
IEnumerable<ValueListEntryDC> pAllIndGoalCategories,
|
|
List<ValueListEntryDC> pAllGoals,
|
|
List<CompactWohnheimDC> pAlleWohnheime,
|
|
List<ValueListEntryDC> allDocTypes,
|
|
List<DarreichungsformDC> pAllDosageForms)
|
|
{
|
|
_ServiceRecordTimeInterval = BeWoApp.AppSettings.LastSelectedServiceRecordTimeInterval;
|
|
_XTage = BeWoApp.AppSettings.LastSelectedServiceRecordTimeIntervalDays;
|
|
|
|
if (pCategory2Services != null)
|
|
{
|
|
Dictionary<ServiceCategoryDC, List<ServiceDescriptionDC>> globalCats =
|
|
pCategory2Services.Keys.Where(cat => cat.ScopeType == ScopeTypeId.Global)
|
|
.ToDictionary(cat => cat, cat => pCategory2Services[cat]);
|
|
_Category2Services = globalCats;
|
|
}
|
|
|
|
_ServiceRecordsForSelectedCustomer = new BindingList<ServiceRecordVM>();
|
|
|
|
|
|
_SelectedMonthIndex = BeWoApp.AppSettings.LastSelectedServiceRecordMonth.Month - 1;
|
|
_SelectedYear = BeWoApp.AppSettings.LastSelectedServiceRecordMonth.Year;
|
|
//if (DateTime.Now.Day < 15)
|
|
//{
|
|
|
|
|
|
|
|
|
|
//CB EINKOMMENTIEREN
|
|
//var wdc = new WohnheimbuchungDC();
|
|
//wdc.Buchungsdatum = DateTime.Now;
|
|
|
|
//var gefilterteWohnheime =
|
|
// pAlleWohnheime.Where(wh => wh.EmployeeOids.Contains(BeWoApp.LoggedOnEmployee.EmployeeOid.Value)).ToList();
|
|
//if (gefilterteWohnheime.Count == 1)
|
|
//{
|
|
// wdc.Wohnheim = gefilterteWohnheime[0];
|
|
//}
|
|
//selectedWohnheimbuchung = new WohnheimbuchungsVM(wdc, pCategory2Services);
|
|
|
|
//AlleWohnheime = gefilterteWohnheime;
|
|
|
|
//AllDosageForms = pAllDosageForms;
|
|
|
|
_AllGoalCategories = new List<ValueListEntryDC>();
|
|
|
|
if (pAllGoalCategories != null)
|
|
{
|
|
_AllGoalCategories.AddRange(pAllGoalCategories);
|
|
}
|
|
if (pAllIndGoalCategories != null)
|
|
{
|
|
_AllGoalCategories.AddRange(pAllIndGoalCategories);
|
|
}
|
|
_AllGoals = pAllGoals;
|
|
AllDocTypes = allDocTypes;
|
|
AllGoalCategories = _AllGoalCategories;
|
|
if (AllDocTypes != null)
|
|
{
|
|
AllDocTypes.Sort((a, b) => a.ValueListEntryOid.Value.CompareTo(b.ValueListEntryOid.Value));
|
|
}
|
|
VMList.ListChanged += (s, e) => CheckCustomerAbsenceTimes();
|
|
|
|
InitAiStuff();
|
|
}
|
|
|
|
private void InitAiStuff()
|
|
{
|
|
//var vm_doku = new AiPromptbausteinSelectionComplexViewModel(AiActionType.ServiceRecordDocumentation);
|
|
|
|
//vm_doku.PromptAccepted += PromptAccepted;
|
|
|
|
//OpenAiPromptSelectionCommand = CommandFactory.GetAiViewCommand(
|
|
// () => BeWoApp.MainControl.WindowService.Show(vm_doku),
|
|
// null,
|
|
// () => !string.IsNullOrWhiteSpace(AktuellerDokutext));
|
|
|
|
UndoAiActionCommand = new DelegateCommand(UndoAiAction);
|
|
RedoAiActionCommand = new DelegateCommand(RedoAiAction);
|
|
|
|
//var vm_edit_doku = new AiPromptbausteinSelectionComplexViewModel(AiActionType.ServiceRecordDocumentation);
|
|
|
|
//vm_edit_doku.PromptAccepted += EditPromptAccepted;
|
|
|
|
//OpenEditAiPromptSelectionCommand = CommandFactory.GetAiViewCommand(() =>
|
|
//{
|
|
// _EditAiActionHistory = new List<string>();
|
|
// _EditAiActionHistory.Add(AktuellerEditDokutext);
|
|
// _EditAiActionHistoryIndex = 0;
|
|
// BeWoApp.MainControl.WindowService.Show(vm_edit_doku);
|
|
//},
|
|
//null,
|
|
//() => !string.IsNullOrWhiteSpace(AktuellerEditDokutext));
|
|
|
|
UndoEditAiActionCommand = new DelegateCommand(UndoEditAiAction);
|
|
RedoEditAiActionCommand = new DelegateCommand(RedoEditAiAction);
|
|
|
|
_AiActionHistory = new List<string>();
|
|
_AiActionHistory.Add(AktuellerDokutext);
|
|
_AiActionHistoryIndex = 0;
|
|
}
|
|
|
|
public AiConversationButtonState AiConversationButtonState
|
|
{
|
|
get => _AiConversationButtonState;
|
|
set => SetProperty(ref _AiConversationButtonState, value, nameof(AiConversationButtonState));
|
|
}
|
|
|
|
public IEnumerable<ServiceRecordVM> CurrentVisibleVMs { get; set; }
|
|
public string AktuellerDokutext
|
|
{
|
|
get => PrototypeVM.Notice;
|
|
set
|
|
{
|
|
PrototypeVM.Notice = value;
|
|
FirePropertyChanged(nameof(IsAiDocuButtonCanExecute));
|
|
FirePropertyChanged(nameof(IsRedoButtonVisible));
|
|
FirePropertyChanged(nameof(IsUndoButtonVisible));
|
|
}
|
|
}
|
|
public string AktuellerEditDokutext
|
|
{
|
|
get => EditVM?.Notice;
|
|
set
|
|
{
|
|
EditVM.Notice = value;
|
|
FirePropertyChanged(nameof(IsEditUndoButtonVisible));
|
|
FirePropertyChanged(nameof(IsEditRedoButtonVisible));
|
|
}
|
|
}
|
|
|
|
public bool IsAiModuleEnabled => (BeWoApp.AppSettings.ShowAI || BeWoApp.AppSettings.ShowAIVoice);
|
|
public bool IsAiChatButtonVisible => SelectedCustomerNode is object && IsAiModuleEnabled && BeWoApp.HasLoggedOnUserRight(UserRightType.AiModuleServiceRecordChat);
|
|
public bool IsAiDocuButtonVisible => SelectedCustomerNode is object && IsAiModuleEnabled && BeWoApp.HasLoggedOnUserRight(UserRightType.AiModuleServiceRecordDocu);
|
|
public bool IsAiDocuButtonCanExecute => !string.IsNullOrWhiteSpace(AktuellerDokutext);
|
|
public bool IsUndoButtonVisible => _AiActionHistoryIndex > 0;
|
|
public bool IsRedoButtonVisible => _AiActionHistoryIndex < _AiActionHistory.Count - 1;
|
|
|
|
public bool IsEditUndoButtonVisible => _EditAiActionHistoryIndex > 0;
|
|
public bool IsEditRedoButtonVisible => _EditAiActionHistoryIndex < (_EditAiActionHistory?.Count ?? 0) - 1;
|
|
|
|
public void PromptAccepted(object sender, AiPromptbausteinPromptVM prompt)
|
|
{
|
|
if (prompt is null)
|
|
throw new NotImplementedException();
|
|
|
|
// 1. Information aufbereiten
|
|
// 1.1 Prompt
|
|
var prompt_oid = prompt.DataContract.Oid.Value;
|
|
var prompt_version = prompt.DataContract.Version;
|
|
|
|
// 1.2 Hilfeplan
|
|
var support_concept = SelectedCustomerNode.SupportConceptTreeNodeDC.SupportConcept;
|
|
var support_concept_oid = support_concept.SupportConceptOid;
|
|
var support_concept_version = support_concept.SupportConceptVersion;
|
|
|
|
// 1.3 Aktuelles Doku Feld
|
|
var doku_feld = AktuellerDokutext;
|
|
|
|
// 1.4 Sichtbaren Zeiterfassungseinträge
|
|
var service_records = CurrentVisibleVMs;
|
|
var sr_refs = service_records.Select(x => new BeWoRefDC(x.DataContract.ServiceRecordOid.Value, x.DataContract.ServiceRecordVersion));
|
|
|
|
// 1.5 Costbearer
|
|
var costbearer = SelectedCustomerNode.SupportConceptTreeNodeDC.CostBearer;
|
|
var cb_oid = costbearer.CostBearerOid.Value;
|
|
var cb_ver = costbearer.CostBearerVersion;
|
|
|
|
// Service Aufruf
|
|
var req = new AiFunctionDocRequest()
|
|
{
|
|
AiPromptbausteinPrompt = new BeWoRefDC(prompt_oid, prompt_version),
|
|
SupportConcept = new BeWoRefDC(support_concept_oid, support_concept_version),
|
|
ServiceRecords = sr_refs,
|
|
CostBearer = new BeWoRefDC(cb_oid, cb_ver),
|
|
Dokumentation = doku_feld,
|
|
};
|
|
|
|
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.ExecuteAiFunctionServiceRecordDocumentation(req),
|
|
callback =>
|
|
{
|
|
var viewModel = new AiPromptbausteinActionResultViewModel();
|
|
|
|
viewModel.Result = callback.Result;
|
|
|
|
viewModel.Accept_Button_Clicked += (s, e) =>
|
|
{
|
|
var sb = new StringBuilder();
|
|
|
|
sb.AppendLine("AI Antwort:");
|
|
sb.AppendLine(viewModel.Result);
|
|
|
|
sb.AppendLine();
|
|
sb.AppendLine("Original:");
|
|
sb.AppendLine(AktuellerDokutext);
|
|
|
|
var str = sb.ToString();
|
|
var idx = _AiActionHistoryIndex;
|
|
var count = _AiActionHistory.Count;
|
|
|
|
if (count - 1 > idx)
|
|
{
|
|
_AiActionHistory.RemoveRange(idx + 1, count - idx - 1);
|
|
}
|
|
|
|
if (AktuellerDokutext != _AiActionHistory[_AiActionHistoryIndex])
|
|
{
|
|
_AiActionHistory.Add(AktuellerDokutext);
|
|
_AiActionHistoryIndex++;
|
|
}
|
|
|
|
_AiActionHistory.Add(str);
|
|
_AiActionHistoryIndex++;
|
|
|
|
AktuellerDokutext = str;
|
|
};
|
|
viewModel.Replace_Button_Clicked += (s, e) =>
|
|
{
|
|
var str = viewModel.Result;
|
|
var idx = _AiActionHistoryIndex;
|
|
var count = _AiActionHistory.Count;
|
|
|
|
if (count - 1 > idx)
|
|
{
|
|
_AiActionHistory.RemoveRange(idx + 1, count - idx - 1);
|
|
}
|
|
|
|
if (AktuellerDokutext != _AiActionHistory[_AiActionHistoryIndex])
|
|
{
|
|
_AiActionHistory.Add(AktuellerDokutext);
|
|
_AiActionHistoryIndex++;
|
|
}
|
|
|
|
_AiActionHistory.Add(str);
|
|
_AiActionHistoryIndex++;
|
|
|
|
AktuellerDokutext = str;
|
|
};
|
|
viewModel.Retry_Button_Clicked += (s, e) =>
|
|
{
|
|
PromptAccepted(sender, prompt);
|
|
};
|
|
|
|
BeWoApp.MainControl.WindowService.Show(viewModel);
|
|
}
|
|
);
|
|
}
|
|
|
|
public void EditPromptAccepted(object sender, AiPromptbausteinPromptVM prompt)
|
|
{
|
|
if (prompt is null)
|
|
throw new NotImplementedException();
|
|
|
|
// 1. Information aufbereiten
|
|
// 1.1 Prompt
|
|
var prompt_oid = prompt.DataContract.Oid.Value;
|
|
var prompt_version = prompt.DataContract.Version;
|
|
|
|
// 1.2 Hilfeplan
|
|
var support_concept = SelectedCustomerNode.SupportConceptTreeNodeDC.SupportConcept;
|
|
var support_concept_oid = support_concept.SupportConceptOid;
|
|
var support_concept_version = support_concept.SupportConceptVersion;
|
|
|
|
// 1.3 Aktuelles Doku Feld
|
|
var doku_feld = AktuellerEditDokutext;
|
|
|
|
// 1.4 Sichtbaren Zeiterfassungseinträge
|
|
var service_records = CurrentVisibleVMs;
|
|
var sr_refs = service_records.Select(x => new BeWoRefDC(x.DataContract.ServiceRecordOid.Value, x.DataContract.ServiceRecordVersion));
|
|
|
|
// 1.5 Costbearer
|
|
var costbearer = SelectedCustomerNode.SupportConceptTreeNodeDC.CostBearer;
|
|
var cb_oid = costbearer.CostBearerOid.Value;
|
|
var cb_ver = costbearer.CostBearerVersion;
|
|
|
|
// Service Aufruf
|
|
var req = new AiFunctionDocRequest()
|
|
{
|
|
AiPromptbausteinPrompt = new BeWoRefDC(prompt_oid, prompt_version),
|
|
SupportConcept = new BeWoRefDC(support_concept_oid, support_concept_version),
|
|
ServiceRecords = sr_refs,
|
|
CostBearer = new BeWoRefDC(cb_oid, cb_ver),
|
|
Dokumentation = doku_feld,
|
|
};
|
|
|
|
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.ExecuteAiFunctionServiceRecordDocumentation(req),
|
|
callback =>
|
|
{
|
|
var viewModel = new AiPromptbausteinActionResultViewModel();
|
|
|
|
viewModel.Result = callback.Result;
|
|
|
|
viewModel.Accept_Button_Clicked += (s, e) =>
|
|
{
|
|
var sb = new StringBuilder();
|
|
|
|
sb.AppendLine("AI Antwort:");
|
|
sb.AppendLine(viewModel.Result);
|
|
|
|
sb.AppendLine();
|
|
sb.AppendLine("Original:");
|
|
sb.AppendLine(AktuellerEditDokutext);
|
|
|
|
var str = sb.ToString();
|
|
var idx = _EditAiActionHistoryIndex;
|
|
var count = _EditAiActionHistory.Count;
|
|
|
|
if (count - 1 > idx)
|
|
{
|
|
_EditAiActionHistory.RemoveRange(idx + 1, count - idx - 1);
|
|
}
|
|
|
|
if (AktuellerEditDokutext != _EditAiActionHistory[_EditAiActionHistoryIndex])
|
|
{
|
|
_EditAiActionHistory.Add(AktuellerEditDokutext);
|
|
_EditAiActionHistoryIndex++;
|
|
}
|
|
|
|
_EditAiActionHistory.Add(str);
|
|
_EditAiActionHistoryIndex++;
|
|
|
|
AktuellerEditDokutext = str;
|
|
};
|
|
viewModel.Replace_Button_Clicked += (s, e) =>
|
|
{
|
|
var str = viewModel.Result;
|
|
var idx = _EditAiActionHistoryIndex;
|
|
var count = _EditAiActionHistory.Count;
|
|
|
|
if (count - 1 > idx)
|
|
{
|
|
_EditAiActionHistory.RemoveRange(idx + 1, count - idx - 1);
|
|
}
|
|
|
|
if (AktuellerEditDokutext != _EditAiActionHistory[_EditAiActionHistoryIndex])
|
|
{
|
|
_EditAiActionHistory.Add(AktuellerEditDokutext);
|
|
_EditAiActionHistoryIndex++;
|
|
}
|
|
|
|
_EditAiActionHistory.Add(str);
|
|
_EditAiActionHistoryIndex++;
|
|
|
|
AktuellerEditDokutext = str;
|
|
};
|
|
viewModel.Retry_Button_Clicked += (s, e) =>
|
|
{
|
|
PromptAccepted(sender, prompt);
|
|
};
|
|
|
|
BeWoApp.MainControl.WindowService.Show(viewModel);
|
|
}
|
|
);
|
|
}
|
|
|
|
public void UpdateViewYearFilter(IEnumerable<ServiceRecordVM> enumerable)
|
|
{
|
|
if (!IsAiChatButtonVisible)
|
|
{
|
|
AiConversationButtonState = AiConversationButtonState.Hidden;
|
|
return;
|
|
}
|
|
|
|
AiConversationButtonState = AiConversationButtonState.Loading;
|
|
var context = GetVisibleInformationReferences(enumerable);
|
|
if (context != null)
|
|
{
|
|
var context2 = context.ToDictionary(kv => kv.Key, kv => kv.Value.ToList());
|
|
|
|
ServiceFacade.DoAiEnhancedServiceAsnyc(x => x.CheckContextSize(AiContextType.ServiceRecord, context2, null),
|
|
isValid =>
|
|
{
|
|
if (isValid)
|
|
AiConversationButtonState = AiConversationButtonState.Normal;
|
|
else
|
|
AiConversationButtonState = AiConversationButtonState.Warning;
|
|
},
|
|
(exp) => AiConversationButtonState = AiConversationButtonState.Disabled);
|
|
}
|
|
}
|
|
|
|
public void ResetAiAction()
|
|
{
|
|
_AiActionHistory.Clear();
|
|
_AiActionHistory.Add(AktuellerDokutext);
|
|
_AiActionHistoryIndex = 0;
|
|
|
|
FirePropertyChanged(nameof(IsRedoButtonVisible));
|
|
FirePropertyChanged(nameof(IsUndoButtonVisible));
|
|
}
|
|
|
|
public Dictionary<TableID, long[]> GetVisibleInformationReferences(IEnumerable<ServiceRecordVM> selected_records)
|
|
{
|
|
var current = SelectedCustomerNode;
|
|
var hello = current?.SupportConceptTreeNodeDC;
|
|
var sr = ServiceRecordsForSelectedCustomer;
|
|
|
|
if (current is null || hello is null)
|
|
return null;
|
|
|
|
var oids = new List<long>();
|
|
foreach (var record in selected_records)
|
|
{
|
|
oids.Add(record.DataContract.ServiceRecordOid ?? -1);
|
|
}
|
|
|
|
var rtn = new Dictionary<TableID, long[]>()
|
|
{
|
|
{TableID.Customer, new long[]{ hello.Customer.CustomerOid } },
|
|
{TableID.SupportConcept, new long[]{ hello.SupportConcept.SupportConceptOid } },
|
|
{TableID.CostBearer, new long[]{ hello.CostBearer.CostBearerOid ?? -1 } },
|
|
{TableID.ServiceRecord, oids.ToArray() }
|
|
};
|
|
|
|
return rtn;
|
|
}
|
|
|
|
//CB EINKOMMENTIEREN
|
|
//public bool MedRecordCreationEnabled
|
|
//{
|
|
// get { return (BeWoApp.LoggedOnUser.HasRight(UserRightType.MedRecordsAnlegen) || BeWoApp.LoggedOnUser.HasRight(UserRightType.CreateAll)) && BedarfsMedViewModel != null; }
|
|
//}
|
|
|
|
public List<ValueListEntryDC> AllDocTypes { get; set; }
|
|
|
|
public List<ValueListEntryDC> AllGoalCategories { get; set; }
|
|
|
|
//CB EINKOMMENTIEREN
|
|
//public void LoadExistingWohnheimbuchung(CompactWohnheimDC pWohnheim, DateTime pBuchungsdatum, Action<bool> callback)
|
|
//{
|
|
// ServiceFacade.DoCustomerServiceAsync(s => s.GetWohnheimbuchungByWohnheimAndBuchungsdatum(pWohnheim.WohnheimOid, pBuchungsdatum), r =>
|
|
// {
|
|
// SelectedWohnheimbuchung = new WohnheimbuchungsVM(r ?? new WohnheimbuchungDC { Buchungsdatum = pBuchungsdatum, Wohnheim = pWohnheim }, PrototypeVM.Category2Services) { Category = selectedWohnheimbuchung.Category, ServiceDescription = selectedWohnheimbuchung.ServiceDescription };
|
|
|
|
// if (r == null)
|
|
// {
|
|
// SelectedWohnheimbuchung.Wohnheimbuchung2Costbearer2SupportConceptList = new Wohnheimbuchung2Costbearer2SupportConceptRelListVM(SelectedWohnheimbuchung.DataContract.Costbearer2SupportConceptList);
|
|
// SelectedWohnheimbuchung.EmployeeList = new WohnheimbuchungEmployeeRelListVM(SelectedWohnheimbuchung.DataContract.EmployeeList);
|
|
// SelectedWohnheimbuchung.Buchungsdatum = pBuchungsdatum;
|
|
// SelectedWohnheimbuchung.Wohnheim = pWohnheim;
|
|
// selectedWohnheimbuchung.Category = selectedWohnheimbuchung.Category;
|
|
// selectedWohnheimbuchung.ServiceDescription = selectedWohnheimbuchung.ServiceDescription;
|
|
// }
|
|
// else
|
|
// {
|
|
// var serviceDescription = ServiceFacade.DoCustomerServiceSync(s => s.FindServiceDescriptionForWohnheimbuchungsServiceRecord(r.WohnheimbuchungOid.Value)) ?? selectedWohnheimbuchung.ServiceDescription;
|
|
|
|
// selectedWohnheimbuchung.ServiceDescription = serviceDescription;
|
|
// selectedWohnheimbuchung.Category = serviceDescription.Category;
|
|
// }
|
|
|
|
// callback(r != null);
|
|
// });
|
|
//}
|
|
|
|
private MedRecordListVM _BedarfsMedViewModel;
|
|
|
|
public MedRecordListVM BedarfsMedViewModel
|
|
{
|
|
get { return _BedarfsMedViewModel; }
|
|
|
|
set
|
|
{
|
|
_BedarfsMedViewModel = value;
|
|
FirePropertyChanged(PropertyName_BedarfsMedViewModel);
|
|
FirePropertyChanged(PropertyName_MedRecordCreationEnabled);
|
|
}
|
|
}
|
|
|
|
public static List<DarreichungsformDC> AllDosageForms { get; private set; }
|
|
|
|
internal void FetchStatistics(long costBearer2SupportConceptOid)
|
|
{
|
|
DateTime stichtag = DateTime.Now;
|
|
|
|
var recordStats = ServiceFacade.DoOperationsServiceSync(s => s.GetServiceRecordStatisticInfo(costBearer2SupportConceptOid, stichtag));
|
|
var scStats = ServiceFacade.DoOperationsServiceSync(s => s.CreateSupportConceptStatistics(costBearer2SupportConceptOid, stichtag));
|
|
|
|
RecordStatisticsDC = recordStats;
|
|
StatisticsDC = scStats;
|
|
Statistics = CreateStatisticVMList(scStats);
|
|
}
|
|
|
|
//CB EINKOMMENTIEREN
|
|
//public WohnheimbuchungsVM SelectedWohnheimbuchung
|
|
//{
|
|
// get { return selectedWohnheimbuchung; }
|
|
// set
|
|
// {
|
|
// selectedWohnheimbuchung = value;
|
|
// FirePropertyChanged(PropertyName_SelectedWohnheimbuchung);
|
|
// }
|
|
//}
|
|
|
|
public List<CompactWohnheimDC> AlleWohnheime { get; private set; }
|
|
|
|
public int XTage
|
|
{
|
|
get { return _XTage; }
|
|
|
|
set
|
|
{
|
|
if (AreDifferent(_XTage, value))
|
|
{
|
|
_XTage = value;
|
|
ServiceRecordTimeInterval = ServiceRecordTimeInterval.XTage;
|
|
BeWoApp.AppSettings.LastSelectedServiceRecordTimeIntervalDays = value;
|
|
BeWoApp.SaveAppSettings();
|
|
|
|
BuildServiceRecordsForSelectedTreeNode(true, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public DateTime? XTageBis
|
|
{
|
|
get { return _XTageBis ?? (_XTageBis = DateTime.Now); }
|
|
|
|
set
|
|
{
|
|
if (AreDifferent(_XTageBis, value))
|
|
{
|
|
_XTageBis = value;
|
|
ServiceRecordTimeInterval = ServiceRecordTimeInterval.ZeitraumWaehlen;
|
|
|
|
if (XTageVon == null)
|
|
{
|
|
XTageVon = DateTime.Now;
|
|
}
|
|
|
|
BuildServiceRecordsForSelectedTreeNode(true, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public DateTime? XTageVon
|
|
{
|
|
get { return _XTageVon ?? (_XTageVon = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1, 0, 0, 0)); }
|
|
|
|
set
|
|
{
|
|
if (AreDifferent(_XTageVon, value))
|
|
{
|
|
_XTageVon = value;
|
|
ServiceRecordTimeInterval = ServiceRecordTimeInterval.ZeitraumWaehlen;
|
|
|
|
BuildServiceRecordsForSelectedTreeNode(true, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public int SelectedMonthIndex
|
|
{
|
|
get { return _SelectedMonthIndex; }
|
|
|
|
set
|
|
{
|
|
if (AreDifferent(_SelectedMonthIndex, value))
|
|
{
|
|
_SelectedMonthIndex = value;
|
|
ServiceRecordTimeInterval = ServiceRecordTimeInterval.Monatsauswahl;
|
|
BeWoApp.AppSettings.LastSelectedServiceRecordMonth = new DateTime(_SelectedYear, _SelectedMonthIndex + 1, 1);
|
|
BeWoApp.SaveAppSettings();
|
|
BuildServiceRecordsForSelectedTreeNode(true, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public int SelectedYear
|
|
{
|
|
get { return _SelectedYear; }
|
|
|
|
set
|
|
{
|
|
if (AreDifferent(_SelectedYear, value))
|
|
{
|
|
_SelectedYear = value;
|
|
ServiceRecordTimeInterval = ServiceRecordTimeInterval.Monatsauswahl;
|
|
BeWoApp.AppSettings.LastSelectedServiceRecordMonth = new DateTime(_SelectedYear, _SelectedMonthIndex + 1, 1);
|
|
BeWoApp.SaveAppSettings();
|
|
BuildServiceRecordsForSelectedTreeNode(true, false);
|
|
}
|
|
}
|
|
}
|
|
public List<SupportConceptPeriodStatisticsVM> Statistics
|
|
{
|
|
get { return _Statistics; }
|
|
set
|
|
{
|
|
_Statistics = value;
|
|
FirePropertyChanged(PropertyName_Statistics);
|
|
FirePropertyChanged("HasStatistics");
|
|
FirePropertyChanged("StatisticsButtonVisible");
|
|
FirePropertyChanged("OpenAiChatButtonVisible");
|
|
}
|
|
}
|
|
|
|
public bool HasStatistics
|
|
{
|
|
get { return _Statistics != null && _Statistics.Count > 0; }
|
|
}
|
|
|
|
public bool StatisticsButtonVisible
|
|
{
|
|
get { return BeWoApp.AppSettings.ShowHilfeplanStatistikReport && SelectedCustomerNode != null && SelectedCustomerNode.SupportConceptTreeNodeDC != null; }
|
|
}
|
|
|
|
public ServiceRecordTimeInterval ServiceRecordTimeInterval
|
|
{
|
|
get { return _ServiceRecordTimeInterval; }
|
|
set
|
|
{
|
|
if (_ServiceRecordTimeInterval != value)
|
|
{
|
|
_ServiceRecordTimeInterval = value;
|
|
BuildServiceRecordsForSelectedTreeNode(true, false);
|
|
if (value != ServiceRecordTimeInterval.ZeitraumWaehlen)
|
|
{
|
|
BeWoApp.AppSettings.LastSelectedServiceRecordTimeInterval = value;
|
|
BeWoApp.SaveAppSettings();
|
|
}
|
|
FirePropertyChanged(PropertyName_ServiceRecordTimeInterval);
|
|
}
|
|
}
|
|
}
|
|
|
|
public ServiceRecordTypeId? OnlyWithThisType { get; set; }
|
|
private bool _ShowOnlyAdditionalServiceRecords;
|
|
|
|
public bool ShowOnlyAdditionalServiceRecords
|
|
{
|
|
get { return _ShowOnlyAdditionalServiceRecords; }
|
|
set
|
|
{
|
|
if (_ShowOnlyAdditionalServiceRecords == value)
|
|
return;
|
|
|
|
_ShowOnlyAdditionalServiceRecords = value;
|
|
if (_ShowOnlyAdditionalServiceRecords)
|
|
{
|
|
FilterServiceRecordsByType(ServiceRecordTypeId.AdditionalService);
|
|
OnlyWithThisType = ServiceRecordTypeId.AdditionalService;
|
|
}
|
|
else
|
|
{
|
|
FilterServiceRecordsByType(null);
|
|
OnlyWithThisType = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool ShowOnlyContentServiceRecords
|
|
{
|
|
get { return _ShowOnlyContentServiceRecords; }
|
|
set
|
|
{
|
|
if (_ShowOnlyContentServiceRecords != value)
|
|
{
|
|
_ShowOnlyContentServiceRecords = value;
|
|
if (_ShowOnlyContentServiceRecords)
|
|
FilterServiceRecordsByType(ServiceRecordTypeId.Content);
|
|
else
|
|
FilterServiceRecordsByType(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void FilterServiceRecordsByType(ServiceRecordTypeId? serviceRecordTypeId)
|
|
{
|
|
// Wird nur beim Klick auf Ergänzende Dienste ausgeführt.
|
|
BuildServiceRecordsForTreeNode(_SelectedCustomerNode, false, serviceRecordTypeId);
|
|
}
|
|
|
|
public FlatSupportConceptTreeNodeDC SelectedCustomerNode
|
|
{
|
|
get { return _SelectedCustomerNode; }
|
|
}
|
|
|
|
public event EventHandler ServiceRecordListChanged;
|
|
|
|
public ObservableSortCollection<FlatSupportConceptTreeNodeDC> CustomerNodes
|
|
{
|
|
get
|
|
{
|
|
if (_CustomerNodes == null)
|
|
{
|
|
_CustomerNodes = new ObservableSortCollection<FlatSupportConceptTreeNodeDC>();
|
|
_CustomerNodes.CollectionChanged += (s, e) =>
|
|
{
|
|
if (e.OldItems != null && e.OldItems.Count > 0)
|
|
{
|
|
foreach (FlatSupportConceptTreeNodeDC iNode in e.OldItems)
|
|
{
|
|
iNode.IsCustomerWarningActive = false;
|
|
iNode.CustomerWarning = null;
|
|
}
|
|
}
|
|
|
|
FirePropertyChanged(PropertyName_Information);
|
|
|
|
//this.CheckCustomerAbsenceTimes();
|
|
CheckEmployeeLabourTime();
|
|
};
|
|
}
|
|
|
|
return _CustomerNodes;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (AreDifferent(_CustomerNodes, value))
|
|
{
|
|
_CustomerNodes = value;
|
|
FirePropertyChanged(PropertyName_CustomerNodes);
|
|
}
|
|
}
|
|
}
|
|
|
|
public DispatcherObject DispatcherObject { get; set; }
|
|
|
|
|
|
public bool IsCustomerWarningActive
|
|
{
|
|
get { return _IsCustomerWarningActive; }
|
|
|
|
set
|
|
{
|
|
_IsCustomerWarningActive = value;
|
|
FirePropertyChanged(PropertyName_IsCustomerWarningActive);
|
|
}
|
|
}
|
|
|
|
public string CustomerWarning
|
|
{
|
|
get { return _CustomerWarning; }
|
|
set
|
|
{
|
|
_CustomerWarning = value;
|
|
FirePropertyChanged(PropertyName_CustomerWarning);
|
|
}
|
|
}
|
|
|
|
public string Information
|
|
{
|
|
get { return string.Empty; }
|
|
}
|
|
|
|
public ServiceRecordVM PrototypeVM
|
|
{
|
|
get
|
|
{
|
|
if (_PrototypeVM == null)
|
|
{
|
|
_PrototypeVM = NewVM;
|
|
_PrototypeVM.DauerEinheit = BeWoApp.AppSettings.LetzteZeiterfassungsDauer;
|
|
_PrototypeVM.PropertyChanged += (s, e) =>
|
|
{
|
|
if (e.PropertyName.Equals(ServiceRecordVM.PropertyName_Duration))
|
|
{
|
|
FirePropertyChanged(PropertyName_Information);
|
|
}
|
|
|
|
CheckCustomerAbsenceTimes();
|
|
CheckEmployeeLabourTime();
|
|
};
|
|
}
|
|
|
|
return _PrototypeVM;
|
|
}
|
|
}
|
|
|
|
public string RecordCountInformationString
|
|
{
|
|
get { return _RecordCountInformationString; }
|
|
}
|
|
|
|
public ObservableCollection<DayOfWeek> RecordingDays
|
|
{
|
|
get
|
|
{
|
|
if (_RecordingDays == null)
|
|
{
|
|
_RecordingDays = new ObservableCollection<DayOfWeek>();
|
|
//this._RecordingDays.CollectionChanged += (s, e) =>
|
|
// {
|
|
// this.CheckCustomerAbsenceTimes();
|
|
// this.CheckEmployeeLabourTime();
|
|
// };
|
|
}
|
|
|
|
return _RecordingDays;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (AreDifferent(_RecordingDays, value))
|
|
{
|
|
_RecordingDays = value;
|
|
FirePropertyChanged(PropertyName_RecordingDays);
|
|
}
|
|
}
|
|
}
|
|
|
|
public CompactEmployeeDC SelectedEmployee
|
|
{
|
|
get { return mSelectedEmployee; }
|
|
|
|
set { mSelectedEmployee = value; }
|
|
}
|
|
|
|
//public ServiceRecordVM SelectedVMForEditing { get; set; }
|
|
|
|
public BindingList<ServiceRecordVM> ServiceRecordsForSelectedCustomer
|
|
{
|
|
get { return _ServiceRecordsForSelectedCustomer; }
|
|
}
|
|
|
|
//public List<SupportConceptTreeNodeDC> Tree { get; private set; }
|
|
|
|
public bool WithoutClient { get; set; }
|
|
|
|
protected override Comparison<ServiceRecordVM> Comparison
|
|
{
|
|
get { return (x, y) => y.StartDate.CompareTo(x.StartDate); }
|
|
}
|
|
|
|
private DateTime? enddate;
|
|
|
|
public void UndoAiAction()
|
|
{
|
|
if (_AiActionHistoryIndex <= 0)
|
|
return;
|
|
|
|
_AiActionHistoryIndex--;
|
|
AktuellerDokutext = _AiActionHistory[_AiActionHistoryIndex];
|
|
}
|
|
|
|
public void RedoAiAction()
|
|
{
|
|
if (_AiActionHistoryIndex >= _AiActionHistory.Count - 1)
|
|
return;
|
|
|
|
_AiActionHistoryIndex++;
|
|
AktuellerDokutext = _AiActionHistory[_AiActionHistoryIndex];
|
|
}
|
|
|
|
public void UndoEditAiAction()
|
|
{
|
|
if (_EditAiActionHistoryIndex <= 0)
|
|
return;
|
|
|
|
_EditAiActionHistoryIndex--;
|
|
AktuellerEditDokutext = _EditAiActionHistory[_EditAiActionHistoryIndex];
|
|
}
|
|
|
|
public void RedoEditAiAction()
|
|
{
|
|
if (_EditAiActionHistoryIndex >= _EditAiActionHistory.Count - 1)
|
|
return;
|
|
|
|
_EditAiActionHistoryIndex++;
|
|
AktuellerEditDokutext = _EditAiActionHistory[_EditAiActionHistoryIndex];
|
|
}
|
|
|
|
public List<ServiceRecordVM> CreateFromPrototype()
|
|
{
|
|
var lResult = new List<ServiceRecordVM>();
|
|
|
|
|
|
if (WithoutClient)
|
|
{
|
|
ServiceRecordVM lNewRecord = CreateNewVM();
|
|
lNewRecord.Employee = BeWoApp.LoggedOnUser.Employee;
|
|
lNewRecord.Customer = null;
|
|
lResult.Add(lNewRecord);
|
|
}
|
|
else
|
|
{
|
|
foreach (FlatSupportConceptTreeNodeDC iCustomerNode in _CustomerNodes)
|
|
{
|
|
ServiceRecordVM lNewRecord = CreateNewVM();
|
|
|
|
enddate = lNewRecord.EndDate;
|
|
|
|
lNewRecord.ChoosenNode = iCustomerNode;
|
|
|
|
//if (_PrototypeVM.Duration == 0)
|
|
//{
|
|
// var minutes = enddate.Value.Subtract(_PrototypeVM.StartDate).TotalMinutes;
|
|
|
|
// _PrototypeVM.Duration = (decimal)minutes;
|
|
//}
|
|
|
|
//lNewRecord.Duration = _PrototypeVM.Duration / _CustomerNodes.Count;
|
|
|
|
//if(lNewRecord.Duration.HasValue)
|
|
//{
|
|
// lNewRecord.RoundedDuration = lNewRecord.Duration.Value;
|
|
//}
|
|
|
|
|
|
lResult.Add(lNewRecord);
|
|
}
|
|
}
|
|
|
|
// NewVM = null;
|
|
// _PrototypeVM = null;
|
|
FirePropertyChanged(PropertyName_PrototypeVM);
|
|
|
|
return lResult;
|
|
}
|
|
|
|
public ServiceRecordVM CreateNewVM(ServiceRecordDC pDC)
|
|
{
|
|
ServiceRecordVM lNewRecord = CreateVM(pDC);
|
|
return lNewRecord;
|
|
}
|
|
|
|
public List<AbsenceTimeDC> GetAbsencesTimeForDate(SupportConceptCostBearerRelDC relDc, DateTime dt)
|
|
{
|
|
if (_CostBearer2SupportConceptOid2BookingInfoDict.ContainsKey(relDc.CostBearer2SupportConceptOid.Value))
|
|
{
|
|
SupportConceptTreeNodeDetailInfoDC info = _CostBearer2SupportConceptOid2BookingInfoDict[relDc.CostBearer2SupportConceptOid.Value];
|
|
|
|
if (info != null && info.CustomerAbsenceTimes != null)
|
|
{
|
|
return info.CustomerAbsenceTimes.Where(
|
|
at => at.AbsenceSpan.ContainsDate(dt)).ToList();
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
//public List<ValueListEntryDC> GetSupportConceptGoals(SupportConceptCostBearerRelDC relDc)
|
|
//{
|
|
// List<ValueListEntryDC> list = new List<ValueListEntryDC>();
|
|
|
|
// if (this._CostBearer2SupportConceptOid2BookingInfoDict.ContainsKey(relDc.CostBearer2SupportConceptOid.Value))
|
|
// {
|
|
// SupportConceptTreeNodeDetailInfoDC info = this._CostBearer2SupportConceptOid2BookingInfoDict[relDc.CostBearer2SupportConceptOid.Value];
|
|
|
|
// list = info.SupportConceptGoals;
|
|
// }
|
|
|
|
// return list;
|
|
//}
|
|
|
|
public void RefreshServiceRecordsForSelectedTreeNode(bool refreshGoalTree)
|
|
{
|
|
BuildServiceRecordsForSelectedTreeNode(false, refreshGoalTree);
|
|
}
|
|
|
|
internal void ChangeTreeItemSelection(FlatSupportConceptTreeNodeDC lClickedNode)
|
|
{
|
|
if (WithoutClient || _SelectedCustomerNode == null || lClickedNode.SupportConceptTreeNodeDC == null ||
|
|
_SelectedCustomerNode.SupportConceptTreeNodeDC == null ||
|
|
!_SelectedCustomerNode.SupportConceptTreeNodeDC.Customer.EqualsNullCheck(
|
|
lClickedNode.SupportConceptTreeNodeDC.Customer) ||
|
|
!_SelectedCustomerNode.SupportConceptTreeNodeDC.SupportConcept.EqualsNullCheck(
|
|
lClickedNode.SupportConceptTreeNodeDC.SupportConcept) ||
|
|
!_SelectedCustomerNode.SupportConceptTreeNodeDC.CostBearer.EqualsNullCheck(
|
|
lClickedNode.SupportConceptTreeNodeDC.CostBearer))
|
|
{
|
|
_SelectedCustomerNode = lClickedNode;
|
|
FirePropertyChanged(nameof(IsAiChatButtonVisible));
|
|
FirePropertyChanged(nameof(IsAiDocuButtonVisible));
|
|
CustomerNodes.Clear();
|
|
|
|
if (lClickedNode != null)
|
|
{
|
|
CustomerNodes.Add(lClickedNode);
|
|
}
|
|
|
|
BuildServiceRecordsForSelectedTreeNode(false, true);
|
|
}
|
|
}
|
|
|
|
protected override ServiceRecordVM CreateVM(ServiceRecordDC pDC)
|
|
{
|
|
return new ServiceRecordVM(pDC, _Category2Services, null, null);
|
|
}
|
|
|
|
private void AddServiceRecordToList(ServiceRecordDC dc, List<ValueListEntryDC> goalCats, List<ValueListEntryDC> goals, FlatSupportConceptTreeNodeDC selectedCustomerNode)
|
|
{
|
|
bool contained = false;
|
|
|
|
InitNewDC(dc, selectedCustomerNode);
|
|
|
|
// List<ServiceRecordVM> contained = new List<ServiceRecordVM>();
|
|
var groupVMs = new Dictionary<string, ServiceRecordVM>();
|
|
|
|
foreach (ServiceRecordVM vm in VMList)
|
|
{
|
|
if (vm.GroupOid != null && vm.Customer != null)
|
|
{
|
|
string key = String.Format("{0}_{1}", vm.GroupOid.Value, vm.Customer.Oid.Value);
|
|
if (!groupVMs.ContainsKey(key))
|
|
{
|
|
groupVMs.Add(key, vm);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (ServiceRecordVM vm in VMList)
|
|
{
|
|
if (vm.DataContract.ServiceRecordOid == dc.ServiceRecordOid)
|
|
{
|
|
contained = true;
|
|
break;
|
|
}
|
|
if (dc.GroupOid != null && dc.Customer != null)
|
|
{
|
|
contained = true;
|
|
|
|
string key = String.Format("{0}_{1}", dc.GroupOid.Value, dc.Customer.Oid.Value);
|
|
|
|
if (groupVMs.ContainsKey(key))
|
|
{
|
|
ServiceRecordVM groupVM = groupVMs[key];
|
|
|
|
// groupVM.RoundedDuration = groupVM.GroupRoundedDuration.Value;
|
|
}
|
|
else
|
|
{
|
|
var newVM = new ServiceRecordVM(dc, _Category2Services, goalCats, goals);
|
|
SetDocTypes(newVM);
|
|
// newVM.RoundedDuration = newVM.GroupRoundedDuration.Value;
|
|
groupVMs.Add(key, newVM);
|
|
|
|
// ###AddServiceRecord
|
|
VMList.Add(newVM);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!contained)
|
|
{
|
|
// ###AddServiceRecord
|
|
var newVM = new ServiceRecordVM(dc, _Category2Services, goalCats, goals);
|
|
SetDocTypes(newVM);
|
|
if (dc.GroupOid != null)
|
|
{
|
|
// newVM.RoundedDuration = newVM.GroupRoundedDuration.Value;
|
|
}
|
|
|
|
|
|
VMList.Add(newVM);
|
|
}
|
|
}
|
|
|
|
private void SetDocTypes(ServiceRecordVM newVM)
|
|
{
|
|
if (AllDocTypes != null)
|
|
{
|
|
if (AllDocTypes.Count > 0)
|
|
{
|
|
newVM.DocField1 = AllDocTypes[0].TypeDescription;
|
|
}
|
|
if (AllDocTypes.Count > 1)
|
|
{
|
|
newVM.DocField2 = AllDocTypes[1].TypeDescription;
|
|
}
|
|
if (AllDocTypes.Count > 2)
|
|
{
|
|
newVM.DocField3 = AllDocTypes[2].TypeDescription;
|
|
}
|
|
if (AllDocTypes.Count > 3)
|
|
{
|
|
newVM.DocField4 = AllDocTypes[3].TypeDescription;
|
|
}
|
|
if (AllDocTypes.Count > 4)
|
|
{
|
|
newVM.DocField5 = AllDocTypes[4].TypeDescription;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void InitNewDC(ServiceRecordDC newDc, FlatSupportConceptTreeNodeDC selectedCustomerNode)
|
|
{
|
|
if (selectedCustomerNode != null && selectedCustomerNode.SupportConceptTreeNodeDC != null)
|
|
{
|
|
newDc.Customer = selectedCustomerNode.SupportConceptTreeNodeDC.Customer;
|
|
|
|
//dc.Customer = new CompactCustomerDC();
|
|
//dc.Customer.CustomerOid = cust.Oid.Value;
|
|
//dc.Customer.CustomerVersion = cust.Version.Value;
|
|
//dc.Customer.FirstName = cust.Person.FirstName;
|
|
//dc.Customer.LastName = cust.Person.LastName;
|
|
|
|
|
|
newDc.SupportConcept = selectedCustomerNode.SupportConceptTreeNodeDC.SupportConcept;
|
|
|
|
if (selectedCustomerNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC != null)
|
|
{
|
|
newDc.CostBearer2SupportConceptOid =
|
|
selectedCustomerNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.
|
|
CostBearer2SupportConceptOid;
|
|
|
|
newDc.CostBearer =
|
|
selectedCustomerNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.CostBearer;
|
|
}
|
|
//if (sr.SupportConcept != null)
|
|
//{
|
|
// dc.SupportConcept = new CompactSupportConceptDC();
|
|
|
|
// dc.SupportConcept.SupportConceptOid = sr.SupportConcept.Oid.Value;
|
|
// dc.SupportConcept.SupportConceptVersion = sr.SupportConcept.Version.Value;
|
|
// dc.SupportConcept.Customer = dc.Customer;
|
|
// dc.SupportConcept.ActivationType = sr.SupportConcept.IsActive;
|
|
// dc.SupportConcept.ConferenceDate = sr.SupportConcept.ConferenceDate;
|
|
//}
|
|
|
|
//Costbearer -----------------
|
|
//if (sr.CostBearer2SupportConcept != null)
|
|
//{
|
|
// dc.CostBearer2SupportConceptOid = sr.CostBearer2SupportConcept.Oid.Value;
|
|
|
|
// if (dc.SupportConcept != null)
|
|
// {
|
|
// CompactCostBearerDC costBearer = new CompactCostBearerDC();
|
|
|
|
// if (sr.CostBearer2SupportConcept.CostBearer.Organisation != null)
|
|
// {
|
|
// CompactOrganisationDC orgDC = new CompactOrganisationDC();
|
|
// orgDC.Name = sr.CostBearer2SupportConcept.CostBearer.Organisation.Name;
|
|
// orgDC.OrganisationOid = sr.CostBearer2SupportConcept.CostBearer.Organisation.Oid.Value;
|
|
// orgDC.CostBearerOid = sr.CostBearer2SupportConcept.CostBearer.Oid;
|
|
// dc.CostBearer = orgDC;
|
|
// costBearer.Organisation = orgDC;
|
|
// }
|
|
// costBearer.CostBearerOid = sr.CostBearer2SupportConcept.CostBearer.Oid.Value;
|
|
// costBearer.CostBearer2SupportConceptOid = sr.CostBearer2SupportConcept.Oid.Value;
|
|
// costBearer.SupportConceptStatus = sr.CostBearer2SupportConcept.Status;
|
|
// costBearer.RequestedStartDate = sr.CostBearer2SupportConcept.RequestedStartDate;
|
|
// costBearer.RequestedEndDate = sr.CostBearer2SupportConcept.RequestedEndDate;
|
|
// costBearer.ApprovedStartDate = sr.CostBearer2SupportConcept.ApprovedStartDate;
|
|
// costBearer.ApprovedEndDate = sr.CostBearer2SupportConcept.ApprovedEndDate;
|
|
// costBearer.CustomerReferenceNumber = sr.CostBearer2SupportConcept.CustomerReferenceNumber;
|
|
// costBearer.IsCalculatingWithFactor = sr.CostBearer2SupportConcept.CostBearer.IsCalculatingWithFactor;
|
|
|
|
// dc.SupportConcept.CostBearerList.Add(costBearer);
|
|
// dc.SupportConcept.CustomerReferenceNumbers.Add(sr.CostBearer2SupportConcept.CustomerReferenceNumber);
|
|
// dc.SupportConcept.CostBearerRelOids.Add(sr.CostBearer2SupportConcept.Oid.Value);
|
|
// }
|
|
|
|
// if (dc.CostBearer == null)
|
|
// {
|
|
// if (sr.CostBearer2SupportConcept.CostBearer.Organisation != null)
|
|
// dc.CostBearer = MapperFactory.CompactOrganisationDC_Organisation.MapToNewDC(sr.CostBearer2SupportConcept.CostBearer.Organisation);
|
|
// }
|
|
//}
|
|
}
|
|
}
|
|
|
|
public void BuildServiceRecordsForSelectedTreeNode(bool forceRefreshServiceRecords, bool changeGoalTree)
|
|
{
|
|
BuildServiceRecordsForSelectedTreeNode(forceRefreshServiceRecords, changeGoalTree, null);
|
|
}
|
|
|
|
public void BuildServiceRecordsForSelectedTreeNode(bool forceRefreshServiceRecords, bool changeGoalTree, Action refreshFinishedCallback)
|
|
{
|
|
long? days = 0;
|
|
DateTime start = DateTime.MinValue;
|
|
DateTime end = DateTime.MaxValue;
|
|
|
|
switch (ServiceRecordTimeInterval)
|
|
{
|
|
case ServiceRecordTimeInterval.All:
|
|
days = null;
|
|
break;
|
|
case ServiceRecordTimeInterval.LastWeek:
|
|
days = 7;
|
|
break;
|
|
case ServiceRecordTimeInterval.LastMonth:
|
|
days = 30;
|
|
break;
|
|
case ServiceRecordTimeInterval.Last3Month:
|
|
days = 90;
|
|
break;
|
|
case ServiceRecordTimeInterval.XTage:
|
|
days = _XTage;
|
|
break;
|
|
case ServiceRecordTimeInterval.ZeitraumWaehlen:
|
|
start = XTageVon.Value;
|
|
end = XTageBis.Value;
|
|
break;
|
|
case ServiceRecordTimeInterval.Monatsauswahl:
|
|
if (SelectedYear > 0)
|
|
{
|
|
start = new DateTime(SelectedYear, SelectedMonthIndex + 1, 1);
|
|
end = start.AddMonths(1).AddDays(-1);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (WithoutClient)
|
|
{
|
|
var emp = mSelectedEmployee ?? BeWoApp.LoggedOnUser.Employee;
|
|
|
|
PrototypeVM.UpdateServiceAccountings(null, _Category2Services, false);
|
|
|
|
if (DispatcherObject != null && (!days.HasValue || days.Value > 0))
|
|
{
|
|
ServiceFacade.DoOperationsServiceAsync(s => s.GetEmployeesServiceRecords2(emp.EmployeeOid, days),
|
|
r => DispatcherObject.Dispatch(delegate
|
|
{
|
|
PrepareListVM(r, null, null, null, null, true, null);
|
|
}));
|
|
}
|
|
else if (DispatcherObject != null)
|
|
{
|
|
|
|
ServiceFacade.DoOperationsServiceAsync(s => s.GetEmployeesServiceRecordsWithStartEndDate(emp.EmployeeOid, start, end),
|
|
r => DispatcherObject.Dispatch(delegate
|
|
{
|
|
PrepareListVM(r, null, null, null, null, true, null);
|
|
}));
|
|
}
|
|
else
|
|
{
|
|
BuildServiceRecordsForTreeNode(null, true, null);
|
|
}
|
|
|
|
PrototypeVM.ChangeGoalTree(null, null);
|
|
}
|
|
else
|
|
{
|
|
if (_SelectedCustomerNode != null)
|
|
{
|
|
if (_SelectedCustomerNode.SupportConceptTreeNodeDC == null)
|
|
{
|
|
//Gruppen- oder Mehrfachbuchung
|
|
PrototypeVM.UpdateServiceAccountings(null, _Category2Services, true);
|
|
|
|
BuildServiceRecordsForTreeNode(_SelectedCustomerNode, true, OnlyWithThisType);
|
|
}
|
|
else
|
|
{
|
|
var customer = _SelectedCustomerNode.SupportConceptTreeNodeDC.Customer;
|
|
|
|
if (customer != null)
|
|
{
|
|
var scDC = _SelectedCustomerNode.SupportConceptTreeNodeDC.SupportConcept;
|
|
|
|
List<ValueListEntryDC> goalCats = null;
|
|
List<ValueListEntryDC> goals = null;
|
|
|
|
var cb2scOid = _SelectedCustomerNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.CostBearer2SupportConceptOid.Value;
|
|
|
|
if (_CostBearer2SupportConceptOid2BookingInfoDict.ContainsKey(cb2scOid))
|
|
{
|
|
_CostBearer2SupportConceptOid2BookingInfoDict.Remove(cb2scOid);
|
|
}
|
|
|
|
long? scOidForGoals = scDC.SupportConceptOid;
|
|
|
|
var infoDC = ServiceFacade.DoOperationsServiceSync(s => s.GetSupportConceptTreeNodeDetailInfo(customer.CustomerOid, scOidForGoals, cb2scOid));
|
|
|
|
_CostBearer2SupportConceptOid2BookingInfoDict.Add(cb2scOid, infoDC);
|
|
|
|
if (infoDC != null && infoDC.SupportConceptGoals != null && infoDC.SupportConceptGoals.Count > 0)
|
|
{
|
|
goalCats = new List<ValueListEntryDC>();
|
|
goals = new List<ValueListEntryDC>();
|
|
|
|
var goalCategoryDict = _AllGoalCategories.ToDictionary(goalCat => goalCat.ValueListEntryOid.Value);
|
|
|
|
foreach (var goal in infoDC.SupportConceptGoals)
|
|
{
|
|
if (goal.ParentOid != null && goalCategoryDict.ContainsKey(goal.ParentOid.Value))
|
|
{
|
|
var path = GetAllParentGoalCategoies(goalCategoryDict, goal);
|
|
foreach (var goalCat in path)
|
|
{
|
|
goalCats.Add(goalCat);
|
|
goalCategoryDict.Remove(goalCat.ValueListEntryOid.Value);
|
|
}
|
|
}
|
|
|
|
goals.Add(goal);
|
|
}
|
|
}
|
|
if (infoDC != null)
|
|
{
|
|
_SelectedCustomerNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.ApprovalPeriodList = infoDC.ApprovalPeriods;
|
|
|
|
if (!IsGroupBooking && !IsMultiBooking)
|
|
{
|
|
PrototypeVM.UpdateServiceAccountings(infoDC.ServiceAccountings, _Category2Services, true);
|
|
}
|
|
}
|
|
|
|
if (DispatcherObject != null && (!days.HasValue || days.Value > 0))
|
|
{
|
|
ServiceFacade.DoOperationsServiceAsync(
|
|
s => s.GetCustomerServiceRecordsCompact(customer.CustomerOid, cb2scOid, days),
|
|
r => DispatcherObject.Dispatch(delegate
|
|
{
|
|
PrepareListVM(r, goalCats, goals, _SelectedCustomerNode, refreshFinishedCallback, true, OnlyWithThisType);
|
|
}));
|
|
}
|
|
else if (DispatcherObject != null)
|
|
{
|
|
ServiceFacade.DoOperationsServiceAsync(
|
|
s => s.GetCustomerServiceRecordsCompactWithStartEndDate(customer.CustomerOid, cb2scOid, start, end),
|
|
r => DispatcherObject.Dispatch(delegate
|
|
{
|
|
PrepareListVM(r, goalCats, goals, _SelectedCustomerNode, refreshFinishedCallback, true, OnlyWithThisType);
|
|
}));
|
|
}
|
|
|
|
if (changeGoalTree)
|
|
{
|
|
var copyGoalCats = GoalService.CopyGoals(goalCats, false);
|
|
var copyGoals = GoalService.CopyGoals(goals, false);
|
|
|
|
PrototypeVM.ChangeGoalTree(copyGoalCats, copyGoals);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PrepareListVM(IEnumerable<ServiceRecordDC> pServiceRecords, List<ValueListEntryDC> pGoalCats, List<ValueListEntryDC> pGoals, FlatSupportConceptTreeNodeDC pSelectedCustomerNode, Action pRefreshFinishedCallback, bool pShouldFetchStatistics, ServiceRecordTypeId? pOnlyWithThisType)
|
|
{
|
|
VMList.Clear();
|
|
foreach (var dc in pServiceRecords)
|
|
{
|
|
AddServiceRecordToList(dc, pGoalCats, pGoals, pSelectedCustomerNode);
|
|
}
|
|
|
|
BuildServiceRecordsForTreeNode(pSelectedCustomerNode, pShouldFetchStatistics, pOnlyWithThisType);
|
|
|
|
if (pRefreshFinishedCallback != null)
|
|
{
|
|
pRefreshFinishedCallback();
|
|
}
|
|
}
|
|
|
|
public static IEnumerable<ValueListEntryDC> GetAllParentGoalCategoies(Dictionary<long, ValueListEntryDC> goalCategoryDict, ValueListEntryDC goal)
|
|
{
|
|
IList<ValueListEntryDC> path = new List<ValueListEntryDC>();
|
|
|
|
|
|
if (goal.ParentOid.HasValue && goalCategoryDict.ContainsKey(goal.ParentOid.Value))
|
|
{
|
|
ValueListEntryDC parentCat = goalCategoryDict[goal.ParentOid.Value];
|
|
|
|
while (parentCat != null)
|
|
{
|
|
path.Add(parentCat);
|
|
if (parentCat.ParentOid.HasValue && goalCategoryDict.ContainsKey(parentCat.ParentOid.Value))
|
|
{
|
|
parentCat = goalCategoryDict[parentCat.ParentOid.Value];
|
|
}
|
|
else
|
|
{
|
|
parentCat = null;
|
|
}
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
|
|
private List<ValueListEntryDC> Parents;
|
|
|
|
public void GetGoalParents(ValueListEntryDC child, Dictionary<long, ValueListEntryDC> possibleParents)
|
|
{
|
|
while (true)
|
|
{
|
|
if (child.ParentOid != null && possibleParents.ContainsKey(child.ParentOid.Value) && !Parents.Contains(possibleParents[child.ParentOid.Value]))
|
|
{
|
|
Parents.Add(possibleParents[child.ParentOid.Value]);
|
|
child = possibleParents[child.ParentOid.Value];
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void BuildServiceRecordsForTreeNode(FlatSupportConceptTreeNodeDC treeNode, bool fetchStatistics, ServiceRecordTypeId? onlyWithThisType)
|
|
{
|
|
_ServiceRecordsForSelectedCustomer.Clear();
|
|
|
|
if (fetchStatistics)
|
|
Statistics = null;
|
|
|
|
bool isTypeZeitraumWaehlen = false;
|
|
|
|
if (WithoutClient || (treeNode != null && treeNode.SupportConceptTreeNodeDC != null))
|
|
{
|
|
SupportConceptCostBearerRelDC relDC = null;
|
|
|
|
if (!WithoutClient)
|
|
{
|
|
relDC = treeNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC;
|
|
}
|
|
|
|
Func<ServiceRecordVM, bool> f;
|
|
if (WithoutClient)
|
|
{
|
|
CompactEmployeeDC emp = SelectedEmployee ?? BeWoApp.LoggedOnUser.Employee;
|
|
|
|
f = vm => (vm.Customer == null || vm.SupportConcept == null || vm.CostBearer == null) && emp.Equals(vm.Employee) && (!onlyWithThisType.HasValue || onlyWithThisType.HasValue && vm.ServiceRecordType == onlyWithThisType.Value);
|
|
}
|
|
else
|
|
{
|
|
if (treeNode.SupportConceptTreeNodeDC.CostBearer != null)
|
|
{
|
|
f = vm =>
|
|
treeNode.SupportConceptTreeNodeDC.Customer.Equals(vm.Customer) &&
|
|
treeNode.SupportConceptTreeNodeDC.SupportConcept.Equals(vm.SupportConcept) &&
|
|
treeNode.SupportConceptTreeNodeDC.CostBearer.Equals(vm.CostBearer) &&
|
|
(!onlyWithThisType.HasValue /*&& vm.ServiceRecordType != ServiceRecordTypeId.AdditionalService*/||
|
|
onlyWithThisType.HasValue && vm.ServiceRecordType == onlyWithThisType.Value);
|
|
}
|
|
else if (treeNode.SupportConceptTreeNodeDC.SupportConcept != null)
|
|
{
|
|
f = vm =>
|
|
treeNode.SupportConceptTreeNodeDC.Customer.Equals(vm.Customer) &&
|
|
treeNode.SupportConceptTreeNodeDC.SupportConcept.Equals(vm.SupportConcept) &&
|
|
(!onlyWithThisType.HasValue /* && vm.ServiceRecordType != ServiceRecordTypeId.AdditionalService */||
|
|
onlyWithThisType.HasValue && vm.ServiceRecordType == onlyWithThisType.Value);
|
|
}
|
|
else
|
|
{
|
|
f = vm =>
|
|
treeNode.SupportConceptTreeNodeDC.Customer.Equals(vm.Customer) &&
|
|
(!onlyWithThisType.HasValue /* && vm.ServiceRecordType != ServiceRecordTypeId.AdditionalService */||
|
|
onlyWithThisType.HasValue && vm.ServiceRecordType == onlyWithThisType.Value);
|
|
}
|
|
}
|
|
|
|
//var recordsUpToDate = ServiceFacade.DoOperationsServiceSync(s => s.GetCustomerServiceRecords(treeNode.SupportConceptTreeNodeDC.Customer.Oid.Value, false));
|
|
//VMList.Clear();
|
|
//foreach (var record in recordsUpToDate.Where(r =>
|
|
// r.SupportConcept.SupportConceptOid.Equals(treeNode.SupportConceptTreeNodeDC.SupportConcept.SupportConceptOid) &&
|
|
// r.CostBearer2SupportConceptOid.Value.Equals(treeNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.CostBearer2SupportConceptOid.Value)))
|
|
//{
|
|
|
|
// if (record.GroupOid.HasValue && VMList.Any(x => x.GroupOid.HasValue && x.GroupOid.Equals(record.GroupOid)))
|
|
// continue;
|
|
|
|
// VMList.Add(CreateVM(record));
|
|
//}
|
|
|
|
foreach (ServiceRecordVM vm in VMList.Where(f))
|
|
{
|
|
long? days = null;
|
|
switch (ServiceRecordTimeInterval)
|
|
{
|
|
case ServiceRecordTimeInterval.LastWeek:
|
|
days = 7;
|
|
break;
|
|
case ServiceRecordTimeInterval.LastMonth:
|
|
days = 30;
|
|
break;
|
|
case ServiceRecordTimeInterval.Last3Month:
|
|
days = 90;
|
|
break;
|
|
case ServiceRecordTimeInterval.XTage:
|
|
days = _XTage;
|
|
break;
|
|
//case ServiceRecordTimeInterval.ZeitraumWaehlen:
|
|
|
|
// //zu test zwecken
|
|
// var x = XTageBis.Value.Date - XTageVon.Value.Date;
|
|
|
|
// days = (long)x.TotalDays;
|
|
|
|
// isTypeZeitraumWaehlen = true;
|
|
|
|
// break;
|
|
}
|
|
|
|
DateTime minDate = DateTime.MinValue;
|
|
if (days.HasValue)
|
|
{
|
|
minDate = DateTime.Now.Date.AddDays(-1 * days.Value);
|
|
}
|
|
if (vm.StartDate >= minDate)
|
|
_ServiceRecordsForSelectedCustomer.Add(vm);
|
|
}
|
|
|
|
if (!WithoutClient && relDC != null && isTypeZeitraumWaehlen == false)
|
|
{
|
|
if (fetchStatistics)
|
|
{
|
|
|
|
//DateTime stichtag = new DateTime(2021, 8, 15);
|
|
DateTime stichtag = DateTime.Now;
|
|
|
|
ServiceFacade.DoOperationsServiceAsync(
|
|
s1 =>
|
|
s1.GetServiceRecordStatisticInfo(relDC.CostBearer2SupportConceptOid.Value, stichtag),
|
|
stinf =>
|
|
ServiceFacade.DoOperationsServiceAsync(
|
|
s =>
|
|
s.CreateSupportConceptStatistics(relDC.CostBearer2SupportConceptOid.Value, stichtag),
|
|
r => DispatcherObject.Dispatch(delegate
|
|
{
|
|
StatisticsDC = r;
|
|
RecordStatisticsDC = stinf;
|
|
|
|
if (stinf != null && StatisticInfosLoaded != null)
|
|
{
|
|
StatisticInfosLoaded(stinf, new EventArgs());
|
|
}
|
|
else
|
|
{
|
|
Statistics = CreateStatisticVMList(r);
|
|
}
|
|
}), false));
|
|
}
|
|
}
|
|
}
|
|
|
|
//ErstelleRecordInformationString(_ServiceRecordsForSelectedCustomer);
|
|
|
|
FirePropertyChanged(PropertyName_ServiceRecordsForSelectedCustomer);
|
|
|
|
|
|
if (ServiceRecordListChanged != null)
|
|
{
|
|
ServiceRecordListChanged(this, new EventArgs());
|
|
}
|
|
}
|
|
|
|
public void ErstelleRecordInformationString(IList<ServiceRecordVM> records)
|
|
{
|
|
if (records == null)
|
|
{
|
|
_RecordCountInformationString = null;
|
|
}
|
|
else
|
|
{
|
|
decimal minuten = 0;
|
|
|
|
foreach (var sr in records)
|
|
{
|
|
minuten += sr.RoundedDuration;
|
|
}
|
|
_RecordCountInformationString =
|
|
String.Format("Anzahl Einträge: {0}, Summe Minuten: {1:0.##} entspricht {2:0.00} Stunden", records.Count, minuten, minuten / 60);
|
|
|
|
}
|
|
|
|
FirePropertyChanged(PropertyName_RecordCountInformationString);
|
|
}
|
|
|
|
private static List<SupportConceptPeriodStatisticsVM> CreateStatisticVMList(SupportConceptStatisticsDC statisticsDc)
|
|
{
|
|
var stats =
|
|
new List<SupportConceptPeriodStatisticsVM>();
|
|
if (statisticsDc != null)
|
|
{
|
|
if (statisticsDc.PeriodStatistics.Count > 1 && !TimeSpanIsEqual(statisticsDc))
|
|
stats.Add(CreateTotalStatisticsVM(statisticsDc));
|
|
|
|
foreach (SupportConceptPeriodStatisticsDC dc in statisticsDc.PeriodStatistics)
|
|
{
|
|
bool showOutOfPeriod = statisticsDc.PeriodStatistics.Count == 1;
|
|
stats.Add(CreateStatisticsVM(statisticsDc, dc, showOutOfPeriod));
|
|
}
|
|
}
|
|
return stats;
|
|
}
|
|
|
|
public static SupportConceptPeriodStatisticsVM CreateTotalStatisticsVM(SupportConceptStatisticsDC dc)
|
|
{
|
|
int unitDividend = 60;
|
|
|
|
var vm = new SupportConceptPeriodStatisticsVM();
|
|
vm.Header = "Gesamt";
|
|
|
|
String tenant = BeWoApp.Tenant;
|
|
|
|
#if DEBUG
|
|
//tenant = "3057313346";
|
|
#endif
|
|
if (tenant == "3057313346" || tenant == "2918696314")
|
|
{
|
|
unitDividend = 1;
|
|
vm.StatisticInfo1Left = String.Format("{0:0.00}", dc.MinutesProvidedThisWeek / unitDividend);
|
|
vm.StatisticInfo1Right = String.Format("{0:0.00}", dc.MinutesProvidedTotalRounded / unitDividend);
|
|
|
|
vm.StatisticInfo2Left = String.Format("{0:0.00}", dc.MinutesApprovedPerWeek / unitDividend);
|
|
vm.StatisticInfo2Right = String.Format("{0:0.00}", dc.MinutesApprovedTotal / unitDividend);
|
|
|
|
vm.StatisticInfo3Left = String.Format("{0:0.00}", dc.MinutesFreePerWeekAverage / unitDividend);
|
|
vm.StatisticInfo3Right = String.Format("{0:0.00}", (dc.MinutesApprovedTotal - dc.MinutesProvidedTotalRounded) / unitDividend);
|
|
|
|
vm.StatisticInfo4Left = String.Format("{0:0.00}", dc.MinutesProvidedThisMonth / unitDividend);
|
|
vm.StatisticInfo4Right = String.Format("{0:0.00}", dc.MinutesApprovedPerMonth / unitDividend);
|
|
|
|
vm.StatisticInfo5Left = String.Format("{0:0.00}", dc.SollTotalUntilThisMonth / unitDividend);
|
|
vm.StatisticInfo5Right = String.Format("{0:0.00}", dc.IstTotalUntilThisMonth / unitDividend);
|
|
}
|
|
else
|
|
{
|
|
vm.StatisticInfo1Left = String.Format("{0:0.00}", dc.MinutesProvidedThisWeek / unitDividend);
|
|
vm.StatisticInfo1Right = String.Format("{0:0.00}", dc.MinutesProvidedTotalRounded / unitDividend);
|
|
|
|
vm.StatisticInfo2Left = String.Format("{0:0.00}", dc.MinutesApprovedPerWeek / unitDividend);
|
|
vm.StatisticInfo2Right = String.Format("{0:0.00}", dc.MinutesApprovedTotal / unitDividend);
|
|
|
|
vm.StatisticInfo3Left = String.Format("{0:0.00}", dc.MinutesFreePerWeekAverage / unitDividend);
|
|
|
|
vm.StatisticInfo3Right = String.Format("{0:0.00}", (dc.MinutesApprovedTotal - dc.MinutesProvidedTotalRounded) / unitDividend);
|
|
|
|
|
|
decimal schwellwert = dc.MinutesApprovedTotal * (BeWoApp.AppSettings.ZeiterfassungsSchwellwert / 100m);
|
|
decimal free = dc.MinutesApprovedTotal - dc.MinutesProvidedTotalRounded;
|
|
|
|
decimal prozent = 0;
|
|
if (dc.MinutesApprovedTotal != 0)
|
|
{
|
|
prozent = (free / dc.MinutesApprovedTotal) * 100;
|
|
}
|
|
if (dc.MinutesProvidedTotalRounded > schwellwert)
|
|
{
|
|
vm.StatisticInfo3ForegroundColor = Brushes.Red;
|
|
|
|
if (free >= 0)
|
|
{
|
|
vm.StatisticInfo3Tooltip =
|
|
String.Format(
|
|
"Es stehen nur noch {0:0.##} % der bewilligten Gesamtstunden zur Verfügung.\nSie können den Schwellwert für diese Anzeige in der Verwaltung ändern.",
|
|
prozent);
|
|
}
|
|
else
|
|
{
|
|
vm.StatisticInfo3Tooltip =
|
|
String.Format(
|
|
"Die bewilligten Gesamtstunden wurden um {0:0.##} % überschritten.\nSie können den Schwellwert für diese Anzeige in der Verwaltung ändern.",
|
|
prozent * -1m);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
vm.StatisticInfo3ForegroundColor = Brushes.Green;
|
|
vm.StatisticInfo3Tooltip =
|
|
String.Format(
|
|
"Es stehen noch {0:0.##} % der bewilligten Gesamtstunden zur Verfügung.\nSie können den Schwellwert für diese Anzeige in der Verwaltung ändern.",
|
|
prozent);
|
|
}
|
|
}
|
|
|
|
|
|
vm.MinutesProvidedTotalRounded = dc.MinutesProvidedTotalRounded;
|
|
return vm;
|
|
}
|
|
|
|
public static SupportConceptPeriodStatisticsVM CreateStatisticsVM(SupportConceptStatisticsDC stats, SupportConceptPeriodStatisticsDC periodStats, bool showOutOfPeriod)
|
|
{
|
|
int unitDividend = 60;
|
|
|
|
var vm = new SupportConceptPeriodStatisticsVM();
|
|
if (periodStats.SupportConceptApprovalPeriod != null)
|
|
{
|
|
if (periodStats.SupportConceptApprovalPeriod.ServiceCategory != null)
|
|
{
|
|
if (periodStats.SupportConceptApprovalPeriod.StartDate.HasValue && periodStats.SupportConceptApprovalPeriod.EndDate.HasValue &&
|
|
periodStats.SupportConceptApprovalPeriod.StartDate.Value.Date == stats.StatisticsStartDate.Date &&
|
|
periodStats.SupportConceptApprovalPeriod.EndDate.Value.Date == stats.StatisticsEndDate.Date && !showOutOfPeriod)
|
|
{
|
|
vm.Header = periodStats.SupportConceptApprovalPeriod.ServiceCategory.Name;
|
|
}
|
|
else
|
|
{
|
|
vm.Header = String.Format("{0}: {1:dd.MM.yy} - {2:dd.MM.yy}",
|
|
periodStats.SupportConceptApprovalPeriod.ServiceCategory.Name,
|
|
periodStats.SupportConceptApprovalPeriod.StartDate,
|
|
periodStats.SupportConceptApprovalPeriod.EndDate);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vm.Header = String.Format("{0:dd.MM.yy} - {1:dd.MM.yy}",
|
|
periodStats.SupportConceptApprovalPeriod.StartDate,
|
|
periodStats.SupportConceptApprovalPeriod.EndDate);
|
|
}
|
|
}
|
|
String tenant = BeWoApp.Tenant;
|
|
|
|
#if DEBUG
|
|
//tenant = "3057313346";
|
|
#endif
|
|
if (tenant == "3057313346" || tenant == "2918696314")
|
|
{
|
|
unitDividend = 1;
|
|
vm.StatisticInfo1Left = String.Format("{0:0.00}", periodStats.MinutesProvidedTotalRounded / unitDividend);
|
|
vm.StatisticInfo1Right = String.Format("{0:0.00}", periodStats.MinutesApprovedTotal / unitDividend);
|
|
|
|
vm.StatisticInfo2Left = String.Format("{0:0.00}", periodStats.MinutesProvidedThisWeek / unitDividend);
|
|
vm.StatisticInfo2Right = String.Format("{0:0.00}", periodStats.MinutesApprovedPerWeek / unitDividend);
|
|
|
|
vm.StatisticInfo3Left = String.Format("{0:0.00}", periodStats.MinutesProvidedThisMonth / unitDividend);
|
|
vm.StatisticInfo3Right = String.Format("{0:0.00}", periodStats.MinutesApprovedPerMonth / unitDividend);
|
|
|
|
vm.StatisticInfo4Left = String.Format("{0:0.00}",
|
|
(periodStats.SollTotalUntilThisMonth - periodStats.IstTotalUntilThisMonth) /
|
|
unitDividend);
|
|
}
|
|
else
|
|
{
|
|
vm.StatisticInfo1Left = String.Format("{0:0.00}", periodStats.MinutesProvidedThisWeek / unitDividend);
|
|
vm.StatisticInfo1Right = String.Format("{0:0.00}", periodStats.MinutesProvidedTotalRounded / unitDividend);
|
|
|
|
vm.StatisticInfo2Left = String.Format("{0:0.00}", periodStats.MinutesApprovedPerWeek / unitDividend);
|
|
vm.StatisticInfo2Right = String.Format("{0:0.00}", periodStats.MinutesApprovedTotal / unitDividend);
|
|
|
|
vm.StatisticInfo3Left = String.Format("{0:0.00}", periodStats.MinutesFreePerWeek / unitDividend);
|
|
vm.StatisticInfo3Right = String.Format("{0:0.00}",
|
|
(periodStats.MinutesApprovedTotal - periodStats.MinutesProvidedTotalRounded) /
|
|
unitDividend);
|
|
|
|
decimal schwellwert = periodStats.MinutesApprovedTotal * (BeWoApp.AppSettings.ZeiterfassungsSchwellwert / 100m);
|
|
decimal free = periodStats.MinutesApprovedTotal - periodStats.MinutesProvidedTotalRounded;
|
|
|
|
decimal prozent = 0;
|
|
if (periodStats.MinutesApprovedTotal != 0)
|
|
{
|
|
prozent = (free / periodStats.MinutesApprovedTotal) * 100;
|
|
}
|
|
if (periodStats.MinutesProvidedTotalRounded > schwellwert)
|
|
{
|
|
vm.StatisticInfo3ForegroundColor = Brushes.Red;
|
|
|
|
if (free >= 0)
|
|
{
|
|
vm.StatisticInfo3Tooltip =
|
|
String.Format(
|
|
"Es stehen nur noch {0:0.##} % der bewilligten Gesamtstunden zur Verfügung.\nSie können den Schwellwert für diese Anzeige in der Verwaltung ändern.",
|
|
prozent);
|
|
}
|
|
else
|
|
{
|
|
vm.StatisticInfo3Tooltip =
|
|
String.Format(
|
|
"Die bewilligten Gesamtstunden wurden um {0:0.##} % überschritten.\nSie können den Schwellwert für diese Anzeige in der Verwaltung ändern.",
|
|
prozent * -1m);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
vm.StatisticInfo3ForegroundColor = Brushes.Green;
|
|
vm.StatisticInfo3Tooltip =
|
|
String.Format(
|
|
"Es stehen noch {0:0.##} % der bewilligten Gesamtstunden zur Verfügung.\nSie können den Schwellwert für diese Anzeige in der Verwaltung ändern.",
|
|
prozent);
|
|
}
|
|
|
|
}
|
|
if (showOutOfPeriod && stats.MinutesOutOfApprovedPeriod > 0)
|
|
vm.StatisticInfo1Error = String.Format(" {0:0.00}", stats.MinutesOutOfApprovedPeriod / 60);
|
|
|
|
vm.MinutesProvidedTotalRounded = periodStats.MinutesProvidedTotalRounded;
|
|
|
|
return vm;
|
|
}
|
|
|
|
private static bool TimeSpanIsEqual(SupportConceptStatisticsDC r)
|
|
{
|
|
if (r.PeriodStatistics != null && r.PeriodStatistics.Count > 1)
|
|
{
|
|
for (int i = 0; i < r.PeriodStatistics.Count - 1; i++)
|
|
{
|
|
SupportConceptPeriodStatisticsDC p1 = r.PeriodStatistics[i];
|
|
|
|
if (p1.SupportConceptApprovalPeriod.StartDate.HasValue && p1.SupportConceptApprovalPeriod.EndDate.HasValue)
|
|
{
|
|
for (int j = i + 1; j < r.PeriodStatistics.Count; j++)
|
|
{
|
|
SupportConceptPeriodStatisticsDC p2 = r.PeriodStatistics[j];
|
|
if (p2.SupportConceptApprovalPeriod.StartDate.HasValue && p2.SupportConceptApprovalPeriod.EndDate.HasValue)
|
|
{
|
|
if ((p1.SupportConceptApprovalPeriod.StartDate.Value.Date != p2.SupportConceptApprovalPeriod.StartDate.Value.Date) ||
|
|
(p1.SupportConceptApprovalPeriod.EndDate.Value.Date != p2.SupportConceptApprovalPeriod.EndDate.Value.Date))
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private decimal CalculateDurationSum(FlatSupportConceptTreeNodeDC pCustomerNode)
|
|
{
|
|
decimal lResult = 0m;
|
|
|
|
if (_PrototypeVM.Duration > 0)
|
|
{
|
|
lResult = Convert.ToDecimal(_PrototypeVM.RoundedDuration) / _CustomerNodes.Count;
|
|
|
|
if (_PrototypeVM.ServiceDescription != null && _PrototypeVM.ServiceDescription.Category != null && _PrototypeVM.ServiceDescription.Category.IsBillable &&
|
|
pCustomerNode.SupportConceptTreeNodeDC.CostBearer != null)
|
|
{
|
|
int mi = pCustomerNode.SupportConceptTreeNodeDC.CostBearer.ActualMinuteIntervall;
|
|
|
|
if (mi > 0)
|
|
{
|
|
lResult = lResult % mi != 0
|
|
? lResult + (mi - (lResult % mi))
|
|
: lResult;
|
|
}
|
|
}
|
|
}
|
|
|
|
return lResult; // *this.GetBookingDates().Count();
|
|
}
|
|
|
|
private void CheckCustomerAbsenceTimes()
|
|
{
|
|
IsCustomerWarningActive = false;
|
|
|
|
if (!WithoutClient)
|
|
{
|
|
if (CustomerNodes != null)
|
|
{
|
|
foreach (FlatSupportConceptTreeNodeDC iCustomerNode in CustomerNodes)
|
|
{
|
|
if (iCustomerNode.SupportConceptTreeNodeDC != null &&
|
|
iCustomerNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC != null)
|
|
{
|
|
List<AbsenceTimeDC> atList =
|
|
GetAbsencesTimeForDate(
|
|
iCustomerNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC,
|
|
PrototypeVM.StartDate);
|
|
if (atList != null && atList.Count > 0)
|
|
{
|
|
IsCustomerWarningActive = true;
|
|
|
|
CustomerWarning = "";
|
|
AbsenceTimeDC atCurrent = null;
|
|
foreach (AbsenceTimeDC at in atList)
|
|
{
|
|
if (CustomerWarning.Length > 0)
|
|
CustomerWarning += "\n";
|
|
CustomerWarning += String.Format("{0} von {1:d} bis {2}", at.Reason.Description,
|
|
at.Start,
|
|
at.End.HasValue
|
|
? String.Format("{0:d}", at.End)
|
|
: "unbekannt");
|
|
|
|
if (at.Reason.BillableMinutes.HasValue && at.Reason.BillableMinutes.Value > 0)
|
|
atCurrent = at;
|
|
}
|
|
|
|
|
|
if (atCurrent != null)
|
|
{
|
|
DateTimeSpan week = null;
|
|
decimal maxBillableMinutes = atCurrent.Reason.BillableMinutes.Value;
|
|
|
|
IEnumerable<DateTimeSpan> lAbsenceWeeks = atCurrent.AbsenceSpan.GetWholeWeeks();
|
|
foreach (DateTimeSpan lAbsenceWeek in lAbsenceWeeks)
|
|
{
|
|
if (PrototypeVM.StartDate.InBetween(lAbsenceWeek, true))
|
|
{
|
|
week = lAbsenceWeek;
|
|
}
|
|
}
|
|
|
|
|
|
//iCustomerNode.IsCustomerWarningActive = false;
|
|
//iCustomerNode.CustomerWarning = null;
|
|
DateTime start = atCurrent.Start.Value.Date;
|
|
DateTime end = atCurrent.End.HasValue
|
|
? atCurrent.End.Value.Date
|
|
: DateTime.MaxValue;
|
|
|
|
if (week != null)
|
|
{
|
|
decimal lExisitingFLMInAbsenceWeek =
|
|
VMList.Where(
|
|
sr =>
|
|
sr.Customer != null &&
|
|
sr.Customer.Equals(iCustomerNode.SupportConceptTreeNodeDC.Customer) &&
|
|
sr.ServiceDescription != null &&
|
|
sr.ServiceDescription.Category.IsBillable &&
|
|
sr.StartDate.InBetween(week, true) &&
|
|
sr.StartDate.Date != start &&
|
|
sr.StartDate.Date != end)
|
|
.Sum(sr => sr.RoundedDuration);
|
|
|
|
//decimal lNewFLMInAbsenceWeek = CalculateDurationSum(iCustomerNode);
|
|
|
|
//if (lExisitingFLMInAbsenceWeek + lNewFLMInAbsenceWeek > lAbsenceWeek.Value)
|
|
//{
|
|
//iCustomerNode.IsCustomerWarningActive = true;
|
|
|
|
CustomerWarning +=
|
|
"\nAbrechenbar in dieser Woche: " +
|
|
maxBillableMinutes +
|
|
" Minuten\nBereits geleistet: " +
|
|
BeWoWpfUtils.GetDecimalValueWithMaxDecimal(lExisitingFLMInAbsenceWeek, 2) +
|
|
" Minuten";
|
|
//" Minuten\nNeue Buchung(en) in der Maske: " + BeWoWpfUtils.GetDecimalValueWithMaxDecimal(lNewFLMInAbsenceWeek, 2) + " Minuten" +
|
|
|
|
decimal notBillableMinutes =
|
|
BeWoWpfUtils.GetDecimalValueWithMaxDecimal(
|
|
-(maxBillableMinutes -
|
|
(lExisitingFLMInAbsenceWeek)), 2) ?? 0;
|
|
if (notBillableMinutes > 0)
|
|
{
|
|
CustomerWarning += "\nEs werden " + notBillableMinutes +
|
|
" Minuten verfallen";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void CheckEmployeeLabourTime()
|
|
{
|
|
}
|
|
|
|
private ServiceRecordVM CreateNewVM()
|
|
{
|
|
ServiceRecordVM lNewRecord = _PrototypeVM.Clone();
|
|
|
|
//lNewRecord.Date = _PrototypeVM.Date;
|
|
//lNewRecord.Duration = _PrototypeVM.Duration;
|
|
|
|
//if (_PrototypeVM.Duration.HasValue)
|
|
//lNewRecord.RoundedDuration = _PrototypeVM.Duration.Value;
|
|
|
|
lNewRecord.SetInsertedOn(DateTime.Now);
|
|
lNewRecord.InsUser = BeWoApp.LoggedOnUser.Employee.FirstName + " " + BeWoApp.LoggedOnUser.Employee.LastName;
|
|
|
|
//lNewRecord.ServiceRecordType = this._PrototypeVM.ServiceRecordType;
|
|
|
|
return lNewRecord;
|
|
}
|
|
|
|
//private List<DateTime> GetBookingDates()
|
|
//{
|
|
// if (this._PrototypeVM != null && this._PrototypeVM.Date != null && this._RecordingDays != null)
|
|
// {
|
|
// return this._RecordingDays.Select(d => this._PrototypeVM.Date.Value.GetInSameCalendarWeek(d)).ToList();
|
|
// }
|
|
|
|
// return new List<DateTime>();
|
|
//}
|
|
|
|
public bool IsGroupBooking { get; set; }
|
|
|
|
public bool IsMultiBooking { get; set; }
|
|
|
|
internal decimal GetFLSTotal(ServiceRecordVM vm)
|
|
{
|
|
if (Statistics != null && Statistics.Count > 0)
|
|
{
|
|
return Statistics[0].MinutesProvidedTotalRounded / 60;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public ServiceRecordStatisticsInfoDC RecordStatisticsDC { get; set; }
|
|
public SupportConceptStatisticsDC StatisticsDC { get; set; }
|
|
|
|
internal static GroupDurationDC CalculateGroupDuration(int personCount, int employeeCount, decimal totalDuration, List<long> costBearer2SupportConceptList)
|
|
{
|
|
return ServiceFacade.DoOperationsServiceSync(s => s.CalculateGroupDuration2(personCount, employeeCount, totalDuration, costBearer2SupportConceptList));
|
|
}
|
|
|
|
public void InitPrototypeVM(long customerOid, long? supportConceptOid, long? cb2scOid)
|
|
{
|
|
|
|
var infoDC = ServiceFacade.DoOperationsServiceSync(s => s.GetSupportConceptTreeNodeDetailInfo(customerOid, supportConceptOid, cb2scOid));
|
|
|
|
if (infoDC != null && infoDC.SupportConceptGoals != null && infoDC.SupportConceptGoals.Count > 0)
|
|
{
|
|
var goalCats = new List<ValueListEntryDC>();
|
|
var goals = new List<ValueListEntryDC>();
|
|
|
|
var goalCategoryDict = _AllGoalCategories.ToDictionary(goalCat => goalCat.ValueListEntryOid.Value);
|
|
|
|
foreach (var goal in infoDC.SupportConceptGoals)
|
|
{
|
|
if (goal.ParentOid != null && goalCategoryDict.ContainsKey(goal.ParentOid.Value))
|
|
{
|
|
var path = GetAllParentGoalCategoies(goalCategoryDict, goal);
|
|
foreach (var goalCat in path)
|
|
{
|
|
goalCats.Add(goalCat);
|
|
goalCategoryDict.Remove(goalCat.ValueListEntryOid.Value);
|
|
}
|
|
}
|
|
|
|
goals.Add(goal);
|
|
}
|
|
|
|
PrototypeVM.ChangeGoalTree(goalCats, goals);
|
|
}
|
|
if (infoDC != null)
|
|
{
|
|
//_SelectedCustomerNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.ApprovalPeriodList = infoDC.ApprovalPeriods;
|
|
|
|
if (!IsGroupBooking && !IsMultiBooking)
|
|
{
|
|
PrototypeVM.UpdateServiceAccountings(infoDC.ServiceAccountings, _Category2Services, true);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
internal void UpdateGroupServiceAccountings(IList<CompactSupportConceptDC> data)
|
|
{
|
|
if (data != null)
|
|
{
|
|
|
|
var oids = new List<long>();
|
|
|
|
foreach (var item in data)
|
|
{
|
|
oids.Add(item.SupportConceptOid);
|
|
}
|
|
|
|
var allInfos = ServiceFacade.DoOperationsServiceSync(s => s.GetSupportConceptTreeNodeDetailInfos(oids));
|
|
|
|
|
|
UpdateGruppenZiele(allInfos);
|
|
|
|
if (BeWoApp.AppSettings.FilterGroupServiceCategories)
|
|
{
|
|
var serviceAccountings = ErstelleServiceCategorySchnittmenge(allInfos);
|
|
PrototypeVM.UpdateServiceAccountings(serviceAccountings, _Category2Services, true);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private void UpdateGruppenZiele(List<SupportConceptTreeNodeDetailInfoDC> allInfos)
|
|
{
|
|
if (allInfos != null && _AllGoalCategories != null)
|
|
{
|
|
var goalCats = new List<ValueListEntryDC>();
|
|
var goals = new List<ValueListEntryDC>();
|
|
|
|
var goalCategoryDict = _AllGoalCategories.ToDictionary(goalCat => goalCat.ValueListEntryOid.Value);
|
|
|
|
foreach (var info in allInfos)
|
|
{
|
|
foreach (var goal in info.SupportConceptGoals)
|
|
{
|
|
goal.Prefix = info.CustomerName;
|
|
|
|
if (goal.ParentOid != null && goalCategoryDict.ContainsKey(goal.ParentOid.Value))
|
|
{
|
|
var path = GetAllParentGoalCategoies(goalCategoryDict, goal);
|
|
foreach (var goalCat in path)
|
|
{
|
|
goalCats.Add(goalCat);
|
|
goalCategoryDict.Remove(goalCat.ValueListEntryOid.Value);
|
|
}
|
|
}
|
|
|
|
goals.Add(goal);
|
|
}
|
|
}
|
|
|
|
|
|
PrototypeVM.ChangeGoalTree(goalCats, goals);
|
|
}
|
|
}
|
|
|
|
|
|
private List<ServiceAccountingDC> ErstelleServiceCategorySchnittmenge(List<SupportConceptTreeNodeDetailInfoDC> allInfos)
|
|
{
|
|
|
|
if (allInfos.Count == 0)
|
|
{
|
|
return null;
|
|
}
|
|
else if (allInfos.Count == 1)
|
|
{
|
|
return allInfos[0].ServiceAccountings;
|
|
}
|
|
|
|
var schnittmenge = new List<ServiceAccountingDC>();
|
|
|
|
foreach (var info in allInfos)
|
|
{
|
|
if (info.ServiceAccountings != null && info.ServiceAccountings.Count == 0 && _Category2Services != null)
|
|
{
|
|
foreach (var cat in _Category2Services.Keys)
|
|
{
|
|
if (!cat.OhneHilfeplan.HasValue || (cat.OhneHilfeplan.Value != AccountingvisibilityType.NichtKlientenbezogen && cat.OhneHilfeplan.Value != AccountingvisibilityType.Never))
|
|
{
|
|
var descList = _Category2Services[cat];
|
|
foreach (var desc in descList)
|
|
{
|
|
info.ServiceAccountings.Add(new ServiceAccountingDC { ServiceDescription = desc });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var erster = allInfos[0];
|
|
|
|
foreach (var sa in erster.ServiceAccountings)
|
|
{
|
|
//Prüfe für jeden des ersten ob er auch in allen anderen enthalten ist
|
|
bool istDrin = true;
|
|
for (int i = 1; i < allInfos.Count; i++)
|
|
{
|
|
var info2 = allInfos[i];
|
|
|
|
if (!info2.ServiceAccountings.Exists(sa2 => sa2.ServiceDescription.ServiceDescriptionOid == sa.ServiceDescription.ServiceDescriptionOid))
|
|
{
|
|
istDrin = false;
|
|
}
|
|
|
|
}
|
|
if (istDrin)
|
|
{
|
|
schnittmenge.Add(sa);
|
|
}
|
|
}
|
|
return schnittmenge;
|
|
|
|
}
|
|
|
|
public string GetVisibleInformationString(IEnumerable<ServiceRecordVM> selected_records)
|
|
{
|
|
var current = SelectedCustomerNode;
|
|
var hello = current?.SupportConceptTreeNodeDC;
|
|
var sr = ServiceRecordsForSelectedCustomer;
|
|
|
|
if (current is null)
|
|
return null;
|
|
|
|
var selected = new Dictionary<string, object>
|
|
{
|
|
{ "CostBearerName", current.CostBearerName },
|
|
{ "CustomerName", current.CustomerName },
|
|
{ "SupportConceptDuration", current.SupportConceptName }
|
|
};
|
|
|
|
var records = new List<Dictionary<string, object>>();
|
|
foreach (var record in selected_records)
|
|
{
|
|
var record_dict = new Dictionary<string, object>
|
|
{
|
|
{ "StartDate", record.StartDate },
|
|
{ "EndDate", record.EndDate },
|
|
{ "Duration (Min)", record.Duration },
|
|
{ "Category", record.CategoryString },
|
|
{ "ServiceDescription", record.ServiceDescriptionString },
|
|
{ "Documentation", record.AllNotices },
|
|
{ "Goals", record.GoalString },
|
|
{ "Distance (Meter)", record.DistanceInMeter ?? 0 },
|
|
{ "InsertedOn", record.InsertedOn },
|
|
{ "Betrag", record.Betrag },
|
|
{ "InsertUser", record.InsUser },
|
|
{ "Employee", record.Employee }
|
|
};
|
|
records.Add(record_dict);
|
|
}
|
|
|
|
var dict = new Dictionary<string, object>
|
|
{
|
|
{ "Aktuelle Ansicht", "Zeiterfassung" },
|
|
{ "Selected", selected },
|
|
{ "Zeiterfassungen", records }
|
|
};
|
|
|
|
var json = JsonConvert.SerializeObject(dict);
|
|
//var
|
|
|
|
// var node = ViewModel.SelectedCustomerNode;
|
|
//long c2sOid = 0;
|
|
|
|
//if (node != null && node.SupportConceptTreeNodeDC != null && node.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC != null)
|
|
//{
|
|
// c2sOid = node.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.CostBearer2SupportConceptOid.Value;
|
|
//}
|
|
|
|
//var sr = ViewModel.ServiceRecordsForSelectedCustomer;
|
|
|
|
//var earliestStartDate = sr.Any() ? sr.OrderBy(o => o.StartDate).First().StartDate : DateTime.Now;
|
|
//var latestEndDate = sr.Any()
|
|
// ? sr.OrderByDescending(o => o.EndDate).First().EndDate
|
|
// : DateTime.Now.AddSeconds(1);
|
|
|
|
//if (latestEndDate.Hour == 0 && latestEndDate.Minute == 0 && latestEndDate.Second == 1)
|
|
//{
|
|
// latestEndDate = latestEndDate.AddHours(23);
|
|
// latestEndDate = latestEndDate.AddMinutes(59);
|
|
//}
|
|
|
|
//AiChatController.ShowAiChatViewForServiceRecords(c2sOid, earliestStartDate, latestEndDate, Math.Min(800, this.ActualHeight), Math.Min(1200, this.ActualWidth));
|
|
|
|
return json;
|
|
}
|
|
}
|
|
} |