Lyndon Jetten
23b8757ff5
ownChat: Neues TimeStamp-Objekt wird unterstützt und der Chat funktioniert wieder.
1751 lines
69 KiB
C#
1751 lines
69 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Controls.Primitives;
|
|
using System.Windows.Documents;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using System.Windows.Media.Animation;
|
|
using System.Windows.Navigation;
|
|
using System.Windows.Threading;
|
|
|
|
using BeWo.Core;
|
|
using BeWo.Core.Service;
|
|
using BeWo.ServiceProxy;
|
|
using BeWo.Validation;
|
|
using BeWo.View.Controls;
|
|
using BeWo.View.Detail.Zeiterfassung;
|
|
using BeWo.ViewModel;
|
|
using BeWo.ViewModel.ListViewModel;
|
|
|
|
using BS.Shared;
|
|
using BS.Shared.Core;
|
|
using BS.Shared.DataContracts;
|
|
using BS.Shared.DataContracts.Compact;
|
|
using BS.Shared.Extensions;
|
|
using BS.Shared.Translation;
|
|
using DevExpress.Xpf.Bars;
|
|
using DevExpress.Xpf.Docking;
|
|
using DevExpress.Xpf.Editors;
|
|
using DevExpress.Xpf.Grid;
|
|
|
|
using Microsoft.Win32;
|
|
|
|
using DependencyObject = System.Windows.DependencyObject;
|
|
|
|
namespace BeWo.View.Detail
|
|
{
|
|
public partial class AdditionalServiceView : INotifyPropertyChanged
|
|
{
|
|
public static Visibility InsertedOnAndByVisibility
|
|
{
|
|
get
|
|
{
|
|
return BeWoApp.AppSettings.HideServiceRecordInsertedByAndInsertedOn ? Visibility.Collapsed : Visibility.Visible;
|
|
}
|
|
}
|
|
|
|
private AdditionalServiceGroupOfPeopleView _AdditionalServiceGroupOfPeoplePopUp;
|
|
|
|
private readonly Dictionary<DayOfWeek, CheckBox> _DayBoxes = new Dictionary<DayOfWeek, CheckBox>();
|
|
|
|
private CompactEmployeeDC _SelectedEmployee;
|
|
|
|
private ServiceRecordListVM _ViewModel;
|
|
|
|
private readonly AssessmentSheetEntryView _AssessmentSheet;
|
|
|
|
private readonly Dictionary<long, CompactCustomerDC> _Oid2CustomerDict;
|
|
|
|
private readonly bool _disableTeilnehmerUpdate;
|
|
|
|
public AdditionalServiceView(ServiceRecordListVM pViewModel, IEnumerable<CompactCustomerDC> allCustomerList)
|
|
{
|
|
_disableTeilnehmerUpdate = true;
|
|
InitializeComponent();
|
|
|
|
AdditionalServiceBookings = new AdditionalServiceBookingListVM(new List<AdditionalServiceBookingDC>());
|
|
|
|
MultiAddServGroupOfPeopleSelectionControl.EditGroupButtonClicked += multiAddServGroupOfPeopleSelectionControl_EditGroupButtonClicked;
|
|
PopupContent.Visibility = Visibility.Hidden;
|
|
_Oid2CustomerDict = new Dictionary<long, CompactCustomerDC>();
|
|
if (allCustomerList != null)
|
|
{
|
|
foreach (var cdc in allCustomerList)
|
|
{
|
|
_Oid2CustomerDict.Add(cdc.CustomerOid, cdc);
|
|
}
|
|
}
|
|
|
|
ViewModel = pViewModel;
|
|
ViewModel.ShowOnlyAdditionalServiceRecords = true;
|
|
|
|
DownloadLinkEngine = new DownloadLinkEngine();
|
|
LinkExcelExport.NavigateUri = DownloadLinkEngine.GenerateNewExcelLink();
|
|
|
|
ComboboxServices.SelectionChanged += (s, e) =>
|
|
{
|
|
// TODO: löst das OnSelectionChanged-Event der NullItemCombobox-Klasse aus, die wiederum dieses Event auslöst und es letztendlich zum Stack Overflow kommt
|
|
if(ComboboxServices.SelectedIndex == -1)
|
|
{
|
|
ComboboxServices.SelectedIndex = 0;
|
|
}
|
|
};
|
|
|
|
InitDayCheckBoxes();
|
|
|
|
if (BeWoApp.LoggedOnUser.HasRight(UserRightType.AssessmentSheet_View))
|
|
{
|
|
_AssessmentSheet = new AssessmentSheetEntryView();
|
|
PunktebogenRootGrid.Children.Clear();
|
|
PunktebogenRootGrid.Children.Add(_AssessmentSheet);
|
|
_AssessmentSheet.Visibility = Visibility.Collapsed;
|
|
}
|
|
else
|
|
{
|
|
PunktebogenRootGrid.Visibility = Visibility.Collapsed;
|
|
}
|
|
|
|
MultiEmployeeControlAddServ.SelectedEmployees.CollectionChanged += multiEmployeeAddServ_CollectionChanged;
|
|
|
|
ReloadAdditionalServiceRelatedObjects();
|
|
|
|
Years = new int[10];
|
|
for (var i = (Years.Length - 1); i > -1; i--)
|
|
Years[i] = DateTime.Now.Year - i;
|
|
|
|
MonatsCombobox.DataContext = this;
|
|
JahresCombobox.DataContext = this;
|
|
TeilnahmeGrid.DataContext = this;
|
|
|
|
SelectedYear = Years[0];
|
|
SelectedMonth = (Monat) DateTime.Now.Month;
|
|
|
|
MonatsCombobox.SelectedIndex = 0;
|
|
JahresCombobox.SelectedIndex = 0;
|
|
|
|
SaveBtn.IsEnabled = false;
|
|
|
|
//SupportConceptSelectionControl.SupportConceptList = new List<CompactSupportConceptDC>();
|
|
|
|
//this.Dispatch(() => Cache.GetInstance().GetAllActiveSupportConceptsCompact(x => this.Dispatch(() => { SupportConceptSelectionControl.SupportConceptList = x; })));
|
|
ServiceFacade.DoEmployeeServiceSync(e => MultiEmployeeControlAddServ.SelectedEmployees.Add(e.LoadCompactEmployee(BeWoApp.LoggedOnEmployee.EmployeeOid.Value)));
|
|
|
|
_SelectedEmployee = MultiEmployeeControlAddServ.SelectedEmployees.First();
|
|
|
|
_disableTeilnehmerUpdate = false;
|
|
}
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
void multiEmployeeAddServ_CollectionChanged(object sender, EventArgs e)
|
|
{
|
|
AdditionalServiceBookings.NewVM.EmployeeOidList = MultiEmployeeControlAddServ.SelectedEmployees.Select(emp => emp.EmployeeOid).ToList();
|
|
if (AdditionalServiceBookings.NewVM.EmployeeOidList.Count <= 0)
|
|
return;
|
|
|
|
//_SelectedEmployee = AdditionalServiceBookings.NewVM.EmployeeOidList.First();
|
|
//PopupeditEmployee.Text = _SelectedEmployee.ToString();
|
|
//_SelectedEmployee = null;
|
|
//PopupeditEmployee.Text = AdditionalServiceBookings.NewVM.EmployeeOidList.First().ToString();
|
|
|
|
}
|
|
|
|
public override bool CanDelete
|
|
{
|
|
get { return false; }
|
|
}
|
|
|
|
public List<AdditionalServiceDC> AdditionalServices { get; set; }
|
|
public List<AdditionalServiceRegionDC> AdditionalServiceRegions { get; set; }
|
|
|
|
public AdditionalServiceBookingListVM AdditionalServiceBookings { get; set; }
|
|
|
|
public List<AdditionalServiceNoticeDC> AdditionalServiceNoticeList { get; set; }
|
|
|
|
public int GridColumnCount { get; set; }
|
|
|
|
public int[] Years { get; set; }
|
|
private int _SelectedYear;
|
|
public int SelectedYear
|
|
{
|
|
get { return _SelectedYear; }
|
|
set
|
|
{
|
|
_SelectedYear = value;
|
|
|
|
if ((int) SelectedMonth == 0)
|
|
return;
|
|
|
|
ShouldGridBeSaved();
|
|
GridColumnCount = DateTime.DaysInMonth(value, (int)SelectedMonth);
|
|
UpdateTeilnahmeGrid();
|
|
}
|
|
}
|
|
|
|
private Monat _SelectedMonth;
|
|
public Monat SelectedMonth
|
|
{
|
|
get { return _SelectedMonth; }
|
|
set
|
|
{
|
|
ShouldGridBeSaved();
|
|
|
|
_SelectedMonth = value;
|
|
GridColumnCount = DateTime.DaysInMonth(SelectedYear, (int)value);
|
|
UpdateTeilnahmeGrid();
|
|
}
|
|
}
|
|
|
|
private List<Teilnehmer> _TeilnehmerListe;
|
|
public List<Teilnehmer> TeilnehmerListe
|
|
{
|
|
get
|
|
{
|
|
if(_TeilnehmerListe!=null)
|
|
_TeilnehmerListe.Sort((x, y) => x.Customer.LastNameFirstName.CompareTo(y.Customer.LastNameFirstName));
|
|
|
|
return _TeilnehmerListe ?? (_TeilnehmerListe = new List<Teilnehmer>());
|
|
}
|
|
set
|
|
{
|
|
_TeilnehmerListe = value;
|
|
OnPropertyChanged("TeilnehmerListe");
|
|
}
|
|
}
|
|
|
|
private List<AdditionalServiceBookingVM> _SelectedBookings;
|
|
public List<AdditionalServiceBookingVM> SelectedBookings
|
|
{
|
|
get { return _SelectedBookings; }
|
|
set
|
|
{
|
|
_SelectedBookings = value;
|
|
OnPropertyChanged("SelectedBookings");
|
|
}
|
|
}
|
|
|
|
internal void UpdateTeilnahmeGrid()
|
|
{
|
|
if (!_disableTeilnehmerUpdate)
|
|
{
|
|
ReloadAdditionalServiceBookings();
|
|
|
|
|
|
if (Angebotscombobox.SelectedItem == null)
|
|
return;
|
|
|
|
SelectedBookings =
|
|
AdditionalServiceBookings.VMList.Where(
|
|
asb =>
|
|
asb.AdditionalServiceRegion.AdditionalServiceRegionOid.Equals(
|
|
(Angebotscombobox.SelectedItem as AdditionalServiceRegionDC).AdditionalServiceRegionOid) &&
|
|
asb.Date.Year == SelectedYear &&
|
|
asb.Date.Month == (int) SelectedMonth).ToList();
|
|
|
|
TeilnehmerListe = new List<Teilnehmer>();
|
|
|
|
foreach (var booking in SelectedBookings)
|
|
{
|
|
foreach (var teilnehmer in booking.CustomerOidDict)
|
|
{
|
|
if (teilnehmer.Key == 547)
|
|
{
|
|
int test = 0;
|
|
}
|
|
var bookingRel = new Dictionary<long, BookingRelationDictionaryValue>();
|
|
var index = -1;
|
|
var anwesenheiten = new bool[GridColumnCount];
|
|
|
|
if (TeilnehmerListe.Any(t => t.Customer.CustomerOid.Equals(teilnehmer.Key)))
|
|
{
|
|
var x = TeilnehmerListe.Where(t => t.Customer.CustomerOid.Equals(teilnehmer.Key)).ToList();
|
|
anwesenheiten = x.First().TeilnahmenForUpdating;
|
|
}
|
|
|
|
anwesenheiten[booking.Date.Day - 1] = teilnehmer.Value;
|
|
|
|
|
|
foreach (var item in TeilnehmerListe.Where(item => item.Customer.CustomerOid.Equals(teilnehmer.Key)))
|
|
{
|
|
index = TeilnehmerListe.IndexOf(item);
|
|
foreach (var element in item.BookingRelation.Where(element => !bookingRel.ContainsKey(element.Key)))
|
|
bookingRel.Add(element.Key, element.Value);
|
|
}
|
|
|
|
if (!bookingRel.ContainsKey(booking.DataContract.AdditionalServiceBookingOid.Value))
|
|
bookingRel.Add(booking.DataContract.AdditionalServiceBookingOid.Value,
|
|
new BookingRelationDictionaryValue(booking.Date, booking.StartDate.Value, booking.EndDate.Value));
|
|
|
|
if (index >= 0)
|
|
TeilnehmerListe.RemoveAt(index);
|
|
|
|
CompactCustomerDC customer = null;
|
|
if (_Oid2CustomerDict.ContainsKey(teilnehmer.Key))
|
|
{
|
|
customer = _Oid2CustomerDict[teilnehmer.Key];
|
|
}
|
|
if (customer == null)
|
|
{
|
|
customer = new CompactCustomerDC {CustomerOid = 0, FirstName = "Gelöscht", AbsenceTimes = new List<AbsenceTimeDC>()};
|
|
}
|
|
//else if (customer.LastName == "Shakaev")
|
|
//{
|
|
// int test = 0;
|
|
//}
|
|
|
|
//Notice raussuchen
|
|
var region = Angebotscombobox.SelectedItem as AdditionalServiceRegionDC;
|
|
|
|
AdditionalServiceNoticeDC notice = null;
|
|
if (region != null && customer != null)
|
|
{
|
|
notice = AdditionalServiceNoticeList.Where(n => n.RegionOid == region.AdditionalServiceRegionOid && n.CustomerOid == customer.CustomerOid).FirstOrDefault();
|
|
}
|
|
if (notice == null)
|
|
{
|
|
notice = new AdditionalServiceNoticeDC();
|
|
notice.Monat = new DateTime(booking.StartDate.Value.Year, booking.StartDate.Value.Month, 1);
|
|
notice.RegionOid = region?.AdditionalServiceRegionOid;
|
|
notice.CustomerOid = customer?.Oid;
|
|
}
|
|
|
|
|
|
TeilnehmerListe.Add(new Teilnehmer(customer, anwesenheiten, bookingRel, notice));
|
|
|
|
var klienten = new Dictionary<long, bool>();
|
|
foreach (var test2 in TeilnehmerListe)
|
|
{
|
|
if (!klienten.ContainsKey(test2.Customer.CustomerOid))
|
|
{
|
|
klienten.Add(test2.Customer.CustomerOid, true);
|
|
}
|
|
else
|
|
{
|
|
//Fehler
|
|
int test = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var monthInt = (int) SelectedMonth;
|
|
var daysInMonth = DateTime.DaysInMonth(SelectedYear, monthInt);
|
|
T28.Visible = daysInMonth >= 29;
|
|
T29.Visible = daysInMonth >= 30;
|
|
T30.Visible = daysInMonth == 31;
|
|
|
|
TeilnahmeGrid.ItemsSource = TeilnehmerListe;
|
|
TeilnahmeGrid.RefreshData();
|
|
|
|
foreach (var item in TeilnahmeGrid.Columns)
|
|
{
|
|
var swap = item.Header.ToString();
|
|
item.Header = "";
|
|
item.Header = swap;
|
|
}
|
|
|
|
UpdateAdditionalServiceReportUrl();
|
|
}
|
|
}
|
|
|
|
protected virtual void OnPropertyChanged(string propertyName = null)
|
|
{
|
|
var handler = PropertyChanged;
|
|
if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
|
|
private void gridView1_DoubleClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var selectedCustomer = ((sender as TableView).Grid.GetFocusedRow() as Teilnehmer).Customer;
|
|
|
|
if(selectedCustomer != null)
|
|
VMFactory.CreateCustomerVMAsync(selectedCustomer.CustomerOid, cb => this.Dispatch(
|
|
() => BeWoUtils.OpenModalViewWindow<CustomerVM, CustomerDC, AdditionalServiceView>(cb, this, () => this.Dispatch(
|
|
() => BeWoUtils.UpdateAllViews(selectedCustomer)))));
|
|
}
|
|
|
|
private void pg_ShownEditor(object sender, EditorEventArgs e)
|
|
{
|
|
//if (!CheckEditRight())
|
|
//{
|
|
// e.Handled = true;
|
|
// return;
|
|
//}
|
|
|
|
if (!(e.Editor is CheckEdit))
|
|
return;
|
|
|
|
(e.Editor as CheckEdit).Tag = new CheckEditTag(e.Row as Teilnehmer, e.Column);
|
|
(e.Editor as CheckEdit).Unchecked -= checked_changed;
|
|
(e.Editor as CheckEdit).Unchecked += checked_changed;
|
|
(e.Editor as CheckEdit).Checked -= checked_changed;
|
|
(e.Editor as CheckEdit).Checked += checked_changed;
|
|
}
|
|
|
|
private bool CheckEditRight(bool showMessage)
|
|
{
|
|
if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.AdditionalService_Edit))
|
|
{
|
|
if (showMessage)
|
|
{
|
|
MessageBox.Show("Sie besitzen leider nicht das benötigte Recht \"Ergänzenden Dienste bearbeiten\".", "Speichern", MessageBoxButton.OK, MessageBoxImage.Exclamation);
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void GridViewBase_OnHiddenEditor(object sender, EditorEventArgs e)
|
|
{
|
|
if (!(e.Editor is CheckEdit))
|
|
return;
|
|
|
|
(e.Editor as CheckEdit).Unchecked -= checked_changed;
|
|
(e.Editor as CheckEdit).Checked -= checked_changed;
|
|
}
|
|
|
|
private readonly List<AdditionalServiceBookingDC> _BookingsToUpdate = new List<AdditionalServiceBookingDC>();
|
|
private readonly List<AdditionalServiceNoticeDC> _NoticesToUpdate = new List<AdditionalServiceNoticeDC>();
|
|
private readonly List<CompactCustomerDC> _Customer2Delete = new List<CompactCustomerDC>();
|
|
|
|
private void checked_changed(object sender, RoutedEventArgs e)
|
|
{
|
|
var s = sender as CheckEdit;
|
|
var tag = s.Tag as CheckEditTag;
|
|
|
|
try
|
|
{
|
|
var relationList =
|
|
tag.Teilnehmer.BookingRelation.Where(
|
|
b => b.Value.Datum.Equals(new DateTime(SelectedYear, (int) SelectedMonth, tag.GetHeaderAsDay())));
|
|
|
|
var keyList = relationList.Where(i => i.Key > 0 && i.Value.StartDate != DateTime.MinValue).Select(j => j.Key).ToList();
|
|
|
|
//if (kvp.Key == 0 && kvp.Value.StartDate == DateTime.MinValue)
|
|
// return;
|
|
|
|
//key = kvp.Key;
|
|
if (relationList.Any())
|
|
{
|
|
var abList =
|
|
AdditionalServiceBookings.VMList.Where(asb => keyList.Contains(asb.DataContract.AdditionalServiceBookingOid.Value));
|
|
|
|
foreach (var ab in abList)
|
|
{
|
|
ab.CustomerOidDict[tag.Teilnehmer.Customer.CustomerOid] = s.IsChecked.Value;
|
|
|
|
if (!_BookingsToUpdate.Contains(ab.CommitToDataContract()))
|
|
_BookingsToUpdate.Add(ab.CommitToDataContract());
|
|
|
|
SaveBtn.IsEnabled = true;
|
|
}
|
|
}
|
|
|
|
}
|
|
catch (Exception) { return; }
|
|
}
|
|
|
|
private void SaveBookingChanges(object sender, RoutedEventArgs e)
|
|
{
|
|
SaveGridChanges(true);
|
|
}
|
|
|
|
private void SaveGridChanges(bool updateGrid)
|
|
{
|
|
Mouse.OverrideCursor = Cursors.Wait;
|
|
try
|
|
{
|
|
// do stuff
|
|
|
|
if (_BookingsToUpdate.Count == 0 && newShortAddAD.Any())
|
|
{
|
|
ServiceFacade.DoOperationsServiceSync(
|
|
o => o.InsertNewAdditionalServiceBookings(new List<AdditionalServiceBookingDC>(newShortAddAD)));
|
|
|
|
}
|
|
else if (_BookingsToUpdate.Any() && !newShortAddAD.Any())
|
|
{
|
|
ServiceFacade.DoOperationsServiceSync(o => o.UpdateAdditionalServiceBookings(_BookingsToUpdate));
|
|
}
|
|
else if (_BookingsToUpdate.Any() && newShortAddAD.Any())
|
|
{
|
|
ServiceFacade.DoOperationsServiceSync(o => o.UpdateAdditionalServiceBookings(_BookingsToUpdate));
|
|
ServiceFacade.DoOperationsServiceSync(
|
|
o => o.InsertNewAdditionalServiceBookings(new List<AdditionalServiceBookingDC>(newShortAddAD)));
|
|
}
|
|
if (_NoticesToUpdate.Count > 0)
|
|
{
|
|
ServiceFacade.DoOperationsServiceSync(o => o.UpdateAdditionalServiceNoticeList(_NoticesToUpdate));
|
|
}
|
|
if (_Customer2Delete.Count > 0)
|
|
{
|
|
var start = new DateTime(SelectedYear, (int)SelectedMonth, 1);
|
|
var bereich = Angebotscombobox.SelectedItem as AdditionalServiceRegionDC;
|
|
|
|
ServiceFacade.DoOperationsServiceSync(o => o.RemoveAdditionalServiceCustomer(_Customer2Delete.Select(c => c.CustomerOid).ToList(), bereich?.AdditionalServiceRegionOid, start));
|
|
}
|
|
if (updateGrid)
|
|
UpdateTeilnahmeGrid();
|
|
SaveBtn.IsEnabled = false;
|
|
}
|
|
finally
|
|
{
|
|
Mouse.OverrideCursor = null;
|
|
}
|
|
}
|
|
|
|
public DownloadLinkEngine DownloadLinkEngine { get; set; }
|
|
|
|
public override bool IsDirty
|
|
{
|
|
get { return (ViewModel != null && ViewModel.AddedCount != 0) || IsGridDirty(); }
|
|
}
|
|
|
|
public override string Title
|
|
{
|
|
get { return "Ergänzende Dienste"; }
|
|
}
|
|
|
|
public bool WithoutClient
|
|
{
|
|
get { return ViewModel != null && ViewModel.WithoutClient; }
|
|
|
|
set
|
|
{
|
|
if (ViewModel != null)
|
|
ViewModel.WithoutClient = value;
|
|
}
|
|
}
|
|
|
|
internal override DependencyObject ValidationOnSaveRootElement
|
|
{
|
|
get { return SrListBox; }
|
|
}
|
|
|
|
private ServiceRecordListVM ViewModel
|
|
{
|
|
get { return _ViewModel; }
|
|
|
|
set
|
|
{
|
|
_SelectedEmployee = BeWoApp.LoggedOnUser.Employee;
|
|
PopupeditEmployee.Text = _SelectedEmployee.ToString();
|
|
|
|
DataContext = value;
|
|
|
|
_ViewModel = value;
|
|
|
|
_ViewModel.ServiceRecordListChanged += ViewModel_ServiceRecordListChanged;
|
|
|
|
if (!BeWoApp.LoggedOnUser.HasRight(UserRightType.ServiceRecordView_Create) && !BeWoApp.LoggedOnUser.HasRight(UserRightType.CreateAll))
|
|
{
|
|
NewObjectInfoGrid.IsEnabled = false;
|
|
ButtonAdd.IsEnabled = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void AnimateOpacity(double pOpacitiy, double pDuration)
|
|
{
|
|
var lAnimation = new DoubleAnimation
|
|
{From = DetailContentGrid.Opacity, To = pOpacitiy, Duration = TimeSpan.FromMilliseconds(pDuration)};
|
|
|
|
DetailContentGrid.BeginAnimation(OpacityProperty, lAnimation);
|
|
}
|
|
|
|
public override void Delete()
|
|
{
|
|
Delete(GetSelectedServiceRecordFromListBox());
|
|
}
|
|
|
|
public void Delete(ServiceRecordVM vm)
|
|
{
|
|
if (vm == null) return;
|
|
var msg = vm.GroupOid != null ? "ACHTUNG, wenn Sie fortfahren, löschen Sie die gesamte Gruppenbuchung.\nWenn Sie nur einzelne " + Translator.Translate("Klienten") + " aus der Gruppe entfernen möchten,\neditieren Sie die Gruppe und entfernen den Klienten aus der Liste aller Hilfepläne.\nSind Sie sicher, dass Sie dem gesamten Gruppeneintrag löschen möchten?" : "Sind Sie sicher, dass Sie den gewählten Eintrag löschen möchten?";
|
|
|
|
if (MessageBox.Show(msg, "Eintrag löschen", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes)
|
|
{
|
|
if (vm.GroupOid != null)
|
|
{
|
|
List<ServiceRecordVM> deletedVMs = ViewModel.VMList.Where(item => item.GroupOid != null && item.GroupOid.Value == vm.GroupOid.Value).ToList();
|
|
|
|
foreach (var deletedVM in deletedVMs)
|
|
{
|
|
ViewModel.VMList.Remove(deletedVM);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ViewModel.VMList.Remove(vm);
|
|
}
|
|
|
|
var lDC = vm.CommitToDataContract();
|
|
ServiceFacade.DoOperationsServiceAsync(s => s.DeleteServiceRecord(lDC.ServiceRecordOid.Value, lDC.ServiceRecordVersion.Value), RefreshGrid);
|
|
}
|
|
}
|
|
|
|
public ServiceRecordVM GetSelectedServiceRecordFromListBox()
|
|
{
|
|
return (ServiceRecordVM)SrListBox.SelectedItem;
|
|
}
|
|
|
|
public void SetSelectedServiceRecordVM(ServiceRecordVM vm)
|
|
{
|
|
SrListBox.SelectedItem = vm;
|
|
}
|
|
|
|
internal override bool DoSaveCheck()
|
|
{
|
|
if (this.IsDirty)
|
|
{
|
|
MessageBoxResult lResult = this.ShowSaveQuestion();
|
|
if (lResult == MessageBoxResult.Cancel)
|
|
{
|
|
this.Focus();
|
|
return false;
|
|
}
|
|
|
|
if (lResult == MessageBoxResult.Yes)
|
|
{
|
|
this.SaveData();
|
|
SaveGridChanges(false);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//SRV2
|
|
protected override void Save()
|
|
{
|
|
var lToDos = new List<Action<IOperationsService>>();
|
|
|
|
if (ViewModel.AddedCount > 0)
|
|
{
|
|
lToDos.Add(
|
|
s =>
|
|
{
|
|
var newItems = ViewModel.CommitAdded();
|
|
try
|
|
{
|
|
List<long> oids = s.InsertNewServiceRecords(newItems);
|
|
|
|
int idx = 0;
|
|
foreach (ServiceRecordVM vm in ViewModel.VMList)
|
|
{
|
|
if (!vm.IsNew)
|
|
continue;
|
|
|
|
vm.IsNew = false;
|
|
vm.DataContract.ServiceRecordVersion = 1;
|
|
vm.DataContract.ServiceRecordOid = oids[idx++];
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
var newVMs = ViewModel.VMList.Where(vm => vm.IsNew).ToList();
|
|
|
|
foreach (var serviceRecordVm in newVMs)
|
|
ViewModel.VMList.Remove(serviceRecordVm);
|
|
|
|
this.Dispatch(() => ViewModel.RefreshServiceRecordsForSelectedTreeNode(false));
|
|
|
|
throw;
|
|
}
|
|
});
|
|
}
|
|
|
|
ServiceFacade.DoMultipleOperationsServicesSync(lToDos);
|
|
ReloadViewModel();
|
|
}
|
|
|
|
private void ReloadAdditionalServiceRelatedObjects()
|
|
{
|
|
AdditionalServices = ServiceFacade.DoOperationsServiceSync(f => f.GetAllAdditionalService());
|
|
AdditionalServiceRegions = ServiceFacade.DoOperationsServiceSync(adsr => adsr.GetAllAdditionalServiceRegion());
|
|
|
|
GroupBoxAdditionalService.DataContext = this;
|
|
}
|
|
|
|
private void ReloadAdditionalServiceBookings()
|
|
{
|
|
if (newShortAddAD != null)
|
|
newShortAddAD.Clear();
|
|
if (_BookingsToUpdate != null)
|
|
_BookingsToUpdate.Clear();
|
|
if (_NoticesToUpdate != null)
|
|
_NoticesToUpdate.Clear();
|
|
if (_Customer2Delete != null)
|
|
_Customer2Delete.Clear();
|
|
var start = new DateTime(SelectedYear, (int)SelectedMonth, 1);
|
|
var end = start.AddMonths(1);
|
|
|
|
AdditionalServiceBookings.VMList.Clear();
|
|
|
|
long? regionOid = null;
|
|
|
|
if (AdditionalServiceBookings.NewVM.AdditionalServiceRegion != null)
|
|
{
|
|
regionOid = AdditionalServiceBookings.NewVM.AdditionalServiceRegion.AdditionalServiceRegionOid;
|
|
}
|
|
|
|
foreach (var item in ServiceFacade.DoOperationsServiceSync(t => t.GetAllAdditionalServiceBookings(regionOid, start, end)))
|
|
{
|
|
AdditionalServiceBookings.VMList.Add(new AdditionalServiceBookingVM(item));
|
|
}
|
|
|
|
AdditionalServiceBookings.NewVM.AdditionalServiceRegion = (AdditionalServiceRegionDC)Angebotscombobox.SelectedItem;
|
|
|
|
|
|
AdditionalServiceNoticeList = ServiceFacade.DoOperationsServiceSync(t => t.GetAdditionalServiceNoticeList(regionOid, start, end));
|
|
|
|
}
|
|
|
|
private void ClosePopupView()
|
|
{
|
|
SetPopupViewVisible(false);
|
|
PopupContent.Child = null;
|
|
}
|
|
|
|
private void Edit(ServiceRecordVM vm)
|
|
{
|
|
if (vm != null && vm.EditAllowed)
|
|
{
|
|
BeWoView serviceRecordEditView;
|
|
double height = 450;
|
|
const double width = 800;
|
|
if (vm.GroupOid != null)
|
|
{
|
|
serviceRecordEditView = new ServiceRecordGroupEditView();
|
|
}
|
|
else
|
|
{
|
|
serviceRecordEditView = new ServiceRecordEditView();
|
|
}
|
|
|
|
PopupContent.Child = serviceRecordEditView;
|
|
PopupContent.Width = width;
|
|
|
|
if (rootGrid.ActualHeight < height)
|
|
height = rootGrid.ActualHeight;
|
|
|
|
PopupContent.Height = height;
|
|
|
|
if (serviceRecordEditView.CommandBindings.Count == 0)
|
|
{
|
|
serviceRecordEditView.CommandBindings.Add(
|
|
new CommandBinding(
|
|
ApplicationCommands.Close,
|
|
(s, e) =>
|
|
{
|
|
if (!serviceRecordEditView.DoSaveCheck())
|
|
return;
|
|
ClosePopupView();
|
|
ViewModel.RefreshServiceRecordsForSelectedTreeNode(false);
|
|
|
|
SetSelectedServiceRecordVM(vm);
|
|
}));
|
|
serviceRecordEditView.CommandBindings.Add(
|
|
new CommandBinding(
|
|
ApplicationCommands.Save,
|
|
(s, e) =>
|
|
{
|
|
bool save;
|
|
if (serviceRecordEditView is ServiceRecordEditView)
|
|
{
|
|
save = ((ServiceRecordEditView)serviceRecordEditView).IsValid() && ((ServiceRecordEditView)serviceRecordEditView).IsCustomerChangeAllowed();
|
|
}
|
|
else
|
|
save = ((ServiceRecordGroupEditView)serviceRecordEditView).IsValid() && ((ServiceRecordGroupEditView)serviceRecordEditView).IsCustomerChangeAllowed();
|
|
|
|
if (save)
|
|
{
|
|
serviceRecordEditView.SaveData();
|
|
ClosePopupView();
|
|
|
|
if (serviceRecordEditView is ServiceRecordEditView)
|
|
{
|
|
vm.Employee = _SelectedEmployee;
|
|
|
|
ViewModel.RefreshServiceRecordsForSelectedTreeNode(false);
|
|
SetSelectedServiceRecordVM(vm);
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
|
|
if (serviceRecordEditView is ServiceRecordEditView)
|
|
{
|
|
((ServiceRecordEditView) serviceRecordEditView).InitView(ViewModel, vm, WithoutClient);
|
|
serviceRecordEditView.ParentView = this;
|
|
SetPopupViewVisible(true);
|
|
}
|
|
else
|
|
{
|
|
ServiceFacade.DoOperationsServiceAsync(
|
|
s => s.GetServiceRecordGroup(vm.GroupOid.Value),
|
|
r => this.Dispatch(
|
|
delegate
|
|
{
|
|
((ServiceRecordGroupEditView) serviceRecordEditView).InitView(ViewModel, vm, r);
|
|
|
|
serviceRecordEditView.ParentView = this;
|
|
SetPopupViewVisible(true);
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EmployeeSearchView_CustomerSelected(object sender, EventArgs<CompactEmployeeDC> e)
|
|
{
|
|
_SelectedEmployee = e.Data;
|
|
PopupeditEmployee.Text = _SelectedEmployee.ToString();
|
|
PopupEmployee.IsOpen = false;
|
|
|
|
ViewModel.SelectedEmployee = _SelectedEmployee;
|
|
|
|
if (WithoutClient)
|
|
{
|
|
SelectedItemChanged(null);
|
|
}
|
|
}
|
|
|
|
private static TChildItem FindVisualChild<TChildItem>(DependencyObject obj) where TChildItem : DependencyObject
|
|
{
|
|
for (var i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
|
|
{
|
|
var child = VisualTreeHelper.GetChild(obj, i);
|
|
if (child != null && child is TChildItem)
|
|
{
|
|
return (TChildItem) child;
|
|
}
|
|
|
|
var childOfChild = FindVisualChild<TChildItem>(child);
|
|
if (childOfChild != null)
|
|
{
|
|
return childOfChild;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private void InitDayCheckBoxes()
|
|
{
|
|
foreach (var iDay in Utils.GetDayOfWeeks(DayOfWeek.Monday))
|
|
{
|
|
var lCb = new CheckBox
|
|
{
|
|
Content = DateTimeFormatInfo.CurrentInfo.GetAbbreviatedDayName(iDay),
|
|
Margin = new Thickness(3),
|
|
IsHitTestVisible = DateTime.Now.DayOfWeek != iDay,
|
|
};
|
|
|
|
_DayBoxes[iDay] = lCb;
|
|
WrapPanelDays.Visibility = Visibility.Collapsed;
|
|
WrapPanelDays.Children.Add(lCb);
|
|
|
|
lCb.Checked += (s, e) => ViewModel.RecordingDays.Add(_DayBoxes.Single(entry => entry.Value == s).Key);
|
|
lCb.Unchecked += (s, e) => ViewModel.RecordingDays.Remove(_DayBoxes.Single(entry => entry.Value == s).Key);
|
|
|
|
lCb.IsChecked = DateTime.Now.DayOfWeek == iDay;
|
|
}
|
|
|
|
DependencyPropertyDescriptor.FromProperty(BaseEdit.EditValueProperty, typeof (DateEdit)).AddValueChanged(
|
|
DatepickerNewDate,
|
|
(s, e) => _DayBoxes.DoForEach(
|
|
iCheck =>
|
|
{
|
|
iCheck.Value.IsChecked = DatepickerNewDate.EditValue != null &&
|
|
iCheck.Key == DatepickerNewDate.DateTime.DayOfWeek;
|
|
iCheck.Value.IsHitTestVisible = !iCheck.Value.IsChecked.Value;
|
|
iCheck.Value.IsEnabled = iCheck.Value.IsHitTestVisible;
|
|
}));
|
|
}
|
|
|
|
private void GridViewBase_OnCellValueChanging(object sender, CellValueChangedEventArgs e)
|
|
{
|
|
// Das Datum ist der eindeutige Identifikator
|
|
var ausgewaehlterTeilnehmer = (Teilnehmer)e.Row;
|
|
|
|
if (e.Column.FieldName.Contains("Notice"))
|
|
{
|
|
if (e.Value == null)
|
|
{
|
|
ausgewaehlterTeilnehmer.Notice.Notice = "";
|
|
}
|
|
else
|
|
{
|
|
ausgewaehlterTeilnehmer.Notice.Notice = e.Value.ToString();
|
|
}
|
|
|
|
|
|
_NoticesToUpdate.Add(ausgewaehlterTeilnehmer.Notice);
|
|
}
|
|
else
|
|
{
|
|
|
|
var tableView = (TableView)sender;
|
|
var spalten = (List<Teilnehmer>)tableView.Grid.ItemsSource;
|
|
var alleTeilnehmer = spalten.Select(s => s.Customer);
|
|
|
|
|
|
var ausgewaehlterTag = Convert.ToInt32(e.Column.Header.ToString().Split('.')[0]);
|
|
var ausgewaehltesDatum = new DateTime(SelectedYear, (int)_SelectedMonth, ausgewaehlterTag);
|
|
|
|
var existiert = ausgewaehlterTeilnehmer.BookingRelation.Any(br => br.Value.Datum.Equals(ausgewaehltesDatum));
|
|
if (existiert) return;
|
|
|
|
if (_SelectedBookings.Any(vm => vm.Date.Equals(ausgewaehltesDatum)))
|
|
{
|
|
var btu = _SelectedBookings.First(vm => vm.Date.Equals(ausgewaehltesDatum));
|
|
if (btu.CustomerOidDict.ContainsKey(ausgewaehlterTeilnehmer.Customer.CustomerOid))
|
|
btu.CustomerOidDict.Remove(ausgewaehlterTeilnehmer.Customer.CustomerOid);
|
|
btu.CustomerOidDict.Add(ausgewaehlterTeilnehmer.Customer.CustomerOid, Convert.ToBoolean(e.Value));
|
|
_BookingsToUpdate.Add(btu.CommitToDataContract());
|
|
SaveBtn.IsEnabled = true;
|
|
return;
|
|
}
|
|
|
|
if (newShortAddAD.Any(ad => ad.Date.Equals(ausgewaehltesDatum)))
|
|
{
|
|
newShortAddAD.First(ad => ad.Date.Equals(ausgewaehltesDatum)).CustomerOidDict[ausgewaehlterTeilnehmer.Customer.CustomerOid] = Convert.ToBoolean(e.Value);
|
|
return;
|
|
}
|
|
|
|
var mitarbeiter = MultiEmployeeControlAddServ.SelectedEmployees.Select(emp => emp.EmployeeOid).ToList();
|
|
var temp = alleTeilnehmer.ToList();
|
|
|
|
|
|
//Dictionary<long, bool> klienten = new Dictionary<long, bool>();
|
|
//foreach (var customer in alleTeilnehmer)
|
|
//{
|
|
// if (!klienten.ContainsKey(customer.CustomerOid))
|
|
// {
|
|
// klienten.Add(customer.CustomerOid, customer.Equals(ausgewaehlterTeilnehmer.Customer) && Convert.ToBoolean(e.Value));
|
|
// }
|
|
// else
|
|
// {
|
|
// //Fehler
|
|
// //int test = 0;
|
|
// }
|
|
//}
|
|
var klienten = new Dictionary<long, bool>();
|
|
foreach (var teilnehmer in alleTeilnehmer)
|
|
{
|
|
if (teilnehmer.CustomerOid == 0)
|
|
{
|
|
int test = 0;
|
|
}
|
|
if (!klienten.ContainsKey(teilnehmer.CustomerOid))
|
|
{
|
|
klienten.Add(teilnehmer.CustomerOid, teilnehmer.Equals(ausgewaehlterTeilnehmer.Customer) && Convert.ToBoolean(e.Value));
|
|
}
|
|
|
|
}
|
|
//var klienten = alleTeilnehmer.ToDictionary(teilnehmer => teilnehmer.CustomerOid, teilnehmer => (teilnehmer.Equals(ausgewaehlterTeilnehmer.Customer) && Convert.ToBoolean(e.Value)));
|
|
var bereich = (AdditionalServiceRegionDC)Angebotscombobox.SelectedItem;
|
|
var neueBuchung = new AdditionalServiceBookingDC
|
|
{
|
|
AdditionalServiceRegion = bereich,
|
|
CustomerOidDict = klienten,
|
|
EmployeeOidList = mitarbeiter,
|
|
Date = ausgewaehltesDatum,
|
|
StartDate = ausgewaehltesDatum,
|
|
EndDate = ausgewaehltesDatum.AddHours(23).AddMinutes(59).AddSeconds(59)
|
|
};
|
|
|
|
if (neueBuchung.EndDate.HasValue && neueBuchung.StartDate.HasValue)
|
|
{
|
|
var roundedDuration = Convert.ToDecimal((neueBuchung.EndDate.Value - neueBuchung.StartDate.Value).GetTotalMinutes());
|
|
neueBuchung.RoundedDuration = roundedDuration;
|
|
}
|
|
|
|
newShortAddAD.Add(neueBuchung);
|
|
}
|
|
SaveBtn.IsEnabled = true;
|
|
}
|
|
|
|
private readonly List<AdditionalServiceBookingDC> newShortAddAD = new List<AdditionalServiceBookingDC>();
|
|
|
|
private static bool IsPartOf(object p, Type type)
|
|
{
|
|
if (p != null)
|
|
{
|
|
var fe = p as FrameworkElement;
|
|
if (fe != null)
|
|
return fe.GetType() == type || IsPartOf(fe.TemplatedParent, type);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void RefreshGrid()
|
|
{
|
|
Dispatcher.BeginInvoke(
|
|
DispatcherPriority.Normal,
|
|
(Action)delegate
|
|
{
|
|
var selected = GetSelectedServiceRecordFromListBox();
|
|
ViewModel.RefreshServiceRecordsForSelectedTreeNode(false);
|
|
SetSelectedServiceRecordVM(selected);
|
|
});
|
|
}
|
|
|
|
private void ReloadViewModel()
|
|
{
|
|
ViewModel.PrototypeVM.Notice = string.Empty;
|
|
if (ViewModel.PrototypeVM.GoalTree != null && ViewModel.PrototypeVM.GoalTree.Count > 0)
|
|
foreach (var child in from item in ViewModel.PrototypeVM.GoalTree from child in item.Children where child.IsChecked select child)
|
|
child.IsChecked = false;
|
|
}
|
|
|
|
private void SelectedItemChanged(FlatSupportConceptTreeNodeDC selectedNode)
|
|
{
|
|
if (ViewModel != null)
|
|
{
|
|
UpdateAssessmentSheet(selectedNode);
|
|
|
|
ViewModel.ChangeTreeItemSelection(selectedNode);
|
|
SrListBox.SelectedIndex = -1;
|
|
|
|
var sv = FindVisualChild<ScrollViewer>(SrListBox);
|
|
if (sv != null)
|
|
sv.ScrollToTop();
|
|
|
|
UpdateServiceRecordListReportUrl(selectedNode);
|
|
}
|
|
}
|
|
|
|
private void SetPopupViewVisible(bool visible)
|
|
{
|
|
PopupContent.Visibility = visible ? Visibility.Visible : Visibility.Hidden;
|
|
|
|
if (visible)
|
|
AnimateOpacity(0.5, 200);
|
|
else
|
|
AnimateOpacity(1, 100);
|
|
}
|
|
|
|
private void TextBox_GotFocus(object sender, RoutedEventArgs e)
|
|
{
|
|
var vm = ((TextBox)sender).Tag as ServiceRecordVM;
|
|
if (vm != null)
|
|
SrListBox.SelectedItem = vm;
|
|
}
|
|
|
|
private void UpdateServiceRecordListReportUrl(FlatSupportConceptTreeNodeDC selectedNode)
|
|
{
|
|
long scOid = 0;
|
|
long cOid = 0;
|
|
long cb2scOid = 0;
|
|
var eOid = BeWoApp.LoggedOnUser.Employee.EmployeeOid;
|
|
|
|
if (selectedNode != null && selectedNode.SupportConceptTreeNodeDC != null)
|
|
{
|
|
if (selectedNode.SupportConceptTreeNodeDC.SupportConcept != null)
|
|
{
|
|
scOid = selectedNode.SupportConceptTreeNodeDC.SupportConcept.SupportConceptOid;
|
|
}
|
|
|
|
if (selectedNode.SupportConceptTreeNodeDC.Customer != null)
|
|
{
|
|
cOid = selectedNode.SupportConceptTreeNodeDC.Customer.CustomerOid;
|
|
}
|
|
|
|
if (selectedNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC != null)
|
|
{
|
|
cb2scOid = selectedNode.SupportConceptTreeNodeDC.SupportConceptCostBearerRelDC.CostBearer2SupportConceptOid.Value;
|
|
}
|
|
}
|
|
|
|
|
|
var url = BeWoApp.SiteOfOrigin + "/ReportView.aspx" + "?eOid=" + eOid + "&scOid=" + scOid + "&cOid=" + cOid + "&cb2scOid=" + cb2scOid + "&type=" + Utils.EnumName(ReportTypes.ServiceRecordList);
|
|
|
|
url = BeWoWpfUtils.GetHTMLEncodedURL(url);
|
|
|
|
LinkPdfExport.NavigateUri = new Uri(url);
|
|
}
|
|
|
|
private bool ValidateAdditionalServiceBookings()
|
|
{
|
|
const bool lValid = true;
|
|
|
|
if (AdditionalServiceBookings.NewVM.CustomerOidDict.Count == 0)
|
|
{
|
|
MessageBox.Show("Bitte wählen Sie mindestens " + Translator.Translate("einen Klienten") + "aus, für " + Translator.Translate("den") + " dieses Angebot gebucht werden soll.",
|
|
"Buchen nicht möglich",
|
|
MessageBoxButton.OK,
|
|
MessageBoxImage.Information);
|
|
return false;
|
|
}
|
|
|
|
if (AdditionalServiceBookings.NewVM.EmployeeOidList.Count == 0)
|
|
{
|
|
MessageBox.Show(Translator.Translate("Bitte wählen Sie mindestens einen Mitarbeiter aus, für den dieses Angebot gebucht werden soll."),
|
|
"Buchen nicht möglich",
|
|
MessageBoxButton.OK,
|
|
MessageBoxImage.Information);
|
|
return false;
|
|
}
|
|
|
|
var customerOids = new List<long>();
|
|
|
|
AdditionalServiceBookings.NewVM.CustomerOidDict.Keys.DoForEach(c => customerOids.Add(c));
|
|
|
|
if (ServiceFacade.DoOperationsServiceSync(b =>
|
|
b.OverlapsWithAnotherAdditionalServiceBooking(
|
|
AdditionalServiceBookings.NewVM.AdditionalServiceRegion.AdditionalServiceRegionOid.Value, customerOids,
|
|
AdditionalServiceBookings.NewVM.Date)))
|
|
{
|
|
if (MessageBox.Show(
|
|
"An dem ausgewählten Tag existiert bereits eine Buchung. Möchten Sie trotzdem buchen?",
|
|
"Buchen", MessageBoxButton.YesNo, MessageBoxImage.Information).Equals(MessageBoxResult.No))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return lValid;
|
|
}
|
|
|
|
private void ViewModel_ServiceRecordListChanged(object sender, EventArgs e)
|
|
{
|
|
var list = _ViewModel.ServiceRecordsForSelectedCustomer.OrderByDescending(srVM => srVM.StartDate).ToList();
|
|
|
|
SrListBox.ItemsSource = list;
|
|
|
|
if (_AssessmentSheet != null)
|
|
{
|
|
_AssessmentSheet.ServiceRecords = list;
|
|
}
|
|
}
|
|
|
|
private void btnDelete_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var vm = ((Button)sender).Tag as ServiceRecordVM;
|
|
if (vm != null)
|
|
SrListBox.SelectedItem = vm;
|
|
|
|
Delete();
|
|
}
|
|
|
|
private void btnEdit_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var vm = ((Button)sender).Tag as ServiceRecordVM;
|
|
|
|
if (vm != null)
|
|
SrListBox.SelectedItem = vm;
|
|
|
|
Edit(GetSelectedServiceRecordFromListBox());
|
|
}
|
|
|
|
private void button_ADadd_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if (!CheckEditRight(true))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (AdditionalServiceBookings.NewVM == null ||
|
|
AdditionalServiceBookings.NewVM.CustomerOidDict == null)
|
|
return;
|
|
|
|
var mitarbeiter = MultiEmployeeControlAddServ.SelectedEmployees;
|
|
var klienten = MultiAddServGroupOfPeopleSelectionControl.CurrentGroup.CustomerList;
|
|
|
|
//ReloadAdditionalServiceRelatedObjects();
|
|
|
|
if (!ValidateAdditionalServiceBookings())
|
|
return;
|
|
|
|
var lToDos = new List<Action<IOperationsService>>();
|
|
|
|
AdditionalServiceBookings.AddNewVMToList();
|
|
|
|
if (AdditionalServiceBookings.AddedCount > 0)
|
|
{
|
|
lToDos.Add(
|
|
s =>
|
|
{
|
|
var newItems = AdditionalServiceBookings.CommitAdded();
|
|
try
|
|
{
|
|
var oids = s.InsertNewAdditionalServiceBookings(newItems);
|
|
|
|
var idx = 0;
|
|
foreach (var vm in AdditionalServiceBookings.VMList.Where(vm => vm.IsNew))
|
|
{
|
|
vm.IsNew = false;
|
|
vm.DataContract.AdditionalServiceBookingVersion = 1;
|
|
vm.DataContract.AdditionalServiceBookingOid = oids[idx++];
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
var newVMs = AdditionalServiceBookings.VMList.Where(vm => vm.IsNew).ToList();
|
|
|
|
foreach (var additionalServiceBookingVM in newVMs)
|
|
AdditionalServiceBookings.VMList.Remove(additionalServiceBookingVM);
|
|
|
|
throw;
|
|
}
|
|
});
|
|
}
|
|
|
|
ServiceFacade.DoMultipleOperationsServicesAsync(lToDos, () =>
|
|
{
|
|
//AdditionalServiceBookings.VMList.Clear();
|
|
|
|
//foreach (var item in ServiceFacade.DoOperationsServiceSync(t => t.GetAllAdditionalServiceBookings()))
|
|
// AdditionalServiceBookings.VMList.Add(new AdditionalServiceBookingVM(item));
|
|
|
|
AdditionalServiceBookings.NewVM.EmployeeOidList =
|
|
MultiEmployeeControlAddServ.SelectedEmployees.Select(emp => emp.EmployeeOid).ToList();
|
|
this.Dispatch(
|
|
delegate
|
|
{
|
|
AdditionalServiceBookings.NewVM.CustomerOidDict = MultiAddServGroupOfPeopleSelectionControl.CurrentGroup.CustomerList.ToDictionary(customer => customer.CustomerOid, customer => true);
|
|
UpdateAngebotsCombobox();
|
|
UpdateTeilnahmeGrid();
|
|
});
|
|
});
|
|
}
|
|
|
|
private void BereichsComboboxChange(object sender, RoutedEventArgs e)
|
|
{
|
|
Bereichscombobox.DataContext = this;
|
|
|
|
if (Bereichscombobox.SelectedItem == null)
|
|
Bereichscombobox.SelectedItem = AdditionalServices.ElementAt(0);
|
|
|
|
UpdateAngebotsCombobox();
|
|
}
|
|
|
|
private void UpdateAngebotsCombobox()
|
|
{
|
|
var ASRDCs = AdditionalServiceRegions.Where( id => id.AdditionalServiceOid == ((AdditionalServiceDC) Bereichscombobox.SelectedItem).AdditionalServiceOid).ToList();
|
|
|
|
var gleich = false;
|
|
var liste = Angebotscombobox.ItemsSource as List<AdditionalServiceRegionDC>;
|
|
|
|
if(Angebotscombobox.ItemsSource != null && (liste.Count == ASRDCs.Count))
|
|
for (int i = 0; i < ASRDCs.Count; i++)
|
|
gleich = liste[i].Equals(ASRDCs[i]);
|
|
|
|
if (Angebotscombobox.ItemsSource == null || !gleich)
|
|
Angebotscombobox.ItemsSource = ASRDCs;
|
|
|
|
if (ASRDCs.Any() && Angebotscombobox.SelectedItem == null)
|
|
Angebotscombobox.SelectedItem = AdditionalServiceRegions.Where(id => id.AdditionalServiceOid == ((AdditionalServiceDC) Bereichscombobox.SelectedItem).AdditionalServiceOid).ElementAt(0);
|
|
|
|
if (Angebotscombobox.SelectedItem != null)
|
|
AdditionalServiceBookings.NewVM.AdditionalServiceRegion = (AdditionalServiceRegionDC)Angebotscombobox.SelectedItem;
|
|
}
|
|
|
|
private void AngebotsComboboxChange(object sender, RoutedEventArgs e)
|
|
{
|
|
|
|
//SelectionChangedEventArgs args = e as SelectionChangedEventArgs;
|
|
//var added = args.AddedItems;
|
|
//var removed = args.RemovedItems;
|
|
|
|
ShouldGridBeSaved();
|
|
|
|
if (Angebotscombobox.SelectedItem == null)
|
|
return;
|
|
|
|
AdditionalServiceBookings.NewVM.AdditionalServiceRegion = (AdditionalServiceRegionDC)Angebotscombobox.SelectedItem;
|
|
|
|
UpdateTeilnahmeGrid();
|
|
}
|
|
|
|
private bool ShouldGridBeSaved()
|
|
{
|
|
if (IsGridDirty())
|
|
{
|
|
//var ret = MessageBox.Show("Wollen Sie die Änderungen speichern?", "Änderungen speichern",
|
|
// MessageBoxButton.YesNo, MessageBoxImage.Question);
|
|
|
|
//if (ret == MessageBoxResult.No)
|
|
// return false;
|
|
|
|
SaveGridChanges(false);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool IsGridDirty()
|
|
{
|
|
return _BookingsToUpdate.Count > 0 || newShortAddAD.Any() || _NoticesToUpdate.Count > 0 || _Customer2Delete.Count > 0;
|
|
}
|
|
|
|
private void button_add_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var lValid = ValidationTrigger.Validate(root);
|
|
|
|
if (lValid)
|
|
{
|
|
lValid = SaveSingleBooking();
|
|
|
|
ComboBoxTreeViewControl.ResetControl();
|
|
ComboBoxTreeViewControl.TreeViewSourceList = ViewModel.PrototypeVM.GoalTree;
|
|
}
|
|
|
|
//var lValid = ValidationTrigger.Validate(root);
|
|
//var records = new List<ServiceRecordDC>();
|
|
|
|
//foreach (ServiceRecordVM iVM in ViewModel.CreateFromPrototype())
|
|
//{
|
|
// if (iVM.Customer == null)
|
|
// break;
|
|
|
|
// iVM.Employee = _SelectedEmployee;
|
|
// records.Add(iVM.CommitToDataContract());
|
|
//}
|
|
|
|
//if (lValid)
|
|
// SaveSingleBooking();
|
|
//else
|
|
// foreach (var iVM in ViewModel.CreateFromPrototype())
|
|
// MessageBox.Show("Der gewählte Zeitpunkt '" + iVM.DateAndTime.Value.ToShortDateString() + " " + iVM.DateAndTime.Value.ToShortTimeString() + "' überschneidet sich mit einem bereits existierenden Eintrag desselben Hilfeplans.\nSpeichern nicht möglich.", "Speichern nicht möglich", MessageBoxButton.OK, MessageBoxImage.Information);
|
|
}
|
|
|
|
private bool SaveSingleBooking()
|
|
{
|
|
var lValid = true;
|
|
|
|
FlatSupportConceptTreeNodeDC selectedNode = null;
|
|
if (ViewModel.CustomerNodes.Count > 0)
|
|
{
|
|
selectedNode = ViewModel.CustomerNodes[0];
|
|
}
|
|
|
|
if (!WithoutClient && selectedNode?.SupportConceptTreeNodeDC == null)
|
|
{
|
|
MessageBox.Show("Bitte wählen Sie zuerst einen Hilfeplan, für den Sie Leistungen dokumentieren möchten.", "Speichern", MessageBoxButton.OK, MessageBoxImage.Information);
|
|
lValid = false;
|
|
}
|
|
|
|
if (lValid)
|
|
{
|
|
lValid = BeWoUtils.ValidateServiceRecordVM(ViewModel.PrototypeVM, ViewModel.StatisticsDC, selectedNode, false, ViewModel.SelectedEmployee, null, null);
|
|
|
|
if (lValid)
|
|
{
|
|
var save = false;
|
|
foreach (var iVM in ViewModel.CreateFromPrototype())
|
|
{
|
|
iVM.Employee = _SelectedEmployee;
|
|
|
|
ViewModel.VMList.Add(iVM);
|
|
save = true;
|
|
}
|
|
|
|
if (save)
|
|
{
|
|
Save();
|
|
ViewModel.RefreshServiceRecordsForSelectedTreeNode(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
return lValid;
|
|
}
|
|
|
|
private void linkExcelExport_RequestNavigate(object sender, RequestNavigateEventArgs e)
|
|
{
|
|
var list = SrListBox.ItemsSource as List<ServiceRecordVM>;
|
|
var lHeaderCaptions = new List<string>();
|
|
var lContent = new List<List<string>>();
|
|
|
|
lHeaderCaptions.Add("Datum");
|
|
lHeaderCaptions.Add(Translator.Translate("FLM"));
|
|
lHeaderCaptions.Add(Translator.Translate("FLM gerundet"));
|
|
lHeaderCaptions.Add(Translator.Translate("MitarbeiterSingular"));
|
|
lHeaderCaptions.Add(Translator.Translate("Klient"));
|
|
lHeaderCaptions.Add(Translator.Translate("Hilfeplan"));
|
|
lHeaderCaptions.Add(Translator.Translate("Kostenträger"));
|
|
lHeaderCaptions.Add("Kategorie");
|
|
lHeaderCaptions.Add("Leistung");
|
|
lHeaderCaptions.Add("Dokumentation");
|
|
|
|
if (list != null)
|
|
{
|
|
lContent.AddRange(list.Select(vm => new List<string> {String.Format("{0:d}", vm.StartDate), vm.AssistanceDuration.ToString(), vm.RoundedDuration.ToString(), vm.Employee != null ? vm.Employee.ToString() : string.Empty, vm.Customer != null ? vm.Customer.ToString() : string.Empty, vm.SupportConcept != null ? vm.SupportConcept.ToString() : string.Empty, vm.CostBearer != null ? vm.CostBearer.ToString() : string.Empty, vm.Category != null ? vm.Category.ToString() : string.Empty, vm.ServiceDescription != null ? vm.ServiceDescription.ToString() : string.Empty, vm.Notice}));
|
|
}
|
|
|
|
var path = BeWoApp.GetAndCreateUserAppDataPath() + "\\Dokumentation.xls";
|
|
var sf = new SaveFileDialog { FileName = Path.GetFileName(path), Filter = "Microsoft Excel 97-2003-Arbeitsblatt|*.xls|Alle Dateien|*.*" };
|
|
if (sf.ShowDialog() != true)
|
|
return;
|
|
ServiceFacade.DoDownloadServiceSync(s => BeWoUtils.WriteExcelFile(s.PrepareExcelFile(DownloadLinkEngine.ExcelFileId, lHeaderCaptions, lContent), sf.FileName));
|
|
}
|
|
|
|
private void popupedit_employee_PopUpClick(object sender, RoutedEventArgs e)
|
|
{
|
|
PopupEmployee.IsOpen = true;
|
|
}
|
|
|
|
private void serviceRecordListBox_MouseDoubleClick(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (!IsPartOf(e.OriginalSource, typeof(ScrollBar)))
|
|
Edit(GetSelectedServiceRecordFromListBox());
|
|
}
|
|
|
|
private void UpdateAssessmentSheet(FlatSupportConceptTreeNodeDC selectedNode)
|
|
{
|
|
if (_AssessmentSheet == null)
|
|
return;
|
|
|
|
HideAssessmentSheet();
|
|
}
|
|
|
|
private DockLayoutManager dockLayoutManager;
|
|
private Grid panel1;
|
|
private Grid panel2;
|
|
private Grid panel3;
|
|
|
|
private void HideAssessmentSheet()
|
|
{
|
|
_AssessmentSheet.SetCustomer(null, null);
|
|
_AssessmentSheet.Visibility = Visibility.Collapsed;
|
|
|
|
if (dockLayoutManager != null)
|
|
dockLayoutManager.Visibility = Visibility.Collapsed;
|
|
|
|
|
|
if (FLSGrid.Children.Count != 0)
|
|
return;
|
|
|
|
if (panel1 != null)
|
|
{
|
|
panel1.Children.Clear();
|
|
panel2.Children.Clear();
|
|
panel3.Children.Clear();
|
|
}
|
|
|
|
GroupBoxNeueLeistung.Content = GridNeueLeistung;
|
|
FLSGrid.Children.Add(GroupBoxNeueLeistung);
|
|
FLSGrid.Children.Add(ServiceRecordListContent);
|
|
FLSGrid.Children.Add(TxtServiceListCount);
|
|
FLSGrid.Children.Add(StackPanelInfoText);
|
|
FLSGrid.Children.Add(PunktebogenRootGrid);
|
|
}
|
|
|
|
public override void ModalPopUpCloseInvoked()
|
|
{
|
|
MainControl.CloseCurrentPopUp();
|
|
}
|
|
|
|
public override void ModalPopUpSaveInvoked()
|
|
{
|
|
}
|
|
|
|
void multiAddServGroupOfPeopleSelectionControl_EditGroupButtonClicked(object sender, EventArgs e)
|
|
{
|
|
OpenAddServGroupEditView();
|
|
}
|
|
|
|
private void OpenAddServGroupEditView()
|
|
{
|
|
VMFactory.CreateAdditinoalServiceGroupOfPeopleListVMAsync(
|
|
cb => this.Dispatch(delegate
|
|
{
|
|
_AdditionalServiceGroupOfPeoplePopUp = new AdditionalServiceGroupOfPeopleView(cb)
|
|
{
|
|
MinWidth = 700,
|
|
MaxWidth = 700,
|
|
Height = 600
|
|
};
|
|
|
|
_AdditionalServiceGroupOfPeoplePopUp.GroupOfPeopleSavedOrUpdated += AdditionalServiceGroupOfPeoplePopUp_AdditionalServiceGroupOfPeopleSavedOrUpdated;
|
|
BeWoApp.MainControl.ShowControlAsModalPopup(_AdditionalServiceGroupOfPeoplePopUp);
|
|
_AdditionalServiceGroupOfPeoplePopUp.Focus();
|
|
})
|
|
);
|
|
}
|
|
|
|
private void LinkPdfExport_OnRequestNavigate(object sender, RequestNavigateEventArgs e)
|
|
{
|
|
BeWoUtils.NavigateToReportUri(((Hyperlink)sender).NavigateUri.ToString(), "Druckvorschau");
|
|
}
|
|
|
|
private static void AdditionalServiceGroupOfPeoplePopUp_AdditionalServiceGroupOfPeopleSavedOrUpdated(object sender, EventArgs<AdditionalServiceGroupOfPeopleListVM> e)
|
|
{
|
|
BeWoApp.MainControl.CloseCurrentPopUp();
|
|
}
|
|
|
|
private void MultiAddServGroupOfPeopleSelectionControl_OnPropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
var groupSearchControl = (MultiAddServGroupOfPeopleSelectionControl) sender;
|
|
AdditionalServiceBookings.NewVM.CustomerOidDict = groupSearchControl.CurrentGroup.CustomerList.ToDictionary(customer => customer.CustomerOid, customer => true);
|
|
|
|
this.Dispatch(() => Cache.GetInstance().GetAllActiveSupportConceptsCompact(x => this.Dispatch(() => { SupportConceptSelectionControl.SupportConceptList = x; })));
|
|
}
|
|
|
|
private void UpdateAdditionalServiceReportUrl()
|
|
{
|
|
var url = BeWoApp.SiteOfOrigin + "/ReportView.aspx" + "?y=" + SelectedYear + "&m=" + SelectedMonth + "&asroid=" + (Angebotscombobox.SelectedItem as AdditionalServiceRegionDC).AdditionalServiceRegionOid + "&type=" + Utils.EnumName(ReportTypes.AdditionalServiceBookingReport);
|
|
url = BeWoWpfUtils.GetHTMLEncodedURL(url);
|
|
|
|
LinkPdfExport2.NavigateUri = new Uri(url);
|
|
}
|
|
|
|
private void FLSAnlegenBtn_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
if (TeilnahmeGrid.Visibility == Visibility.Visible)
|
|
{
|
|
TeilnahmeGrid.Visibility = Visibility.Collapsed;
|
|
MonatsLabel.Visibility = Visibility.Collapsed;
|
|
MonatsCombobox.Visibility = Visibility.Collapsed;
|
|
JahresLabel.Visibility = Visibility.Collapsed;
|
|
JahresCombobox.Visibility = Visibility.Collapsed;
|
|
SaveBtn.Visibility = Visibility.Collapsed;
|
|
TextblockLinkPdfexport2.Visibility = Visibility.Collapsed;
|
|
|
|
FLSInfoGrid.Visibility = Visibility.Visible;
|
|
button_ADadd.Visibility = Visibility.Hidden;
|
|
}
|
|
else
|
|
{
|
|
TeilnahmeGrid.Visibility = Visibility.Visible;
|
|
MonatsLabel.Visibility = Visibility.Visible;
|
|
MonatsCombobox.Visibility = Visibility.Visible;
|
|
JahresLabel.Visibility = Visibility.Visible;
|
|
JahresCombobox.Visibility = Visibility.Visible;
|
|
SaveBtn.Visibility = Visibility.Visible;
|
|
TextblockLinkPdfexport2.Visibility = Visibility.Visible;
|
|
button_ADadd.Visibility = Visibility.Visible;
|
|
|
|
FLSInfoGrid.Visibility = Visibility.Collapsed;
|
|
|
|
if (AdditionalServiceBookings.NewVM.EmployeeOidList.Count > 0)
|
|
{
|
|
//_SelectedEmployee = AdditionalServiceBookings.NewVM.EmployeeOidList.First();
|
|
// PopupeditEmployee.Text = _SelectedEmployee.ToString();
|
|
//_SelectedEmployee = null;
|
|
//PopupeditEmployee.Text = AdditionalServiceBookings.NewVM.EmployeeOidList.First().ToString();
|
|
}
|
|
}
|
|
|
|
FLSGrid.Visibility = FLSGrid.Visibility == Visibility.Collapsed ? Visibility.Visible : Visibility.Collapsed;
|
|
}
|
|
|
|
private void supportConceptSelectionControl_ItemSelected(object sender, EventArgs<FlatSupportConceptTreeNodeDC> e)
|
|
{
|
|
ViewModel.ChangeTreeItemSelection(e.Data);
|
|
ViewModel.RefreshServiceRecordsForSelectedTreeNode(true);
|
|
UpdateServiceRecordListReportUrl(e.Data);
|
|
|
|
ComboBoxTreeViewControl.ResetControl();
|
|
|
|
foreach (var item in ViewModel.PrototypeVM.GoalTree)
|
|
item.IsChecked = false;
|
|
|
|
ComboBoxTreeViewControl.TreeViewSourceList = ViewModel.PrototypeVM.GoalTree;
|
|
}
|
|
|
|
private void LinkPdfExport2_OnRequestNavigate(object sender, RequestNavigateEventArgs e)
|
|
{
|
|
BeWoUtils.NavigateToReportUri(((Hyperlink)sender).NavigateUri.ToString(), "Druckvorschau");
|
|
}
|
|
|
|
private void TableView_ShowingEditor(object sender, ShowingEditorEventArgs e)
|
|
{
|
|
if (!CheckEditRight(true))
|
|
{
|
|
e.Cancel = true;
|
|
e.Handled = true;
|
|
}
|
|
}
|
|
|
|
private void TableView_ShowGridMenu(object sender, GridMenuEventArgs e)
|
|
{
|
|
AddContextMenu(e);
|
|
}
|
|
|
|
private void AddContextMenu(GridMenuEventArgs e)
|
|
{
|
|
var item = e.Source.DataControl.SelectedItem as Teilnehmer;
|
|
|
|
if (item != null)
|
|
{
|
|
e.Customizations.Add(new DevExpress.Xpf.Bars.BarItemSeparator());
|
|
|
|
var btn = new BarButtonItem { Content = "Zeile löschen", Tag = item };
|
|
btn.ItemClick += DeleteRow_OnClick;
|
|
e.Customizations.Add(btn);
|
|
}
|
|
|
|
//if (tvm != null)
|
|
//{
|
|
|
|
// if (tvm.Absencetime != null)
|
|
// {
|
|
// e.Customizations.Add(new DevExpress.Xpf.Bars.BarItemSeparator());
|
|
|
|
// var btn = new BarButtonItem { Content = "Abwesenheit löschen", Tag = tvm };
|
|
// btn.ItemClick += DeleteRow_OnClick;
|
|
// e.Customizations.Add(btn);
|
|
// }
|
|
//}
|
|
}
|
|
|
|
private void DeleteRow_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var barButtonItem = (BarButtonItem)sender;
|
|
var item = barButtonItem.Tag as Teilnehmer;
|
|
|
|
if (item != null && MessageBox.Show(String.Format("Möchten Sie '{0}' wirklich aus der Liste entfernen?", item.Customer), "Löschen", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes)
|
|
{
|
|
_Customer2Delete.Add(item.Customer);
|
|
var teilnehmer = (List<Teilnehmer>)TeilnahmeGrid.ItemsSource;
|
|
teilnehmer.Remove(item);
|
|
TeilnahmeGrid.RefreshData();
|
|
SaveBtn.IsEnabled = true;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
public class Teilnehmer
|
|
{
|
|
public CompactCustomerDC Customer { get; set; }
|
|
|
|
#region Anwesenheiten
|
|
private bool _t0; public bool t0 { get { return _t0; } set { _t0 = value; TeilnahmenForUpdating[0] = value; } }
|
|
private bool _t1; public bool t1 { get { return _t1; } set { _t1 = value; TeilnahmenForUpdating[1] = value; } }
|
|
private bool _t2; public bool t2 { get { return _t2; } set { _t2 = value; TeilnahmenForUpdating[2] = value; } }
|
|
private bool _t3; public bool t3 { get { return _t3; } set { _t3 = value; TeilnahmenForUpdating[3] = value; } }
|
|
private bool _t4; public bool t4 { get { return _t4; } set { _t4 = value; TeilnahmenForUpdating[4] = value; } }
|
|
private bool _t5; public bool t5 { get { return _t5; } set { _t5 = value; TeilnahmenForUpdating[5] = value; } }
|
|
private bool _t6; public bool t6 { get { return _t6; } set { _t6 = value; TeilnahmenForUpdating[6] = value; } }
|
|
private bool _t7; public bool t7 { get { return _t7; } set { _t7 = value; TeilnahmenForUpdating[7] = value; } }
|
|
private bool _t8; public bool t8 { get { return _t8; } set { _t8 = value; TeilnahmenForUpdating[8] = value; } }
|
|
private bool _t9; public bool t9 { get { return _t9; } set { _t9 = value; TeilnahmenForUpdating[9] = value; } }
|
|
|
|
private bool _t10; public bool t10 { get { return _t10; } set { _t10 = value; TeilnahmenForUpdating[10] = value; } }
|
|
private bool _t11; public bool t11 { get { return _t11; } set { _t11 = value; TeilnahmenForUpdating[11] = value; } }
|
|
private bool _t12; public bool t12 { get { return _t12; } set { _t12 = value; TeilnahmenForUpdating[12] = value; } }
|
|
private bool _t13; public bool t13 { get { return _t13; } set { _t13 = value; TeilnahmenForUpdating[13] = value; } }
|
|
private bool _t14; public bool t14 { get { return _t14; } set { _t14 = value; TeilnahmenForUpdating[14] = value; } }
|
|
private bool _t15; public bool t15 { get { return _t15; } set { _t15 = value; TeilnahmenForUpdating[15] = value; } }
|
|
private bool _t16; public bool t16 { get { return _t16; } set { _t16 = value; TeilnahmenForUpdating[16] = value; } }
|
|
private bool _t17; public bool t17 { get { return _t17; } set { _t17 = value; TeilnahmenForUpdating[17] = value; } }
|
|
private bool _t18; public bool t18 { get { return _t18; } set { _t18 = value; TeilnahmenForUpdating[18] = value; } }
|
|
private bool _t19; public bool t19 { get { return _t19; } set { _t19 = value; TeilnahmenForUpdating[19] = value; } }
|
|
|
|
private bool _t20; public bool t20 { get { return _t20; } set { _t20 = value; TeilnahmenForUpdating[20] = value; } }
|
|
private bool _t21; public bool t21 { get { return _t21; } set { _t21 = value; TeilnahmenForUpdating[21] = value; } }
|
|
private bool _t22; public bool t22 { get { return _t22; } set { _t22 = value; TeilnahmenForUpdating[22] = value; } }
|
|
private bool _t23; public bool t23 { get { return _t23; } set { _t23 = value; TeilnahmenForUpdating[23] = value; } }
|
|
private bool _t24; public bool t24 { get { return _t24; } set { _t24 = value; TeilnahmenForUpdating[24] = value; } }
|
|
private bool _t25; public bool t25 { get { return _t25; } set { _t25 = value; TeilnahmenForUpdating[25] = value; } }
|
|
private bool _t26; public bool t26 { get { return _t26; } set { _t26 = value; TeilnahmenForUpdating[26] = value; } }
|
|
private bool _t27; public bool t27 { get { return _t27; } set { _t27 = value; TeilnahmenForUpdating[27] = value; } }
|
|
private bool _t28; public bool t28 { get { return _t28; } set { _t28 = value; TeilnahmenForUpdating[28] = value; } }
|
|
private bool _t29; public bool t29 { get { return _t29; } set { _t29 = value; TeilnahmenForUpdating[29] = value; } }
|
|
|
|
private bool _t30; public bool t30 { get { return _t30; } set { _t30 = value; TeilnahmenForUpdating[30] = value; } }
|
|
#endregion
|
|
|
|
public Dictionary<long, BookingRelationDictionaryValue> BookingRelation { get; set; }
|
|
public bool[] TeilnahmenForUpdating { get; set; }
|
|
|
|
public bool ContainsOneRelationOnly { get; set; }
|
|
|
|
public AdditionalServiceNoticeDC Notice { get; set; }
|
|
|
|
public Teilnehmer(CompactCustomerDC customer, IList<bool> teilnahmen, Dictionary<long, BookingRelationDictionaryValue> bookingRelation, AdditionalServiceNoticeDC notice, bool containsOneRelationOnly = false)
|
|
{
|
|
Customer = customer;
|
|
Notice = notice;
|
|
|
|
ContainsOneRelationOnly = containsOneRelationOnly;
|
|
|
|
if (BookingRelation == null)
|
|
BookingRelation = new Dictionary<long, BookingRelationDictionaryValue>();
|
|
|
|
BookingRelation = BookingRelation.Union(bookingRelation).ToDictionary(k => k.Key, v => v.Value);
|
|
TeilnahmenForUpdating = teilnahmen.ToArray();
|
|
|
|
t0 = teilnahmen[0];
|
|
t1 = teilnahmen[1];
|
|
t2 = teilnahmen[2];
|
|
t3 = teilnahmen[3];
|
|
t4 = teilnahmen[4];
|
|
t5 = teilnahmen[5];
|
|
t6 = teilnahmen[6];
|
|
t7 = teilnahmen[7];
|
|
t8 = teilnahmen[8];
|
|
t9 = teilnahmen[9];
|
|
t10 = teilnahmen[10];
|
|
t11 = teilnahmen[11];
|
|
t12 = teilnahmen[12];
|
|
t13 = teilnahmen[13];
|
|
t14 = teilnahmen[14];
|
|
t15 = teilnahmen[15];
|
|
t16 = teilnahmen[16];
|
|
t17 = teilnahmen[17];
|
|
t18 = teilnahmen[18];
|
|
t19 = teilnahmen[19];
|
|
t20 = teilnahmen[20];
|
|
t21 = teilnahmen[21];
|
|
t22 = teilnahmen[22];
|
|
t23 = teilnahmen[23];
|
|
t24 = teilnahmen[24];
|
|
t25 = teilnahmen[25];
|
|
t26 = teilnahmen[26];
|
|
t27 = teilnahmen[27];
|
|
|
|
if (teilnahmen.Count >= 29)
|
|
t28 = teilnahmen[28];
|
|
if (teilnahmen.Count >= 30)
|
|
t29 = teilnahmen[29];
|
|
if (teilnahmen.Count == 31)
|
|
t30 = teilnahmen[30];
|
|
}
|
|
}
|
|
|
|
public struct BookingRelationDictionaryValue
|
|
{
|
|
public DateTime Datum, StartDate, EndDate;
|
|
|
|
public BookingRelationDictionaryValue(DateTime d, DateTime s, DateTime e)
|
|
{
|
|
Datum = d;
|
|
StartDate = s;
|
|
EndDate = e;
|
|
}
|
|
}
|
|
|
|
public class CheckEditTag
|
|
{
|
|
public Teilnehmer Teilnehmer { get; set; }
|
|
public GridColumn Column { get; set; }
|
|
|
|
public CheckEditTag(Teilnehmer teilnehmer, GridColumn column)
|
|
{
|
|
Teilnehmer = teilnehmer;
|
|
Column = column;
|
|
}
|
|
|
|
public int GetHeaderAsDay()
|
|
{
|
|
if (Column.Header.ToString().Equals(string.Empty))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
var tag = int.Parse(Column.Header.ToString().Split('.')[0], NumberStyles.Integer);
|
|
|
|
return tag;
|
|
}
|
|
}
|
|
} |