Lyndon Jetten
4bd9dffd0b
Klienten meiner Teams werden im Kalender angezeigt, auch wenn man sonst keine sehen darf. Nach der Änderung von Benutzergruppen in denen der angemeldete Mitarbeiter ist, wird der Cache geleert, um den Änderungen entsprechende Objekte aus der Datenbank neuzuladen.
3267 lines
135 KiB
C#
3267 lines
135 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Controls.Primitives;
|
|
using System.Windows.Data;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using System.Windows.Navigation;
|
|
|
|
using BeWo.Annotations;
|
|
using BeWo.Core;
|
|
using BeWo.Core.Service;
|
|
using BeWo.Scheduler.Converter;
|
|
using BeWo.Scheduler.Utils;
|
|
using BeWo.Scheduler.ViewModel;
|
|
using BeWo.ServiceProxy;
|
|
using BeWo.View;
|
|
using BeWo.View.Detail;
|
|
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.Editors;
|
|
using DevExpress.Xpf.Scheduler;
|
|
using DevExpress.Xpf.Scheduler.Reporting;
|
|
using DevExpress.XtraScheduler;
|
|
using DevExpress.XtraScheduler.Compatibility;
|
|
using DevExpress.XtraScheduler.iCalendar;
|
|
using DevExpress.XtraScheduler.Services;
|
|
using Microsoft.Win32;
|
|
using Appointment = DevExpress.XtraScheduler.Appointment;
|
|
using AppointmentViewInfoCustomizingEventArgs = DevExpress.Xpf.Scheduler.AppointmentViewInfoCustomizingEventArgs;
|
|
using ColorConverter = System.Windows.Media.ColorConverter;
|
|
using DateTime = System.DateTime;
|
|
using InplaceEditorEventArgs = DevExpress.Xpf.Scheduler.InplaceEditorEventArgs;
|
|
using SchedulerControl = DevExpress.Xpf.Scheduler.SchedulerControl;
|
|
|
|
namespace BeWo.Scheduler.View
|
|
{
|
|
public partial class NewSchedulerView : INotifyPropertyChanged
|
|
{
|
|
private bool _disableUpdateRequestString = false;
|
|
|
|
private bool _IsEmployeeBrushVisible;
|
|
|
|
public bool IsEmployeeBrushVisible
|
|
{
|
|
get => _IsEmployeeBrushVisible;
|
|
|
|
set
|
|
{
|
|
_IsEmployeeBrushVisible = value;
|
|
OnPropertyChanged(nameof(IsEmployeeBrushVisible));
|
|
}
|
|
}
|
|
|
|
private bool _IsAbsenceTimeVisible;
|
|
|
|
public bool IsAbsenceTimeVisible
|
|
{
|
|
get => _IsAbsenceTimeVisible;
|
|
|
|
set
|
|
{
|
|
_IsAbsenceTimeVisible = value;
|
|
OnPropertyChanged(nameof(IsAbsenceTimeVisible));
|
|
}
|
|
}
|
|
|
|
private bool _IsTasksVisible;
|
|
|
|
public bool IsTasksVisible
|
|
{
|
|
get => _IsTasksVisible;
|
|
|
|
set
|
|
{
|
|
_IsTasksVisible = value;
|
|
OnPropertyChanged(nameof(IsTasksVisible));
|
|
}
|
|
}
|
|
|
|
public bool IsInCustomerViewMode { get; set; }
|
|
|
|
private SchedulerPrintingSettings _PrintingSettings = new SchedulerPrintingSettings();
|
|
|
|
public NewSchedulerViewModel ViewModel { get; set; }
|
|
|
|
public event PropertyChangedEventHandler PropertyChanged;
|
|
|
|
[NotifyPropertyChangedInvocator]
|
|
public void OnPropertyChanged(string propertyName)
|
|
{
|
|
var handler = PropertyChanged;
|
|
handler?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
|
}
|
|
|
|
public bool ZeigeNurMeineTermine
|
|
{
|
|
get => BeWoApp.AppSettings.ZeigeNurMeineTermine;
|
|
set
|
|
{
|
|
if(BeWoApp.AppSettings.ZeigeNurMeineTermine != value)
|
|
{
|
|
BeWoApp.AppSettings.ZeigeNurMeineTermine = value;
|
|
BeWoApp.SaveAppSettings();
|
|
OnPropertyChanged(nameof(ZeigeNurMeineTermine));
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<CompactEmployeeDC> _AllEmployees;
|
|
|
|
public List<CompactEmployeeDC> AllEmployees
|
|
{
|
|
get => _AllEmployees ?? (_AllEmployees = new List<CompactEmployeeDC>());
|
|
|
|
set
|
|
{
|
|
if(!ListEquals(_AllEmployees, value))
|
|
{
|
|
_AllEmployees = value;
|
|
|
|
OnPropertyChanged(nameof(AllEmployees));
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<CompactEmployeeDC> _GefilterteMitarbeiter;
|
|
|
|
public List<CompactEmployeeDC> GefilterteMitarbeiter
|
|
{
|
|
get => _GefilterteMitarbeiter ?? (_GefilterteMitarbeiter = new List<CompactEmployeeDC>(AllEmployees));
|
|
|
|
set
|
|
{
|
|
if(!ListEquals(_GefilterteMitarbeiter, value))
|
|
{
|
|
_GefilterteMitarbeiter = value;
|
|
_GefilterteMitarbeiter.Sort((x, y) => string.Compare(x.LastName + ", " + x.FirstName, y.LastName + ", " + y.FirstName, StringComparison.Ordinal));
|
|
|
|
OnPropertyChanged(nameof(GefilterteMitarbeiter));
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<CompactCustomerDC> _GefilterteKlienten;
|
|
|
|
public List<CompactCustomerDC> GefilterteKlienten
|
|
{
|
|
get => _GefilterteKlienten ?? (_GefilterteKlienten = new List<CompactCustomerDC>(AllCustomers));
|
|
|
|
set
|
|
{
|
|
if(!ListEquals(_GefilterteKlienten, value))
|
|
{
|
|
_GefilterteKlienten = value;
|
|
_GefilterteKlienten.Sort((x, y) => string.Compare(x.LastName + ", " + x.FirstName, y.LastName + ", " + y.FirstName, StringComparison.Ordinal));
|
|
|
|
OnPropertyChanged(nameof(GefilterteKlienten));
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<CompactCustomerDC> _AllCustomers;
|
|
|
|
public List<CompactCustomerDC> AllCustomers
|
|
{
|
|
get => _AllCustomers ?? (_AllCustomers = new List<CompactCustomerDC>());
|
|
|
|
set
|
|
{
|
|
if(!ListEquals(_AllCustomers, value))
|
|
{
|
|
_AllCustomers = value;
|
|
OnPropertyChanged(nameof(AllCustomers));
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<ResourceDC> _AllResources;
|
|
|
|
public List<ResourceDC> AllResources
|
|
{
|
|
get => _AllResources ?? (_AllResources = new List<ResourceDC>());
|
|
|
|
set
|
|
{
|
|
if(!ListEquals(_AllResources, value))
|
|
{
|
|
_AllResources = value;
|
|
OnPropertyChanged(nameof(AllResources));
|
|
}
|
|
}
|
|
}
|
|
|
|
private List<CompactCustomerDC> _CustomerList;
|
|
|
|
public List<CompactCustomerDC> CustomerList
|
|
{
|
|
get => _CustomerList ?? (_CustomerList = new List<CompactCustomerDC>());
|
|
|
|
set
|
|
{
|
|
if(!ListEquals(_CustomerList, value))
|
|
{
|
|
_CustomerList = value;
|
|
_CustomerList.Sort((x, y) => string.Compare(x.LastName + ", " + x.FirstName, y.LastName + ", " + y.FirstName, StringComparison.Ordinal));
|
|
OnPropertyChanged(nameof(CustomerList));
|
|
}
|
|
}
|
|
}
|
|
|
|
private int _TimelineDayCount;
|
|
private SchedulerViewType _CurrentViewType;
|
|
|
|
private Dictionary<ValueListEntryDC, List<ResourceDC>> _Category2ResourcesDictionary;
|
|
|
|
public Dictionary<ValueListEntryDC, List<ResourceDC>> Category2ResourcesDictionary
|
|
{
|
|
get => _Category2ResourcesDictionary ?? (_Category2ResourcesDictionary = new Dictionary<ValueListEntryDC, List<ResourceDC>>());
|
|
|
|
set
|
|
{
|
|
if(!CheckCats2ResourcesForEqualitiy(value))
|
|
{
|
|
_Category2ResourcesDictionary = value;
|
|
|
|
AllResources = new List<ResourceDC>();
|
|
value.DoForEach(d => AllResources.AddRange(d.Value));
|
|
|
|
OnPropertyChanged(nameof(Category2ResourcesDictionary));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool CheckCats2ResourcesForEqualitiy(Dictionary<ValueListEntryDC, List<ResourceDC>> dic2)
|
|
{
|
|
if(_Category2ResourcesDictionary == null && dic2 != null || dic2 == null && _Category2ResourcesDictionary != null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return _Category2ResourcesDictionary == null && dic2 == null || _Category2ResourcesDictionary != null && dic2 != null && _Category2ResourcesDictionary.Count == dic2.Count && _Category2ResourcesDictionary.Except(dic2).Any();
|
|
}
|
|
|
|
private static bool ListEquals<T>(IReadOnlyCollection<T> list1, ICollection<T> list2)
|
|
{
|
|
if(list1 == null && list2 == null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if(list1 == null && list2 != null || list1 != null && list2 == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return list1.Count == list2.Count && list1.All(list2.Contains);
|
|
}
|
|
|
|
private List<CompactEmployeeDC> _SelectedEmployees = new List<CompactEmployeeDC>();
|
|
private List<CompactCustomerDC> _SelectedCustomers = new List<CompactCustomerDC>();
|
|
private List<ResourceDC> _SelectedResources = new List<ResourceDC>();
|
|
|
|
public List<CompactEmployeeDC> SelectedEmployees
|
|
{
|
|
get => _SelectedEmployees;
|
|
set
|
|
{
|
|
if(!ListEquals(_SelectedEmployees, value))
|
|
{
|
|
_SelectedEmployees = value;
|
|
_SelectedEmployees.Sort((x, y) => string.Compare(x.LastName + ", " + x.FirstName, y.LastName + ", " + y.FirstName, StringComparison.Ordinal));
|
|
|
|
AlleMitarbeiterCB.IsChecked = ListEquals(value, AllEmployees);
|
|
|
|
ZeigeNurMeineTermine = value.Count == 1 && value.Contains(BeWoApp.CompactLoggedOnEmployee);
|
|
|
|
OnPropertyChanged(nameof(SelectedEmployees));
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<CompactCustomerDC> SelectedCustomers
|
|
{
|
|
get => _SelectedCustomers;
|
|
set
|
|
{
|
|
if(!ListEquals(_SelectedCustomers, value))
|
|
{
|
|
_SelectedCustomers = value;
|
|
_SelectedCustomers.Sort((x, y) => string.Compare(x.LastName + ", " + x.FirstName, y.LastName + ", " + y.FirstName, StringComparison.Ordinal));
|
|
|
|
if(NurMeineKlientenCB.IsChecked.HasValue && NurMeineKlientenCB.IsChecked.Value && value.Equals(GefilterteKlienten) || value.Equals(AllCustomers))
|
|
{
|
|
AlleKlientenCB.IsChecked = true;
|
|
}
|
|
|
|
OnPropertyChanged(nameof(SelectedCustomers));
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<ResourceDC> SelectedResources
|
|
{
|
|
get => _SelectedResources;
|
|
set
|
|
{
|
|
if(!ListEquals(_SelectedResources, value))
|
|
{
|
|
_SelectedResources = value;
|
|
|
|
AlleRessourcenCB.IsChecked = ListEquals(value, AllResources);
|
|
|
|
OnPropertyChanged(nameof(SelectedResources));
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
}
|
|
}
|
|
}
|
|
|
|
public IEnumerable<IDataContract> SelectedItems
|
|
{
|
|
get
|
|
{
|
|
var erg = new List<IDataContract>();
|
|
|
|
erg.AddRange(SelectedEmployees);
|
|
erg.AddRange(SelectedCustomers);
|
|
erg.AddRange(SelectedResources);
|
|
|
|
return erg;
|
|
}
|
|
}
|
|
|
|
public IEnumerable<IDataContract> AllItems
|
|
{
|
|
get
|
|
{
|
|
var erg = new List<IDataContract>();
|
|
|
|
erg.AddRange(GefilterteKlienten);
|
|
erg.AddRange(AllResources);
|
|
|
|
return erg;
|
|
}
|
|
}
|
|
|
|
public static bool IgnoreChangeEvents;
|
|
|
|
//private List<CompactTeamDC> _EmployeesTeams = new List<CompactTeamDC>();
|
|
|
|
private string _Requests;
|
|
|
|
public string Requests
|
|
{
|
|
get => _Requests ?? (_Requests = "keine Benachrichtigungen");
|
|
set
|
|
{
|
|
_Requests = value;
|
|
OnPropertyChanged(nameof(Requests));
|
|
}
|
|
}
|
|
|
|
public static TimeSpan FetchPadding = TimeSpan.FromDays(14);
|
|
|
|
private TimeInterval _LastFetchedInterval = new TimeInterval();
|
|
|
|
public long CustomerOidToPreselect { get; set; }
|
|
|
|
//private static string[] outlookCalendarPaths;
|
|
//public static string[] OutlookCalendarPaths
|
|
//{
|
|
// get
|
|
// {
|
|
// if (outlookCalendarPaths != null)
|
|
// return outlookCalendarPaths;
|
|
|
|
// try
|
|
// {
|
|
// outlookCalendarPaths = OutlookExchangeHelper.GetOutlookCalendarPaths();
|
|
// }
|
|
// catch
|
|
// {
|
|
// outlookCalendarPaths = new string[0];
|
|
// }
|
|
|
|
// return outlookCalendarPaths;
|
|
// }
|
|
//}
|
|
|
|
// KONSTRUKTOR
|
|
public NewSchedulerView(long customerOid)
|
|
{
|
|
// Kalenderaufruf aus dem CustomerView2 heraus
|
|
CustomerOidToPreselect = customerOid;
|
|
ConstructObject();
|
|
}
|
|
|
|
public NewSchedulerView()
|
|
{
|
|
ConstructObject();
|
|
}
|
|
|
|
private DateTime? _SelectedAppointmentStartDate;
|
|
|
|
private readonly SchedulerAppointmentDC _SelectedAppointmentFromHomePanelView;
|
|
private bool _IsComingFromHomeDragPanel;
|
|
|
|
public NewSchedulerView(DateTime pIntervalStartDate, SchedulerAppointmentDC pAppointment)
|
|
{
|
|
_IsComingFromHomeDragPanel = true;
|
|
|
|
_SelectedAppointmentFromHomePanelView = pAppointment;
|
|
|
|
_SelectedAppointmentStartDate = pIntervalStartDate;
|
|
|
|
ConstructObject();
|
|
}
|
|
|
|
private void GetCacheObjects(Action<List<CompactCustomerDC>, List<CompactEmployeeDC>, Dictionary<ValueListEntryDC, List<ResourceDC>>> callback)
|
|
{
|
|
Cache.GetInstance().GetAllActiveEmployeesCompact(allEmployees =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
Cache.GetInstance().GetAllActiveCustomersCompact(allCustomers =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
Cache.GetInstance().GetCategories2ResourcesDictionary(resourceDictionary =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
if(!BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderMitarbeitertermineAnsehen))
|
|
{
|
|
allEmployees = new List<CompactEmployeeDC> {BeWoApp.CompactLoggedOnEmployee};
|
|
}
|
|
|
|
var darfKlientenAnsichtSehen = BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_ViewMyTeams) || BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_ViewMyCustomers) || BeWoApp.LoggedOnUser.HasRight(UserRightType.CustomerView_View);
|
|
var darfTermineAllerKlientenSehen = BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderKliententermineAlleAnsehen);
|
|
|
|
if(darfKlientenAnsichtSehen)
|
|
{
|
|
if(!darfTermineAllerKlientenSehen || !BeWoApp.LoggedOnUser.HasRight(UserRightType.CustomerView_View))
|
|
{
|
|
allCustomers = allCustomers.Where(w => w.IsRelatedToEmployee).ToList();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
allCustomers.Clear();
|
|
}
|
|
|
|
if(!BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderRessourcentermineAnsehen))
|
|
{
|
|
resourceDictionary.Clear();
|
|
}
|
|
|
|
callback(allCustomers, allEmployees, resourceDictionary);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
private void ConstructObject()
|
|
{
|
|
IsEmployeeBrushVisible = true;
|
|
|
|
InitializeComponent();
|
|
InitViewModel();
|
|
InitScheduler();
|
|
|
|
Scheduler.Storage.AppointmentStorage.ResourceSharing = false;
|
|
|
|
DataContext = this;
|
|
|
|
EditorLocalizer.Active = new GermanEditorLocalizer();
|
|
|
|
InitRights();
|
|
|
|
foreach(var item in from object item in TabControl.Items let ti = (TabItem)item where ti.Visibility.Equals(Visibility.Visible) select item)
|
|
{
|
|
TabControl.SelectedIndex = TabControl.Items.IndexOf(item);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//private void Synchronize()
|
|
//{
|
|
// var synchronizer = new OutlookExportSynchronizer(Scheduler.Storage.GetCoreStorage());
|
|
|
|
// if (OutlookCalendarPaths.Length <= 0) return;
|
|
|
|
// ((ISupportCalendarFolders) synchronizer).CalendarFolderName = OutlookCalendarPaths[0];
|
|
// synchronizer.ForeignIdFieldName = "OutlookEntryId";
|
|
|
|
// synchronizer.AppointmentSynchronizing += (sender, args) =>
|
|
// {
|
|
|
|
// };
|
|
|
|
|
|
// synchronizer.Synchronize();
|
|
//}
|
|
|
|
private bool _IstErsterAufruf = true;
|
|
|
|
#region InitViewModel
|
|
|
|
private void InitViewModel()
|
|
{
|
|
ViewModel = new NewSchedulerViewModel();
|
|
ViewModel.ViewModelChanged += ViewModel_ViewModelChanged;
|
|
ViewModel.ViewModelChanged += UpdateRequestStringEvent;
|
|
}
|
|
|
|
private void ViewModel_ViewModelChanged(object sender, EventArgs<ISchedulerViewModel> e)
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
UpdateDataSource(e.Data);
|
|
|
|
LoadSchedulerViewType();
|
|
|
|
if(_IstErsterAufruf)
|
|
{
|
|
if(MainControl.HatNeueTermine && !_IsComingFromHomeDragPanel)
|
|
{
|
|
FensterOeffnen();
|
|
}
|
|
|
|
_IstErsterAufruf = false;
|
|
}
|
|
});
|
|
}
|
|
|
|
private void InitScheduler()
|
|
{
|
|
if(_IsComingFromHomeDragPanel && _SelectedAppointmentStartDate.HasValue)
|
|
{
|
|
var monday = _SelectedAppointmentStartDate.Value.FirstDateOfWeek(_SelectedAppointmentStartDate.Value.GetIso8601WeekOfYear());
|
|
|
|
Scheduler.Start = monday;
|
|
}
|
|
else
|
|
{
|
|
Scheduler.Start = DateTime.Today;
|
|
|
|
}
|
|
|
|
_TimelineDayCount = 0;
|
|
Scheduler.DayView.NavigationButtonVisibility = NavigationButtonVisibility.Always;
|
|
Scheduler.DayView.AppointmentDisplayOptions.ShowRecurrence = true;
|
|
Scheduler.DayView.AppointmentDisplayOptions.ShowReminder = true;
|
|
Scheduler.DayView.ResourcesPerPage = 1;
|
|
|
|
Scheduler.WorkWeekView.ShowFullWeek = _IsComingFromHomeDragPanel && Scheduler.Start.DayOfWeek.Equals(DayOfWeek.Saturday) || Scheduler.Start.DayOfWeek.Equals(DayOfWeek.Sunday);
|
|
Scheduler.WorkWeekView.ShowWorkTimeOnly = false;
|
|
|
|
Scheduler.WorkWeekView.NavigationButtonVisibility = NavigationButtonVisibility.Always;
|
|
Scheduler.WorkWeekView.ResourcesPerPage = 1;
|
|
|
|
Scheduler.WeekView.NavigationButtonVisibility = NavigationButtonVisibility.Always;
|
|
Scheduler.WeekView.ResourcesPerPage = 1;
|
|
|
|
Scheduler.MonthView.NavigationButtonVisibility = NavigationButtonVisibility.Always;
|
|
Scheduler.MonthView.ResourcesPerPage = 1;
|
|
|
|
Scheduler.TimelineView.NavigationButtonVisibility = NavigationButtonVisibility.Always;
|
|
Scheduler.TimelineView.ResourcesPerPage = 1;
|
|
}
|
|
|
|
private void LoadSchedulerViewType()
|
|
{
|
|
var settings = ViewModel.GetActiveSettings();
|
|
|
|
_CurrentViewType = BeWoApp.AppSettings.SchedulerViewType;
|
|
Scheduler.ActiveViewType = _CurrentViewType;
|
|
Scheduler.DayView.DayCount = BeWoApp.AppSettings.SchedulerDayViewDayCount;
|
|
settings.DayViewCount = BeWoApp.AppSettings.SchedulerDayViewDayCount;
|
|
Scheduler.TimelineView.IntervalCount = BeWoApp.AppSettings.SchedulerTimelineViewDayCount;
|
|
settings.TimelineIntervalCount = BeWoApp.AppSettings.SchedulerTimelineViewDayCount;
|
|
|
|
UpdateOptionPanel();
|
|
|
|
switch(_CurrentViewType)
|
|
{
|
|
case SchedulerViewType.Day:
|
|
DayViewOptions.Visibility = Visibility.Visible;
|
|
TimelineViewOptions.Visibility = Visibility.Collapsed;
|
|
break;
|
|
case SchedulerViewType.Month:
|
|
var interval = Scheduler.ActiveView.GetVisibleIntervals();
|
|
Scheduler.ActiveView.SetVisibleIntervals(new TimeIntervalCollection {new TimeInterval(interval.Start, new TimeSpan(35, 0, 0, 0))});
|
|
|
|
UpdateOptionPanel();
|
|
break;
|
|
case SchedulerViewType.Timeline:
|
|
DayViewOptions.Visibility = Visibility.Collapsed;
|
|
TimelineViewOptions.Visibility = Visibility.Visible;
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void SaveSchedulerViewType(SchedulerViewType schedulerViewType)
|
|
{
|
|
BeWoApp.AppSettings.SchedulerViewType = schedulerViewType;
|
|
|
|
var settings = ViewModel.GetActiveSettings();
|
|
BeWoApp.AppSettings.SchedulerTimelineViewDayCount = settings.TimelineIntervalCount;
|
|
|
|
BeWoApp.SaveAppSettings();
|
|
}
|
|
|
|
private void InitRights()
|
|
{
|
|
MitarbeiterTabItem.Visibility = BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderMitarbeitertermineAnsehen) ? Visibility.Visible : Visibility.Collapsed;
|
|
RessourcenTabItem.Visibility = BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderRessourcentermineAnsehen) ? Visibility.Visible : Visibility.Collapsed;
|
|
KlientenTabItem.Visibility = BeWoApp.LoggedOnUser.HasRight(UserRightType.CustomerView_View) || BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_ViewMyTeams) || BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_ViewMyCustomers)
|
|
|| BeWoApp.LoggedOnUser.HasRight(UserRightType.ViewAll)
|
|
? Visibility.Visible
|
|
: Visibility.Collapsed;
|
|
|
|
MitarbeiterEbenenCheckBox.Visibility = MitarbeiterTabItem.Visibility;
|
|
RessourcenEbenenCheckBox.Visibility = RessourcenTabItem.Visibility;
|
|
KlientenEbenenCheckBox.Visibility = KlientenTabItem.Visibility;
|
|
MitarbeiterfarbenEinAusCheckBox.Visibility = MitarbeiterTabItem.Visibility;
|
|
|
|
ButtonDeleteAppointments.Visibility = BeWoApp.LoggedOnUser.HasRight(UserRightType.Termine_IntervalDelete) ? Visibility.Visible : Visibility.Collapsed;
|
|
}
|
|
|
|
private void UpdateDataSource(ISchedulerViewModel vm)
|
|
{
|
|
try
|
|
{
|
|
IgnoreChangeEvents = true;
|
|
|
|
Scheduler.Storage.BeginUpdate();
|
|
UpdateCustomFieldMappings(vm);
|
|
Scheduler.Storage.EndUpdate();
|
|
|
|
// DateTime.MaxValue wird nicht unterstützt, weil zu dem EndDate noch etwas draufaddiert wird und dann der MaxValue überschritten werden würde
|
|
Scheduler.Storage.AppointmentStorage.DataSource = vm.Appointments;
|
|
|
|
Scheduler.Storage.BeginUpdate();
|
|
|
|
UpdateSchedulerSettings();
|
|
|
|
foreach(var item in Scheduler.Storage.AppointmentStorage.Items)
|
|
{
|
|
var bapp = item.GetSourceObject(Scheduler.GetCoreStorage()) as IBeWoAppointment;
|
|
|
|
if(item.IsRecurring)
|
|
{
|
|
var ausnahmen = item.GetExceptions();
|
|
foreach(var exc in ausnahmen)
|
|
{
|
|
var b = exc.GetSourceObject(Scheduler.GetCoreStorage()) as IBeWoAppointment;
|
|
if(b?.CustomFields == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
foreach(var field in b.CustomFields)
|
|
{
|
|
exc.CustomFields[field.Key] = field.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(bapp?.CustomFields == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
foreach(var field in bapp.CustomFields)
|
|
{
|
|
item.CustomFields[field.Key] = field.Value;
|
|
}
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
throw e;
|
|
}
|
|
finally
|
|
{
|
|
Scheduler.Storage.EndUpdate();
|
|
IgnoreChangeEvents = false;
|
|
}
|
|
}
|
|
|
|
private void UpdateSchedulerSettings()
|
|
{
|
|
var settings = ViewModel.GetActiveSettings();
|
|
Scheduler.Start = settings.StartDate;
|
|
var starttimeInterval = settings.StartDate.Date;
|
|
|
|
if(_SelectedAppointmentStartDate.HasValue)
|
|
{
|
|
var weekOfYear = _SelectedAppointmentStartDate.Value.GetIso8601WeekOfYear();
|
|
var monday = _SelectedAppointmentStartDate.Value.FirstDateOfWeek(weekOfYear);
|
|
|
|
settings.StartDate = monday;
|
|
|
|
Scheduler.Start = monday;
|
|
starttimeInterval = settings.StartDate;
|
|
|
|
settings.ViewType = _SelectedAppointmentStartDate.Value.DayOfWeek == DayOfWeek.Saturday || _SelectedAppointmentStartDate.Value.DayOfWeek == DayOfWeek.Sunday ? AppointmentViewType.Week : AppointmentViewType.WorkWeek;
|
|
_SelectedAppointmentStartDate = null;
|
|
}
|
|
else
|
|
{
|
|
settings.ViewType = ViewTypeConvert.ToAppointmentViewType(_CurrentViewType);
|
|
}
|
|
|
|
starttimeInterval = starttimeInterval.AddHours(Scheduler.WorkWeekView.WorkTime.Start.Hours);
|
|
|
|
|
|
switch(settings.ViewType)
|
|
{
|
|
case AppointmentViewType.Day:
|
|
Scheduler.ActiveViewType = SchedulerViewType.Day;
|
|
Scheduler.ActiveView.GotoTimeInterval(new TimeInterval(starttimeInterval, new TimeSpan(8, 0, 0)));
|
|
Scheduler.DayView.DayCount = settings.DayViewCount;
|
|
break;
|
|
case AppointmentViewType.Week:
|
|
Scheduler.ActiveViewType = SchedulerViewType.Week;
|
|
Scheduler.ActiveView.GotoTimeInterval(new TimeInterval(starttimeInterval, new TimeSpan(8, 0, 0)));
|
|
break;
|
|
case AppointmentViewType.Month:
|
|
Scheduler.ActiveViewType = SchedulerViewType.Month;
|
|
break;
|
|
case AppointmentViewType.WorkWeek:
|
|
Scheduler.ActiveViewType = SchedulerViewType.WorkWeek;
|
|
Scheduler.ActiveView.GotoTimeInterval(new TimeInterval(starttimeInterval, new TimeSpan(8, 0, 0)));
|
|
break;
|
|
case AppointmentViewType.Timeline:
|
|
Scheduler.ActiveViewType = SchedulerViewType.Timeline;
|
|
Scheduler.TimelineView.ResourcesPerPage = settings.TimelineResourceCount;
|
|
Scheduler.TimelineView.IntervalCount = settings.TimelineIntervalCount;
|
|
break;
|
|
}
|
|
|
|
UpdateOptionPanel();
|
|
|
|
try
|
|
{
|
|
Scheduler.GroupType = settings.GroupByResource ? SchedulerGroupType.Resource : SchedulerGroupType.None;
|
|
|
|
Scheduler.OptionsCustomization.AllowAppointmentCreate = UsedAppointmentType.Custom;
|
|
Scheduler.OptionsCustomization.AllowAppointmentDrag = UsedAppointmentType.Custom;
|
|
Scheduler.OptionsCustomization.AllowAppointmentDelete = UsedAppointmentType.Custom;
|
|
Scheduler.OptionsCustomization.AllowAppointmentEdit = UsedAppointmentType.Custom;
|
|
Scheduler.OptionsCustomization.AllowAppointmentDragBetweenResources = UsedAppointmentType.Custom;
|
|
}
|
|
catch(Exception)
|
|
{
|
|
MessageBox.Show("Ein Fehler bei der Darstellung ist aufgetreten.", "Fehler", MessageBoxButton.OK, MessageBoxImage.Error);
|
|
}
|
|
}
|
|
|
|
private void UpdateCustomFieldMappings(ISchedulerViewModel vm)
|
|
{
|
|
Scheduler.Storage.AppointmentStorage.CustomFieldMappings.Clear();
|
|
vm.AddCustomFieldsMapping(Scheduler.Storage);
|
|
}
|
|
|
|
#endregion
|
|
|
|
public CheckBoxConverter CheckBoxConverter => Resources[nameof(CheckBoxConverter)] as CheckBoxConverter;
|
|
|
|
#region Filterauswahl
|
|
|
|
private void AlleMitarbeiterCB_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
if(sender is CheckBox checkBox)
|
|
{
|
|
var isChecked = checkBox.IsChecked ?? false;
|
|
|
|
SelectedEmployees = isChecked ? new List<CompactEmployeeDC>(AllEmployees) : new List<CompactEmployeeDC>();
|
|
|
|
if(SelectedEmployees.Count > 1)
|
|
{
|
|
ZeigeNurMeineTermine = false;
|
|
}
|
|
|
|
TeamMembersCheckBox.IsChecked = false;
|
|
|
|
return;
|
|
}
|
|
|
|
var cb = (CheckBox) sender;
|
|
if(!cb.IsChecked.HasValue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SelectedEmployees = cb.IsChecked.Value ? new List<CompactEmployeeDC>(AllEmployees) : new List<CompactEmployeeDC>();
|
|
|
|
if(SelectedEmployees.Count > 1)
|
|
{
|
|
ZeigeNurMeineTermine = false;
|
|
}
|
|
}
|
|
|
|
private void MitarbeiterListe_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox) sender;
|
|
|
|
if(CheckBoxConverter != null && cb.DataContext is CompactEmployeeDC selectedEmployee)
|
|
{
|
|
CheckBoxConverter.AktuellerMitarbeiter = selectedEmployee;
|
|
}
|
|
}
|
|
|
|
private void AlleRessourcenCB_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox) sender;
|
|
if(!cb.IsChecked.HasValue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SelectedResources = cb.IsChecked.Value ? new List<ResourceDC>(AllResources) : new List<ResourceDC>();
|
|
if(CheckBoxConverter != null && SelectedResources != null)
|
|
{
|
|
CheckBoxConverter.SelektierteRessourcen = SelectedResources;
|
|
ReloadVM(true);
|
|
}
|
|
}
|
|
|
|
private void RessourcenTV_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox) sender;
|
|
|
|
if(CheckBoxConverter != null && cb.DataContext is ResourceDC selectedResource)
|
|
{
|
|
CheckBoxConverter.AktuelleRessource = selectedResource;
|
|
}
|
|
}
|
|
|
|
private void AlleKlientennCB_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox) sender;
|
|
if(!cb.IsChecked.HasValue) return;
|
|
|
|
if(NurMeineKlientenCB.IsChecked.HasValue && NurMeineKlientenCB.IsChecked.Value)
|
|
{
|
|
SelectedCustomers = cb.IsChecked.Value ? new List<CompactCustomerDC>(GefilterteKlienten) : new List<CompactCustomerDC>();
|
|
}
|
|
else
|
|
{
|
|
SelectedCustomers = cb.IsChecked.Value ? new List<CompactCustomerDC>(AllCustomers) : new List<CompactCustomerDC>();
|
|
}
|
|
}
|
|
|
|
private void KlientenListe_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox) sender;
|
|
|
|
if(CheckBoxConverter != null && cb.DataContext is CompactCustomerDC selectedCustomer)
|
|
{
|
|
CheckBoxConverter.AktuellerKlient = selectedCustomer;
|
|
}
|
|
}
|
|
|
|
private void ListItemCheckedEvent(object sender, RoutedEventArgs e)
|
|
{
|
|
ReloadVM(true);
|
|
}
|
|
|
|
private void BtnRemoveElement_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var selectedDC = ((Button) sender).Tag as IDataContract;
|
|
|
|
switch(selectedDC)
|
|
{
|
|
case CompactEmployeeDC _:
|
|
var employee = selectedDC as CompactEmployeeDC;
|
|
SelectedEmployees.Remove(employee);
|
|
OnPropertyChanged(nameof(SelectedEmployees));
|
|
|
|
if(employee != null && employee.Equals(BeWoApp.CompactLoggedOnEmployee))
|
|
{
|
|
ZeigeNurMeineTermine = false;
|
|
ReloadVM(true);
|
|
}
|
|
else if(SelectedEmployees.Count == 1 && SelectedEmployees.First().Equals(BeWoApp.CompactLoggedOnEmployee))
|
|
{
|
|
ZeigeNurMeineTermine = true;
|
|
}
|
|
|
|
break;
|
|
case CompactCustomerDC _:
|
|
var customer = selectedDC as CompactCustomerDC;
|
|
|
|
SelectedCustomers.Remove(customer);
|
|
OnPropertyChanged(nameof(SelectedCustomers));
|
|
|
|
break;
|
|
case ResourceDC _:
|
|
var resource = selectedDC as ResourceDC;
|
|
|
|
SelectedResources.Remove(resource);
|
|
OnPropertyChanged(nameof(SelectedResources));
|
|
|
|
break;
|
|
}
|
|
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
}
|
|
|
|
private void ButtonDayView_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Scheduler.ActiveViewType = SchedulerViewType.Day;
|
|
_CurrentViewType = Scheduler.ActiveViewType;
|
|
UpdateOptionPanel();
|
|
|
|
DayViewOptions.Visibility = Visibility.Visible;
|
|
TimelineViewOptions.Visibility = Visibility.Collapsed;
|
|
|
|
SaveSchedulerViewType(SchedulerViewType.Day);
|
|
}
|
|
|
|
private void ButtonMonthView_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Scheduler.ActiveViewType = SchedulerViewType.Month;
|
|
_CurrentViewType = Scheduler.ActiveViewType;
|
|
var interval = Scheduler.ActiveView.GetVisibleIntervals();
|
|
Scheduler.ActiveView.SetVisibleIntervals(new TimeIntervalCollection {new TimeInterval(interval.Start, new TimeSpan(35, 0, 0, 0))});
|
|
|
|
UpdateOptionPanel();
|
|
|
|
SaveSchedulerViewType(SchedulerViewType.Month);
|
|
}
|
|
|
|
private void ButtonWorkWeekView_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Scheduler.ActiveViewType = SchedulerViewType.WorkWeek;
|
|
_CurrentViewType = Scheduler.ActiveViewType;
|
|
UpdateOptionPanel();
|
|
|
|
SaveSchedulerViewType(SchedulerViewType.WorkWeek);
|
|
}
|
|
|
|
private void ButtonWeekView_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Scheduler.ActiveViewType = SchedulerViewType.Week;
|
|
_CurrentViewType = Scheduler.ActiveViewType;
|
|
UpdateOptionPanel();
|
|
|
|
SaveSchedulerViewType(SchedulerViewType.Week);
|
|
}
|
|
|
|
private void ButtonTimelineView_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Scheduler.ActiveViewType = SchedulerViewType.Timeline;
|
|
_CurrentViewType = Scheduler.ActiveViewType;
|
|
UpdateOptionPanel();
|
|
|
|
DayViewOptions.Visibility = Visibility.Collapsed;
|
|
TimelineViewOptions.Visibility = Visibility.Visible;
|
|
|
|
SaveSchedulerViewType(SchedulerViewType.Timeline);
|
|
}
|
|
|
|
private void SpinEditDayViewDayCount_EditValueChanged(object sender, EditValueChangedEventArgs e)
|
|
{
|
|
if(e.NewValue != null && int.TryParse(e.NewValue.ToString(), out var count) && count > 0)
|
|
{
|
|
Scheduler.DayView.DayCount = count;
|
|
_TimelineDayCount = count;
|
|
|
|
BeWoApp.AppSettings.SchedulerDayViewDayCount = count;
|
|
}
|
|
}
|
|
|
|
private void SpinEditTimelineViewDayCount_EditValueChanged(object sender, EditValueChangedEventArgs e)
|
|
{
|
|
if(e.NewValue != null && int.TryParse(e.NewValue.ToString(), out var count) && count > 0)
|
|
{
|
|
Scheduler.TimelineView.IntervalCount = count;
|
|
_TimelineDayCount = count;
|
|
|
|
BeWoApp.AppSettings.SchedulerTimelineViewDayCount = count;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
private bool _Enabled;
|
|
|
|
public bool Enabled
|
|
{
|
|
get => _Enabled;
|
|
set
|
|
{
|
|
_Enabled = value;
|
|
OnPropertyChanged(nameof(Enabled));
|
|
}
|
|
}
|
|
|
|
public void UpdateRequestString()
|
|
{
|
|
if (_disableUpdateRequestString)
|
|
{
|
|
return;
|
|
}
|
|
ServiceFacade.DoResourceServiceSync(r => _Liste = r.GetAllOpenAppointmentsForEmployee(BeWoApp.LoggedOnEmployee.EmployeeOid.Value));
|
|
|
|
var count = 0;
|
|
var oidList = new List<long>();
|
|
foreach(var termin in _Liste)
|
|
{
|
|
if(termin.Originator.EmployeeOid == BeWoApp.LoggedOnEmployee.EmployeeOid.Value)
|
|
{
|
|
foreach(var status in termin.EmployeeList.Where(w => w.Employee.EmployeeOid != BeWoApp.LoggedOnEmployee.EmployeeOid.Value))
|
|
{
|
|
if(status.IsPChanged && status.ParticipationAnswer != ParticipationAnswer.Offen && status.ParticipationAnswer != ParticipationAnswer.Verstrichen && !oidList.Contains(status.Employee2SchedulerAppointmentOid.Value))
|
|
{
|
|
oidList.Add(status.Employee2SchedulerAppointmentOid.Value);
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(termin.EmployeeList.Any(a => a.Employee.EmployeeOid == BeWoApp.LoggedOnEmployee.EmployeeOid.Value))
|
|
{
|
|
foreach(var status in termin.EmployeeList.Where(w => w.Employee.EmployeeOid == BeWoApp.LoggedOnEmployee.EmployeeOid.Value))
|
|
{
|
|
if(!status.IsPChanged && status.ParticipationAnswer == ParticipationAnswer.Offen && status.ParticipationAnswer != ParticipationAnswer.Verstrichen && !oidList.Contains(status.Employee2SchedulerAppointmentOid.Value))
|
|
{
|
|
oidList.Add(status.Employee2SchedulerAppointmentOid.Value);
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Enabled = count > 0;
|
|
Requests = $"{(count == 0 ? "keine" : count.ToString())} Benachrichtigung{(count == 1 ? "" : "en")}";
|
|
}
|
|
|
|
private List<SchedulerAppointmentDC> _Liste = new List<SchedulerAppointmentDC>();
|
|
|
|
private void NewSchedulerStorage_AppointmentsChanged(object sender, PersistentObjectsEventArgs e)
|
|
{
|
|
var appList = e.Objects.Cast<Appointment>().ToList();
|
|
|
|
if (IgnoreChangeEvents || IgnoreManualAppointmentCreation)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(appList.Any(f => f.CF_IsPrivate()))
|
|
{
|
|
ShowPrivateAppointmentsCheckBox.IsChecked = true;
|
|
}
|
|
|
|
var changedAppointments = appList.Where(appointment => appointment.Type != AppointmentType.DeletedOccurrence).ToList();
|
|
|
|
ViewModel.ActiveAppointmentViewModel.SaveAppointments(Scheduler, changedAppointments);
|
|
|
|
ReloadVM(true);
|
|
}
|
|
|
|
private int _NumberOfAppointmentsToDelete;
|
|
private readonly List<SchedulerAppointmentDC> _AppointmentsToDelete = new List<SchedulerAppointmentDC>();
|
|
|
|
private void NewSchedulerStorage_AppointmentDeleting(object sender, PersistentObjectCancelEventArgs e)
|
|
{
|
|
var appointment = (Appointment) e.Object;
|
|
|
|
var items = Scheduler.Storage.AppointmentStorage.Items;
|
|
|
|
if(appointment.IsRecurring)
|
|
{
|
|
var aptList = new List<SchedulerAppointmentVM>();
|
|
|
|
foreach(var item in items)
|
|
{
|
|
var apt = item.GetSourceObject(Scheduler.GetCoreStorage()) as SchedulerAppointmentVM;
|
|
|
|
aptList.Add(apt);
|
|
}
|
|
|
|
var serientermine = aptList.Where(w => w.RecurrenceInfo != null && w.RecurrenceInfo.Contains(appointment.RecurrenceInfo.Id.ToString()) && w.EventType == 1).ToList();
|
|
|
|
var root = serientermine.FirstOrDefault();
|
|
|
|
if(root?.CustomFields[nameof(CustomFieldStorage)] != null)
|
|
{
|
|
var customFieldStorage = (CustomFieldStorage) root.CustomFields[nameof(CustomFieldStorage)];
|
|
|
|
if(customFieldStorage.InternalInfo?.IsTimeChangedRecurringAppointment ?? false)
|
|
{
|
|
e.Cancel = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
var selectedAppointmentCount = Scheduler.SelectedAppointments.Count;
|
|
|
|
if(_NumberOfAppointmentsToDelete == 0)
|
|
{
|
|
_NumberOfAppointmentsToDelete = selectedAppointmentCount;
|
|
}
|
|
|
|
var sourceObj = (SchedulerAppointmentVM) appointment.GetSourceObject(Scheduler.GetCoreStorage());
|
|
|
|
if(!(sourceObj is null))
|
|
{
|
|
var customerOids = new List<long>();
|
|
ServiceFacade.DoEmployeeServiceSync(s => customerOids = s.LoadTeamsRelatedCustomerOids(BeWoApp.CompactLoggedOnEmployee.EmployeeOid));
|
|
|
|
if(!BeWoUtils.CheckSchedulerRights(appointment, sourceObj.IsNew, SchedulerRightsCheckType.Edit, customerOids, true))
|
|
{
|
|
e.Cancel = true;
|
|
return;
|
|
}
|
|
|
|
if(e.Object is Appointment app)
|
|
{
|
|
e.Cancel = PrepareDeletion(app);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(e.Object is Appointment app)
|
|
{
|
|
e.Cancel = PrepareDeletion(app);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool PrepareDeletion(Appointment appointment)
|
|
{
|
|
var shouldCancel = false;
|
|
|
|
var msg = GetDeleteMessageForAppointment(appointment);
|
|
|
|
var dataContract = appointment.GetSourceObject(Scheduler.GetCoreStorage()) is SchedulerAppointmentVM schedulerAppointmentVM ? schedulerAppointmentVM.CommitToDataContract() : CreateDummyAppointment(appointment);
|
|
|
|
if(dataContract.SchedulerAppointmentOid.HasValue)
|
|
{
|
|
// Nur bei Normalem Typ nachfragen. Bei Serienterminen wird bereits im Fenster vorher gefragt, ob gelöscht werden soll.
|
|
if (appointment.Type == AppointmentType.Normal && MessageBox.Show(msg, "BeWoPlaner", MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.No)
|
|
{
|
|
shouldCancel = true;
|
|
|
|
if(_NumberOfAppointmentsToDelete > 0)
|
|
{
|
|
_NumberOfAppointmentsToDelete--;
|
|
}
|
|
|
|
_AppointmentsToDelete.Remove(dataContract);
|
|
}
|
|
else
|
|
{
|
|
_AppointmentsToDelete.AddIfNotIn(dataContract);
|
|
|
|
if(_AppointmentsToDelete.Count == _NumberOfAppointmentsToDelete)
|
|
{
|
|
DeleteAppointments();
|
|
}
|
|
}
|
|
}
|
|
|
|
return shouldCancel;
|
|
}
|
|
|
|
private long _DummyOid = -1;
|
|
|
|
private SchedulerAppointmentDC CreateDummyAppointment(Appointment appointment)
|
|
{
|
|
var dummyAppointment = new SchedulerAppointmentDC
|
|
{
|
|
SchedulerAppointmentOid = _DummyOid,
|
|
Subject = appointment.Subject,
|
|
StartDate = appointment.Start,
|
|
EndDate = appointment.End
|
|
};
|
|
|
|
_DummyOid--;
|
|
|
|
return dummyAppointment;
|
|
}
|
|
|
|
private void DeleteAppointments()
|
|
{
|
|
var stringBuilder = new StringBuilder();
|
|
|
|
foreach(var appointment in _AppointmentsToDelete.OrderBy(o => o.StartDate).ThenBy(o => o.EndDate))
|
|
{
|
|
var oid = appointment.SchedulerAppointmentOid?.ToString() ?? "NO OID";
|
|
var start = appointment.StartDate.Value;
|
|
var end = appointment.EndDate.Value;
|
|
|
|
string type;
|
|
|
|
switch(appointment.Type)
|
|
{
|
|
case 0:
|
|
type = "Normal";
|
|
break;
|
|
case 1:
|
|
type = "Pattern";
|
|
break;
|
|
case 2:
|
|
type = "Occurrence";
|
|
break;
|
|
case 3:
|
|
type = "ChangedOccurrence";
|
|
break;
|
|
case 4:
|
|
type = "DeletedOccurrence";
|
|
break;
|
|
default:
|
|
type = "Normal";
|
|
break;
|
|
}
|
|
|
|
stringBuilder.AppendLine($"\tOid:\t\t{oid}\r\n\tBetreff: {appointment.Subject}\r\n\tStart:\t\t{start:dd.MM.yyyy HH:mm}\r\n\tEnde:\t\t{end:dd.MM.yyyy HH:mm}\r\n\tTyp:\t\t{type}\r\n");
|
|
}
|
|
|
|
//BeWoApp.LogMessage($"DeleteAppointments aufgerufen. Es {(_AppointmentsToDelete.Count == 1 ? "wird" : "werden")} {_AppointmentsToDelete.Count} {(_AppointmentsToDelete.Count == 1 ? "Termin" : "Termine")} gelöscht\n{stringBuilder}", Colors.Red);
|
|
|
|
var idList = (from item in _AppointmentsToDelete where item.SchedulerAppointmentOid.HasValue && item.SchedulerAppointmentOid.Value > 0 select item.SchedulerAppointmentOid.Value).ToList();
|
|
|
|
IgnoreChangeEvents = true;
|
|
|
|
ServiceFacade.DoResourceServiceAsync(s => s.GetSchedulerAppointmentsById(idList), appointments2 =>
|
|
{
|
|
var oids2Versions = appointments2.ToDictionary(dc => dc.SchedulerAppointmentOid.Value, dc => dc.NewSchedulerAppointmentVersion.Value);
|
|
|
|
ServiceFacade.DoResourceServiceAsync(s2 => s2.DeactivateSchedulerAppointmentsForSync(oids2Versions), updatedAppointments2 =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
ViewModel.ActiveAppointmentViewModel.UpdateViewModel(updatedAppointments2);
|
|
|
|
Scheduler.ActiveView.LayoutChanged();
|
|
UpdateRequestString();
|
|
ReloadVM(true);
|
|
|
|
ResetDeletionMode();
|
|
|
|
IgnoreChangeEvents = false;
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
private static string GetDeleteMessageForAppointment(Appointment appointment)
|
|
{
|
|
var message = "Möchten Sie den gewählten Termin wirklich löschen?";
|
|
|
|
if(appointment != null)
|
|
{
|
|
var subject = appointment.Subject;
|
|
|
|
var interval = GetAppointmentTimeString(appointment);
|
|
|
|
message = $"Möchten Sie den gewählten Termin \"{subject}\" vom {interval} wirklich löschen?";
|
|
}
|
|
|
|
return message;
|
|
}
|
|
|
|
public static string GetAppointmentTimeString(Appointment appointment)
|
|
{
|
|
var interval = string.Empty;
|
|
|
|
if(appointment != null)
|
|
{
|
|
var start = appointment.Start;
|
|
var end = appointment.End;
|
|
|
|
// 1. 17. August 2021 09:00 Uhr bis 10:00 Uhr
|
|
// 2. 17. August 2021
|
|
// 3. 17. August 2021 09:00 Uhr bis 19. August 2021 10 Uhr
|
|
// 4. 17. August 2021 bis 19. August 2021
|
|
|
|
if(start.Date == end.Date)
|
|
{
|
|
interval = appointment.AllDay ? $"{start:dd. MMMM yyyy}" : $"{start:dd. MMMM yyyy HH:mm} Uhr bis {end:HH:mm} Uhr";
|
|
}
|
|
else
|
|
{
|
|
interval = appointment.AllDay ? $"{start:dd. MMMM yyyy} bis zum {end:dd. MMMM yyyy}" : $"{start: dd. MMMM yyyy HH:mm} Uhr bis zum {end:dd. MMMM yyyy HH:mm} Uhr";
|
|
}
|
|
}
|
|
|
|
return interval;
|
|
}
|
|
|
|
private void ResetDeletionMode()
|
|
{
|
|
_AppointmentsToDelete.Clear();
|
|
_NumberOfAppointmentsToDelete = 0;
|
|
_DummyOid = 0;
|
|
}
|
|
|
|
private void NewSchedulerStorage_AppointmentsInserted(object sender, PersistentObjectsEventArgs e)
|
|
{
|
|
if(IgnoreManualAppointmentCreation)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var appList = e.Objects.Cast<Appointment>().ToList();
|
|
|
|
if(appList.Any(f => f.CF_IsPrivate()))
|
|
{
|
|
ShowPrivateAppointmentsCheckBox.IsChecked = true;
|
|
}
|
|
|
|
ViewModel.ActiveAppointmentViewModel.InsertAppointments(Scheduler, appList);
|
|
UpdateRequestString();
|
|
ReloadVM(true);
|
|
}
|
|
|
|
private void Scheduler_EditAppointmentFormShowing(object sender, EditAppointmentFormEventArgs e)
|
|
{
|
|
var control = (SchedulerControl) sender;
|
|
|
|
IgnoreChangeEvents = true;
|
|
|
|
if(_IsNew)
|
|
{
|
|
var n = new ObservableCollection<Employee2SchedulerAppointmentDC>(SelectedEmployees.Select(item => new Employee2SchedulerAppointmentDC {Employee = item, ParticipationAnswer = ParticipationAnswer.Offen}).ToList());
|
|
e.Appointment.CF_EmployeeList(n);
|
|
e.Appointment.CF_CustomerList(new List<CompactCustomerDC>(SelectedCustomers));
|
|
e.Appointment.CF_ResourceList(new List<ResourceDC>(SelectedResources));
|
|
}
|
|
|
|
var form = ViewModel.GetEditAppointmentForm(control, e.Appointment);
|
|
if(form == null)
|
|
{
|
|
if(_IsNew)
|
|
{
|
|
_IsNew = false;
|
|
}
|
|
|
|
IgnoreChangeEvents = false;
|
|
|
|
return;
|
|
}
|
|
|
|
e.Form = form;
|
|
e.AllowResize = false;
|
|
|
|
if(_IsNew)
|
|
{
|
|
_IsNew = false;
|
|
}
|
|
|
|
IgnoreChangeEvents = false;
|
|
}
|
|
|
|
private void SchedulerControl_EditRecurrentAppointmentFormShowing(object sender, EditAppointmentFormEventArgs e)
|
|
{
|
|
}
|
|
|
|
private void Scheduler_PopupMenuShowing(object sender, SchedulerMenuEventArgs e)
|
|
{
|
|
if(Scheduler.SelectedAppointments?.Count == 1)
|
|
{
|
|
var customerOids = new List<long>();
|
|
ServiceFacade.DoEmployeeServiceSync(s => customerOids = s.LoadTeamsRelatedCustomerOids(BeWoApp.CompactLoggedOnEmployee.EmployeeOid));
|
|
|
|
bool isAllowedToEdit;
|
|
var test = Scheduler.SelectedAppointments.First();
|
|
if(test.IsOccurrence)
|
|
{
|
|
var patternAppointment = test.RecurrencePattern;
|
|
var sourceObject = patternAppointment.GetSourceObject(Scheduler.GetCoreStorage());
|
|
var viewModel = (SchedulerAppointmentVM) sourceObject;
|
|
|
|
isAllowedToEdit = BeWoUtils.CheckSchedulerRights(test, viewModel.IsNew, SchedulerRightsCheckType.Edit, customerOids, true);
|
|
}
|
|
else
|
|
{
|
|
isAllowedToEdit = Scheduler.SelectedAppointments.Any(a => BeWoUtils.CheckSchedulerRights(a, ((SchedulerAppointmentVM) a.GetSourceObject(Scheduler.GetCoreStorage())).IsNew, SchedulerRightsCheckType.Edit, customerOids, true));
|
|
}
|
|
|
|
if(!isAllowedToEdit)
|
|
{
|
|
var menuItem = e.Menu.ItemLinks.FirstOrDefault(f => f.Name.Contains("DeleteAppointment"));
|
|
|
|
if(menuItem != null)
|
|
{
|
|
e.Menu.ItemLinks.Remove(menuItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderMitarbeitertermineAnsehen) || !BeWoApp.LoggedOnUser.HasRight(UserRightType.Mitarbeiterstundenkonto_ViewAll))
|
|
{
|
|
var verfuegbarkeitMenue = e.Menu.ItemLinks.FirstOrDefault(f => f.GetType() == typeof(BarButtonItemLink) && (((BarButtonItemLink) f).Item?.Name.Contains("MitarbeiterVerfuegbarkeitPruefenButtonItem") ?? false));
|
|
|
|
if(verfuegbarkeitMenue != null)
|
|
{
|
|
e.Menu.ItemLinks.Remove(verfuegbarkeitMenue);
|
|
}
|
|
}
|
|
|
|
if(Scheduler.SelectedAppointments.Count == 0 || Scheduler.SelectedAppointments[0]?.Type != AppointmentType.ChangedOccurrence)
|
|
{
|
|
var restoreMenu = e.Menu.ItemLinks.FirstOrDefault(f =>
|
|
{
|
|
var type = f.GetType();
|
|
if(type == typeof(BarButtonItemLink))
|
|
{
|
|
var item = (BarButtonItemLink) f;
|
|
|
|
if(item.Name.Contains("RestoreAppointmentButtonItem"))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
});
|
|
|
|
if(restoreMenu != null)
|
|
{
|
|
e.Menu.ItemLinks.Remove(restoreMenu);
|
|
}
|
|
}
|
|
|
|
if(!BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderInZeiterfassungUebernehmen))
|
|
{
|
|
BarItemLinkBase menuItem = null;
|
|
|
|
foreach(var item in e.Menu.ItemLinks)
|
|
{
|
|
if(item.GetType() == typeof(BarButtonItemLink))
|
|
{
|
|
var barButton = (BarButtonItemLink) item;
|
|
|
|
if(barButton.Name.Contains("ZeiterfassungButtonItem"))
|
|
{
|
|
menuItem = item;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(menuItem != null)
|
|
{
|
|
e.Menu.ItemLinks.Remove(menuItem);
|
|
}
|
|
|
|
}
|
|
|
|
if(Scheduler.SelectedAppointments.Count > 0)
|
|
{
|
|
var zusageButton = e.Menu.ItemLinks.FirstOrDefault(f => f.GetType() == typeof(BarButtonItemLink) && ((BarButtonItemLink) f).BarItemName.Equals("ZusagenButtonItem"));
|
|
var mitVorbehaltButton = e.Menu.ItemLinks.FirstOrDefault(f => f.GetType() == typeof(BarButtonItemLink) && ((BarButtonItemLink) f).BarItemName.Equals("MitVorbehaltButtonItem"));
|
|
var absageButton = e.Menu.ItemLinks.FirstOrDefault(f => f.GetType() == typeof(BarButtonItemLink) && ((BarButtonItemLink) f).BarItemName.Equals("AbsagenButtonItem"));
|
|
var seperatorTop = e.Menu.ItemLinks.FirstOrDefault(f => f.GetType() == typeof(BarItemLinkSeparator) && ((BarItemLinkSeparator) f).BarItemName.Equals("ZusagenStackSeperatorTop"));
|
|
var seperatorBottom = e.Menu.ItemLinks.FirstOrDefault(f => f.GetType() == typeof(BarItemLinkSeparator) && ((BarItemLinkSeparator) f).BarItemName.Equals("ZusagenStackSeperatorBottom"));
|
|
|
|
if(!Scheduler.SelectedAppointments[0].CF_IsTask() && Scheduler.SelectedAppointments[0].CF_EmployeeList().Any(a => a.Employee.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(seperatorTop != null)
|
|
{
|
|
e.Menu.ItemLinks.Remove(seperatorTop);
|
|
}
|
|
|
|
if(seperatorBottom != null)
|
|
{
|
|
e.Menu.ItemLinks.Remove(seperatorBottom);
|
|
}
|
|
|
|
if(zusageButton != null)
|
|
{
|
|
e.Menu.ItemLinks.Remove(zusageButton);
|
|
}
|
|
|
|
if(mitVorbehaltButton != null)
|
|
{
|
|
e.Menu.ItemLinks.Remove(mitVorbehaltButton);
|
|
}
|
|
|
|
if(absageButton != null)
|
|
{
|
|
e.Menu.ItemLinks.Remove(absageButton);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool _IsNew;
|
|
|
|
private void Scheduler_InitNewAppointment(object sender, AppointmentEventArgs e)
|
|
{
|
|
_IsNew = true;
|
|
ViewModel.InitNewAppointment(e.Appointment);
|
|
}
|
|
|
|
private void Scheduler_AppointmentViewInfoCustomizing(object sender, AppointmentViewInfoCustomizingEventArgs e)
|
|
{
|
|
var customFields = e.ViewInfo.Appointment.CustomFields;
|
|
|
|
if(customFields[nameof(CustomFieldStorage)] == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
customFields.BeginUpdate();
|
|
|
|
e.ViewInfo.CustomViewInfo = customFields;
|
|
|
|
customFields.EndUpdate();
|
|
}
|
|
|
|
private void AllowAppointmentAenderung(object sender, AppointmentOperationEventArgs e)
|
|
{
|
|
var darfTerminDetailsSehen = true;
|
|
var appointment = e.Appointment;
|
|
|
|
if(appointment.GetCustomFieldStorage() is null)
|
|
{
|
|
e.Allow = false;
|
|
return;
|
|
}
|
|
|
|
if(appointment.CF_IsAbsenceTime())
|
|
{
|
|
e.Allow = false;
|
|
return;
|
|
}
|
|
|
|
var ersteller = appointment.CF_Originator();
|
|
var mitarbeiterliste = appointment.CF_EmployeeList();
|
|
var istErsteller = ersteller?.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid) ?? false;
|
|
|
|
if(!istErsteller && appointment.CF_IsPrivate() && !mitarbeiterliste.Any(a => Equals(a.Employee, BeWoApp.CompactLoggedOnEmployee)) || !appointment.CF_CanBeEdited())
|
|
{
|
|
darfTerminDetailsSehen = false;
|
|
}
|
|
|
|
e.Allow = darfTerminDetailsSehen;
|
|
}
|
|
|
|
private void AllowAppointmentCreateEvent(object sender, AppointmentOperationEventArgs e)
|
|
{
|
|
e.Allow = BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderAnsehen) || BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderKliententermineAnlegen) || BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderMitarbeitertermineAnlegen);
|
|
}
|
|
|
|
private void UpdateOptionPanel()
|
|
{
|
|
switch(ViewTypeConvert.ToAppointmentViewType(_CurrentViewType))
|
|
{
|
|
case AppointmentViewType.Day:
|
|
TimelineViewOptions.Visibility = Visibility.Collapsed;
|
|
DayViewOptions.Visibility = Visibility.Visible;
|
|
SpinEditDayViewDayCount.Value = Scheduler.DayView.DayCount;
|
|
_TimelineDayCount = 0;
|
|
break;
|
|
case AppointmentViewType.Timeline:
|
|
TimelineViewOptions.Visibility = Visibility.Visible;
|
|
DayViewOptions.Visibility = Visibility.Collapsed;
|
|
SpinEditTimelineViewDayCount.Value = _TimelineDayCount == 0 ? Scheduler.TimelineView.IntervalCount : _TimelineDayCount;
|
|
break;
|
|
default:
|
|
_TimelineDayCount = 0;
|
|
TimelineViewOptions.Visibility = Visibility.Collapsed;
|
|
DayViewOptions.Visibility = Visibility.Collapsed;
|
|
break;
|
|
}
|
|
|
|
Scheduler.WeekView.AppointmentDisplayOptions.AppointmentAutoHeight = true;
|
|
Scheduler.MonthView.AppointmentDisplayOptions.AppointmentAutoHeight = true;
|
|
Scheduler.TimelineView.AppointmentDisplayOptions.AppointmentAutoHeight = true;
|
|
}
|
|
|
|
private void ShowPrivateAppointmentsCheckBox_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
ReloadVM(true);
|
|
}
|
|
|
|
private void LeftExpanderClick(object sender, RoutedEventArgs e)
|
|
{
|
|
if(!LeftExpanderButton.IsChecked.HasValue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AuswahlGrid.Visibility = ZeigeNurMeineTermineCheckBox.Visibility = LeftExpanderButton.IsChecked.Value ? Visibility.Collapsed : Visibility.Visible;
|
|
}
|
|
|
|
private void RightExpanderClick(object sender, RoutedEventArgs e)
|
|
{
|
|
if(!RightExpanderButton.IsChecked.HasValue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
DateNavigator.Visibility = RightExpanderButton.IsChecked.Value ? Visibility.Collapsed : Visibility.Visible;
|
|
}
|
|
|
|
private void NurEigeneKlientenAnzeigen(object sender, RoutedEventArgs e)
|
|
{
|
|
//!BeWoApp.LoggedOnUser.HasRight(UserRightType.CustomerView_View) && BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_ViewMyCustomers) ? AllCustomers :
|
|
|
|
var relatedCustomerOids = BeWoApp.LoggedOnEmployee.RelatedCustomers.Select(s => s.Customer.CustomerOid);
|
|
|
|
if(NurMeineKlientenCB.IsChecked.HasValue && NurMeineKlientenCB.IsChecked.Value)
|
|
{
|
|
GefilterteKlienten = AllCustomers.Where(ac => relatedCustomerOids.Contains(ac.CustomerOid)).ToList();
|
|
}
|
|
else if(NurMeineKlientenCB.IsChecked.HasValue && !NurMeineKlientenCB.IsChecked.Value)
|
|
{
|
|
GefilterteKlienten = AllCustomers;
|
|
}
|
|
}
|
|
|
|
private void TextBoxEmployees_OnTextChanged(object sender, TextChangedEventArgs e)
|
|
{
|
|
var suchtext = ((TextBox) sender).Text;
|
|
|
|
GefilterteMitarbeiter = AllEmployees.Where(m => m.FirstName.ToLower().Contains(suchtext.ToLower()) || m.LastName.ToLower().Contains(suchtext.ToLower())).ToList();
|
|
}
|
|
|
|
private void TextBoxCustomers_OnTextChanged(object sender, TextChangedEventArgs e)
|
|
{
|
|
var suchtext = ((TextBox) sender).Text;
|
|
|
|
GefilterteKlienten = AllCustomers.Where(m => m.FullName.ToLower().Contains(suchtext.ToLower())).ToList();
|
|
}
|
|
|
|
private void FensterOeffnen()
|
|
{
|
|
var neueListe = new SchedulerAppointmentListVM(_Liste, AllCustomers, AllEmployees, Category2ResourcesDictionary);
|
|
|
|
var vm = neueListe;
|
|
|
|
var zuBestaetigen = vm.Appointments.Where(app =>
|
|
{
|
|
var customFieldStorage = (CustomFieldStorage) app.CustomFields[nameof(CustomFieldStorage)];
|
|
|
|
var originator = customFieldStorage.Originator;
|
|
|
|
if(customFieldStorage.EmployeeList == null || originator.EmployeeOid == BeWoApp.LoggedOnEmployee.EmployeeOid.Value)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var empList = customFieldStorage.EmployeeList;
|
|
|
|
return empList.Any(a => a.Employee.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid) && a.ParticipationAnswer == ParticipationAnswer.Offen);
|
|
}).ToList();
|
|
|
|
var updates = vm.Appointments.Where(app =>
|
|
{
|
|
var customFieldStorage = (CustomFieldStorage) app.CustomFields[nameof(CustomFieldStorage)];
|
|
|
|
if(customFieldStorage.Originator == null || customFieldStorage.EmployeeList == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var empList = customFieldStorage.EmployeeList;
|
|
var or = customFieldStorage.Originator;
|
|
|
|
return or.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid) && empList.Any(a => a.IsPChanged && a.ParticipationAnswer != ParticipationAnswer.Offen && a.ParticipationAnswer != ParticipationAnswer.Verstrichen && !a.Employee.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid));
|
|
}).ToList();
|
|
|
|
if(!zuBestaetigen.Any() && !updates.Any())
|
|
{
|
|
return;
|
|
}
|
|
|
|
var requestAnswerView = new RequestAnswerView(zuBestaetigen, updates);
|
|
|
|
requestAnswerView.Closed += RequestAnswerViewClosedEvent;
|
|
requestAnswerView.ParticipationChanged += UpdateRequestStringEvent;
|
|
requestAnswerView.ParticipationChanged += UpdateBeiParticipationChanged;
|
|
|
|
requestAnswerView.Show();
|
|
}
|
|
|
|
private void RequestAnswerViewClosedEvent(object sender, EventArgs e)
|
|
{
|
|
ReloadVM(true);
|
|
UpdateRequestString();
|
|
}
|
|
|
|
public void ShowAppointmentRequests(object sender, RequestNavigateEventArgs e)
|
|
{
|
|
FensterOeffnen();
|
|
}
|
|
|
|
private void UpdateBeiParticipationChanged(object sender, EventArgs e)
|
|
{
|
|
ReloadVM(true);
|
|
}
|
|
|
|
private void UpdateRequestStringEvent(object sender, EventArgs e)
|
|
{
|
|
UpdateRequestString();
|
|
}
|
|
|
|
private void AuswahlAufhebenClick(object sender, RoutedEventArgs e)
|
|
{
|
|
SelectedResources.Clear();
|
|
SelectedEmployees.Clear();
|
|
SelectedCustomers.Clear();
|
|
|
|
AlleMitarbeiterCB.IsChecked = false;
|
|
AlleKlientenCB.IsChecked = false;
|
|
AlleRessourcenCB.IsChecked = false;
|
|
|
|
OnPropertyChanged(nameof(SelectedCustomers));
|
|
OnPropertyChanged(nameof(SelectedEmployees));
|
|
OnPropertyChanged(nameof(SelectedResources));
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
}
|
|
|
|
private void Selector_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
{
|
|
var tabControl = (TabControl) sender;
|
|
var selectedItem = (TabItem) tabControl.SelectedItem;
|
|
|
|
var mitarbeiterPinsel = new LinearGradientBrush(new GradientStopCollection {new GradientStop(Color.FromRgb(69, 153, 59), 0), new GradientStop(Color.FromRgb(32, 92, 25), 1)}, new Point(0.5, 0), new Point(0.5, 1));
|
|
var klientenPinsel = new LinearGradientBrush(new GradientStopCollection {new GradientStop(Color.FromRgb(59, 119, 153), 0), new GradientStop(Color.FromRgb(25, 72, 92), 1)}, new Point(0.5, 0), new Point(0.5, 1));
|
|
var ressourcenPinsel = new LinearGradientBrush(new GradientStopCollection {new GradientStop(Color.FromRgb(4, 180, 208), 0), new GradientStop(Color.FromRgb(3, 129, 149), 1)}, new Point(0.5, 0), new Point(0.5, 1));
|
|
|
|
var h = selectedItem.Header.ToString();
|
|
|
|
if(h == Translator.Translate("Mitarbeiter"))
|
|
{
|
|
tabControl.Background = mitarbeiterPinsel;
|
|
tabControl.BorderBrush = mitarbeiterPinsel;
|
|
}
|
|
else if(h == Translator.Translate("Klienten"))
|
|
{
|
|
tabControl.Background = klientenPinsel;
|
|
tabControl.BorderBrush = klientenPinsel;
|
|
}
|
|
else
|
|
{
|
|
tabControl.Background = ressourcenPinsel;
|
|
tabControl.BorderBrush = ressourcenPinsel;
|
|
}
|
|
}
|
|
|
|
private void ReloadButton_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
ReloadVM(true);
|
|
}
|
|
|
|
//private void ExportButton_OnClick(object sender, RoutedEventArgs e)
|
|
//{
|
|
// SaveFileDialog dialog = new SaveFileDialog
|
|
// {
|
|
// Filter = "iCalendar files (*.ics)|*.ics",
|
|
// FilterIndex = 1
|
|
// };
|
|
|
|
// if (dialog.ShowDialog() == true)
|
|
// {
|
|
// using (Stream stream = dialog.OpenFile())
|
|
// {
|
|
// iCalendarExporter exporter = new iCalendarExporter(Scheduler.Storage.InnerStorage);
|
|
// exporter.Export(stream);
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
private void ZusagenButtonItem_OnItemClick(object sender, ItemClickEventArgs e)
|
|
{
|
|
if(Scheduler.SelectedAppointments.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ZusageAendern(ParticipationAnswer.Zusage, Scheduler.SelectedAppointments[0]);
|
|
}
|
|
|
|
private void MitVorbehaltButtonItem_OnItemClick(object sender, ItemClickEventArgs e)
|
|
{
|
|
if(Scheduler.SelectedAppointments.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ZusageAendern(ParticipationAnswer.Vorbehalt, Scheduler.SelectedAppointments[0]);
|
|
}
|
|
|
|
private void AbsagenButtonItem_OnItemClick(object sender, ItemClickEventArgs e)
|
|
{
|
|
if(Scheduler.SelectedAppointments.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ZusageAendern(ParticipationAnswer.Absage, Scheduler.SelectedAppointments[0]);
|
|
}
|
|
|
|
private void ZusageAendern(ParticipationAnswer antwort, Appointment selectedAppointment)
|
|
{
|
|
var el = selectedAppointment.CF_EmployeeList();
|
|
var neu = new ObservableCollection<Employee2SchedulerAppointmentDC>(el.DoForEach(dfe =>
|
|
{
|
|
if(!dfe.Employee.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid))
|
|
{
|
|
return;
|
|
}
|
|
|
|
dfe.ParticipationAnswer = antwort;
|
|
dfe.IsPC_CheckedTs = null;
|
|
}).ToList());
|
|
selectedAppointment.CF_EmployeeList(neu);
|
|
|
|
if(selectedAppointment.Type == AppointmentType.Occurrence)
|
|
{
|
|
var id = selectedAppointment.RecurrenceInfo.Id.ToString();
|
|
var index = selectedAppointment.RecurrenceIndex;
|
|
|
|
ServiceFacade.DoResourceServiceAsync(s => s.FindRootAppointmentByRecurrenceId(id), rootAppointment =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
var changedOccurrence = new SchedulerAppointmentDC
|
|
{
|
|
ActivationType = ActivationTypeId.Active,
|
|
AllDay = selectedAppointment.AllDay,
|
|
CanBeEdited = rootAppointment.CanBeEdited,
|
|
CompletedDate = selectedAppointment.CF_CompletedDate(),
|
|
CompletedNotice = selectedAppointment.CF_CompletedNotice(),
|
|
CompletedUser = selectedAppointment.CF_CompletedUser(),
|
|
CustomerList = selectedAppointment.CF_CustomerList() ?? new List<CompactCustomerDC>(),
|
|
Description = selectedAppointment.Description,
|
|
DueDate = selectedAppointment.CF_DueDate(),
|
|
EmployeeList = selectedAppointment.CF_EmployeeList()?.ToList() ?? new List<Employee2SchedulerAppointmentDC>(),
|
|
EndDate = selectedAppointment.End,
|
|
FormerBookingSequenceOid = rootAppointment.FormerBookingSequenceOid,
|
|
FormerTaskOid = rootAppointment.FormerTaskOid,
|
|
HasServiceRecordEntry = selectedAppointment.CF_HasServiceRecordEntry(),
|
|
IsPrivate = rootAppointment.IsPrivate,
|
|
IsTask = rootAppointment.IsTask,
|
|
IsTeilnahmeBestaetigung = rootAppointment.IsTeilnahmeBestaetigung,
|
|
LabelKey = rootAppointment.LabelKey,
|
|
Location = rootAppointment.Location,
|
|
Originator = selectedAppointment.CF_Originator() ?? BeWoApp.CompactLoggedOnEmployee,
|
|
RecurrenceInfo = $"<RecurrenceInfo Id=\"{id}\" Index=\"{index}\" />",
|
|
ReminderInfo = rootAppointment.ReminderInfo,
|
|
ResourceList = selectedAppointment.CF_ResourceList() ?? new List<ResourceDC>(),
|
|
ServiceRecordList = new List<ServiceRecordDC>(),
|
|
StartDate = selectedAppointment.Start,
|
|
Status = rootAppointment.Status,
|
|
Subject = selectedAppointment.Subject,
|
|
SupportConceptList = new List<CompactSupportConceptDC>(),
|
|
TaskDescription = rootAppointment.TaskDescription,
|
|
Type = (int) AppointmentType.ChangedOccurrence
|
|
};
|
|
|
|
ServiceFacade.DoResourceServiceAsync(s2 => s2.InsertSchedulerAppointments(new List<SchedulerAppointmentDC>{changedOccurrence}), () =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
ReloadVM(true);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
var appointment = (SchedulerAppointmentVM)selectedAppointment.GetSourceObject(Scheduler.GetCoreStorage());
|
|
|
|
ServiceFacade.DoResourceServiceAsync(s => s.UpdateSchedulerAppointments(new List<SchedulerAppointmentDC> { appointment.CommitToDataContract() }), delegate { this.Dispatch(() => { ReloadVM(true); }); });
|
|
}
|
|
}
|
|
|
|
private void ZeiterfassungButtonItem_OnItemClick(object sender, ItemClickEventArgs e)
|
|
{
|
|
if(Scheduler.SelectedAppointments.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var appointment = Scheduler.SelectedAppointments.FirstOrDefault();
|
|
|
|
if(appointment is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var employee2SchedulerAppointmentList = appointment.CF_EmployeeList();
|
|
var customerList = appointment.CF_CustomerList();
|
|
|
|
var employeeList = employee2SchedulerAppointmentList.Select(employee2SchedulerAppointment => employee2SchedulerAppointment.Employee).ToList();
|
|
|
|
BeWoUtils.CreateZeiterfassung(appointment.Start, appointment.End, customerList, employeeList, appointment.Subject, appointment, serviceRecords =>
|
|
{
|
|
try
|
|
{
|
|
IgnoreManualAppointmentCreation = true;
|
|
IgnoreChangeEvents = true;
|
|
|
|
var schedulerAppointment = (SchedulerAppointmentVM) appointment.GetSourceObject(Scheduler.GetCoreStorage());
|
|
schedulerAppointment?.ServiceRecordList.AddRange(serviceRecords);
|
|
|
|
var appointmentOid = schedulerAppointment?.CommitToDataContract().SchedulerAppointmentOid;
|
|
|
|
if(appointmentOid.HasValue)
|
|
{
|
|
appointment.CF_ServiceRecordList(serviceRecords);
|
|
|
|
ViewModel.ActiveAppointmentViewModel.SaveAppointments(Scheduler, new List<Appointment> {appointment});
|
|
|
|
ReloadVM(true);
|
|
}
|
|
else
|
|
{
|
|
// Serientermin!
|
|
var recurrenceInfo = appointment.RecurrenceInfo;
|
|
|
|
var pattern = StaticAppointmentFactory.CreateAppointment(AppointmentType.Pattern);
|
|
pattern.RecurrenceInfo.FromXml(recurrenceInfo.ToXml());
|
|
|
|
var apt = appointment.RecurrencePattern.CreateException(AppointmentType.ChangedOccurrence, appointment.RecurrenceIndex);
|
|
|
|
apt.Duration = appointment.Duration;
|
|
apt.End = apt.Start.Add(appointment.Duration);
|
|
apt.Subject = appointment.Subject;
|
|
apt.Location = appointment.Location;
|
|
apt.Description = appointment.Description;
|
|
|
|
Scheduler.Storage.AppointmentStorage.CreateCustomFields(apt);
|
|
|
|
apt.CustomFields[nameof(CustomFieldStorage)] = appointment.CustomFields[nameof(CustomFieldStorage)];
|
|
|
|
appointment.CF_ServiceRecordList(serviceRecords);
|
|
|
|
ViewModel.ActiveAppointmentViewModel.InsertAppointments(Scheduler, new List<Appointment> {apt});
|
|
|
|
IgnoreChangeEvents = true;
|
|
|
|
ReloadVM(true);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
IgnoreManualAppointmentCreation = false;
|
|
IgnoreChangeEvents = false;
|
|
}
|
|
});
|
|
}
|
|
|
|
private bool IgnoreManualAppointmentCreation { get; set; }
|
|
|
|
private void MeinTB_OnChecked(object sender, RoutedEventArgs e)
|
|
{
|
|
var tb = (ToggleButton) sender;
|
|
|
|
if(tb?.IsChecked == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!tb.IsChecked.Value)
|
|
{
|
|
MitarbeiterSuchGrid.Visibility = Visibility.Collapsed;
|
|
MitarbeiterSuchTextBox.Clear();
|
|
}
|
|
else
|
|
{
|
|
MitarbeiterSuchGrid.Visibility = Visibility.Visible;
|
|
MitarbeiterSuchTextBox.Focus();
|
|
}
|
|
}
|
|
|
|
private void MeinTB2_OnChecked(object sender, RoutedEventArgs e)
|
|
{
|
|
var tb = (ToggleButton) sender;
|
|
|
|
if(tb?.IsChecked == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!tb.IsChecked.Value)
|
|
{
|
|
KlientenSuchGrid.Visibility = Visibility.Collapsed;
|
|
KlientenSuchTextBox.Clear();
|
|
}
|
|
else
|
|
{
|
|
KlientenSuchGrid.Visibility = Visibility.Visible;
|
|
KlientenSuchTextBox.Focus();
|
|
}
|
|
}
|
|
|
|
private void SchedulerStorage_OnFetchAppointments(object sender, FetchAppointmentsEventArgs e)
|
|
{
|
|
if(_LastFetchingDateTime != null && _LastFetchingDateTime.Value < DateTime.Now.AddMilliseconds(-500d))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_LastFetchingDateTime = DateTime.Now;
|
|
|
|
ReloadVM();
|
|
}
|
|
|
|
private bool _ReloadingViewModel;
|
|
private DateTime? _LastFetchingDateTime;
|
|
|
|
private void ReloadVM(bool shouldForceReload = false)
|
|
{
|
|
if(_ReloadingViewModel)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_ReloadingViewModel = true;
|
|
|
|
if(ViewModel == null)
|
|
{
|
|
_ReloadingViewModel = false;
|
|
return;
|
|
}
|
|
|
|
var range = Scheduler.ActiveView.GetVisibleIntervals();
|
|
var start = range.Start;
|
|
var end = range.End;
|
|
|
|
var newFetchingInterval = new TimeInterval(start - FetchPadding, end + FetchPadding);
|
|
|
|
var selectedEmployeeOids = SelectedEmployees.Select(s => s.EmployeeOid).ToList();
|
|
var selectedCustomerOids = SelectedCustomers.Select(s => s.CustomerOid).ToList();
|
|
var selectedResourceOids = SelectedResources.Where(w => w.ResourceOid.HasValue).Select(s => s.ResourceOid.Value).ToList();
|
|
var employeesOnly = MitarbeiterEbenenCheckBox.IsChecked != null && MitarbeiterEbenenCheckBox.IsChecked.Value;
|
|
var customersOnly = KlientenEbenenCheckBox.IsChecked != null && KlientenEbenenCheckBox.IsChecked.Value;
|
|
var resourcesOnly = RessourcenEbenenCheckBox.IsChecked != null && RessourcenEbenenCheckBox.IsChecked.Value;
|
|
var onlyPrivateAppointments = ShowPrivateAppointmentsCheckBox.IsChecked != null && ShowPrivateAppointmentsCheckBox.IsChecked.Value;
|
|
var showOnlyMyAppointments = ZeigeNurMeineTermine;
|
|
var showAbsenceTimes = AbwesenheitenEinAusCheckBox.IsChecked != null && AbwesenheitenEinAusCheckBox.IsChecked.Value;
|
|
|
|
if(!shouldForceReload && newFetchingInterval.Equals(_LastFetchedInterval))
|
|
{
|
|
_ReloadingViewModel = false;
|
|
return;
|
|
}
|
|
|
|
_LastFetchedInterval = newFetchingInterval;
|
|
|
|
ReloadAppointmentViewModel(start, end, selectedEmployeeOids, selectedCustomerOids, selectedResourceOids, employeesOnly, customersOnly, resourcesOnly, onlyPrivateAppointments, showOnlyMyAppointments, showAbsenceTimes);
|
|
}
|
|
|
|
public void ReloadAppointmentViewModel(DateTime pIntervalStart, DateTime pIntervalEnd, List<long> pSelectedEmployees, List<long> pSelectedCustomer, List<long> pSelectedResources, bool pEmployeesOnly, bool pCustomersOnly, bool pResourcesOnly, bool pPrivateAppointmentsOnly, bool pOnlyMyAppointments, bool pShouldShowAbsenceTimes)
|
|
{
|
|
ResetDeletionMode();
|
|
|
|
if (!BeWoApp.LoggedOnEmployee.EmployeeOid.HasValue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var start = pIntervalStart - FetchPadding;
|
|
var end = pIntervalEnd + FetchPadding;
|
|
|
|
var service = Scheduler.GetService<ISchedulerStateService>();
|
|
|
|
this.Dispatch(() =>
|
|
{
|
|
if(service.IsDataRefreshAllowed)
|
|
{
|
|
GetCacheObjects((c, e, r) =>
|
|
{
|
|
ServiceFacade.DoResourceServiceAsync(s2 => s2.LoadFilteredAppointmentsMitAufgaben(BeWoApp.HasLoggedOnUserRight(new[] {UserRightType.KalenderMitarbeitertermineAnsehen}), BeWoApp.LoggedOnEmployee.EmployeeOid.Value, start, end, pSelectedEmployees, pSelectedCustomer, pSelectedResources, pEmployeesOnly, pCustomersOnly, pResourcesOnly, pPrivateAppointmentsOnly, pOnlyMyAppointments, IsTasksVisible),
|
|
appointments =>
|
|
{
|
|
ServiceFacade.DoResourceServiceAsync(s3 => s3.GetAllActiveEmployeeAbsenceTimesInInterval(start, end, BeWoApp.LoggedOnEmployee.EmployeeOid.Value, SelectedEmployees.Select(employee => employee.EmployeeOid).ToList()),
|
|
employeeAbsenceTimes =>
|
|
{
|
|
ServiceFacade.DoResourceServiceAsync(s4 => s4.GetAllActiveCustomersAbsenceTimesInInterval(start, end, BeWoApp.LoggedOnEmployeeOid.Value, SelectedCustomers.Select(customer => customer.CustomerOid).ToList()), customerAbsenceTimes =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
var prefilteredAppointments = appointments.Where(w => (w.EmployeeList.Count == 0 && w.Originator.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid) ||
|
|
w.EmployeeList.Count > 0 && w.EmployeeList.Any(a => a.Employee.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid)) ||
|
|
BeWoUtils.HasRight(UserRightType.KalenderMitarbeitertermineAnsehen)) && (!w.EmployeeList.TrueForAll(e2a => e2a.ParticipationAnswer == ParticipationAnswer.Absage) || w.EmployeeList == null || w.EmployeeList.Count == 0)).ToList();
|
|
|
|
var anonymizedAppointments = appointments.Where(w => w.CanBeEdited == false && w.IsTask == false).ToList();
|
|
|
|
prefilteredAppointments.AddRangeIfElementsNotIn(anonymizedAppointments);
|
|
|
|
if(!IsTasksVisible)
|
|
{
|
|
prefilteredAppointments = prefilteredAppointments.Where(app => !app.IsTask).ToList();
|
|
}
|
|
|
|
var vm = new SchedulerAppointmentListVM(prefilteredAppointments, c, e, r);
|
|
if(pShouldShowAbsenceTimes)
|
|
{
|
|
vm.Appointments.AddRange(ViewModel.ConvertAbsenceTimesToAppointments(customerAbsenceTimes, end, e, c));
|
|
vm.Appointments.AddRange(ViewModel.ConvertAbsenceTimesToAppointments(employeeAbsenceTimes, end, e, c));
|
|
//vm.Appointments.AddRange(ViewModel.ConvertAbsenceTimesToAppointments(employeeAbsenceTimes.Where(w => { return SelectedEmployees.Count == 0 || SelectedEmployees.Any(a => a.EmployeeOid == w.EmployeeOid); }), end, e, c));
|
|
}
|
|
|
|
ViewModel.ActiveAppointmentViewModel = vm;
|
|
|
|
ViewModel.SchedulerSettings = ViewModel.GetActiveSettings();
|
|
ViewModel.SchedulerSettings.StartDate = pIntervalStart;
|
|
|
|
GefilterteMitarbeiter = ViewModel.ActiveAppointmentViewModel.AllEmployees;
|
|
AllEmployees = ViewModel.ActiveAppointmentViewModel.AllEmployees;
|
|
GefilterteKlienten = ViewModel.ActiveAppointmentViewModel.AllCustomers;
|
|
AllCustomers = ViewModel.ActiveAppointmentViewModel.AllCustomers;
|
|
|
|
Category2ResourcesDictionary = ViewModel.ActiveAppointmentViewModel.Categories2Resources;
|
|
|
|
SelectedEmployees = AllEmployees.Where(w => SelectedEmployees.Any(a => a.EmployeeOid.Equals(w.EmployeeOid))).ToList();
|
|
SelectedCustomers = AllCustomers.Where(w => SelectedCustomers.Any(a => a.CustomerOid.Equals(w.CustomerOid))).ToList();
|
|
SelectedResources = AllResources.Where(w => SelectedResources.Any(a => a.ResourceOid.Equals(w.ResourceOid))).ToList();
|
|
|
|
var items = SelectedItems;
|
|
|
|
var testtesttest = ViewModel.ActiveAppointmentViewModel;
|
|
|
|
_ReloadingViewModel = false;
|
|
|
|
// TODO: Hier tritt eine Exception auf, wenn man zu schnell löscht?
|
|
Scheduler.Storage.RefreshData();
|
|
Scheduler.Storage.RefreshUI();
|
|
|
|
if(_IsComingFromHomeDragPanel && _SelectedAppointmentFromHomePanelView != null)
|
|
{
|
|
var apps = Scheduler.ActiveView.GetAppointments().ToList();
|
|
|
|
var oid = _SelectedAppointmentFromHomePanelView.SchedulerAppointmentOid;
|
|
Appointment appointmentToOpen;
|
|
|
|
if(oid != null)
|
|
{
|
|
appointmentToOpen = apps.Find(app =>
|
|
{
|
|
var oidValue = app.CF_SchedulerAppointmentOid();
|
|
|
|
return oidValue.HasValue && oidValue.Value == oid;
|
|
});
|
|
|
|
|
|
if(appointmentToOpen != null)
|
|
{
|
|
Scheduler.ShowEditAppointmentForm(appointmentToOpen);
|
|
}
|
|
}
|
|
else if(_SelectedAppointmentFromHomePanelView.RecurrenceId != null && _SelectedAppointmentFromHomePanelView.RecurrenceIndex > 0)
|
|
{
|
|
appointmentToOpen = apps.Find(appointment => appointment.RecurrenceInfo.Id.ToString().Equals(_SelectedAppointmentFromHomePanelView.RecurrenceId));
|
|
|
|
if(appointmentToOpen != null)
|
|
{
|
|
Scheduler.ShowEditAppointmentForm(appointmentToOpen);
|
|
}
|
|
}
|
|
|
|
_IsComingFromHomeDragPanel = false;
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
else
|
|
{
|
|
_ReloadingViewModel = false;
|
|
}
|
|
});
|
|
}
|
|
|
|
private void ExportButton_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var dialog = new SaveFileDialog {Filter = "iCalendar files (*.ics)|*.ics", FilterIndex = 1};
|
|
|
|
if(dialog.ShowDialog() != true)
|
|
return;
|
|
|
|
using(var stream = dialog.OpenFile())
|
|
{
|
|
ExportAppointmentsAs_iCal(stream);
|
|
}
|
|
}
|
|
|
|
private void ExportAppointmentsAs_iCal(Stream stream)
|
|
{
|
|
if(stream == null)
|
|
return;
|
|
try
|
|
{
|
|
var productIdentifier = string.Format("-//{0}//DXScheduler iCalendarExchange Example//DE", BeWoApp.Mandator);
|
|
var exporter = new iCalendarExporter(Scheduler.GetCoreStorage()) {ProductIdentifier = productIdentifier};
|
|
|
|
exporter.AppointmentExporting += OnAppointmentExporting;
|
|
exporter.Export(stream);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
MessageBox.Show(string.Format("Der Kalender konnte leider nicht exportiert werden.\n{0}", e.Message), "Fehler beim Export", MessageBoxButton.OK, MessageBoxImage.Error);
|
|
}
|
|
}
|
|
|
|
private void OnAppointmentExporting(object sender, AppointmentExportingEventArgs appointmentExportingEventArgs)
|
|
{
|
|
appointmentExportingEventArgs.Cancel = !Scheduler.ActiveView.GetAppointments().Contains(appointmentExportingEventArgs.Appointment);
|
|
}
|
|
|
|
//private void OnAppointmentExporting(object sender, AppointmentExportingEventArgs appointmentExportingEventArgs)
|
|
//{
|
|
// var iCalArgs = (iCalendarAppointmentExportingEventArgs)appointmentExportingEventArgs;
|
|
// var vEvent = iCalArgs.VEvent;
|
|
|
|
// var ma = (ObservableCollection<Employee2SchedulerAppointmentDC>)appointmentExportingEventArgs.Appointment.CF_EmployeeList();
|
|
// var ca = (List<CompactCustomerDC>)appointmentExportingEventArgs.Appointment.CF_CustomerList();
|
|
// var ra = (List<ResourceDC>)appointmentExportingEventArgs.Appointment.CF_ResourceList();
|
|
//}
|
|
|
|
//private void SyncWithOutlook(object sender, RoutedEventArgs e)
|
|
//{
|
|
// Synchronize();
|
|
//}
|
|
|
|
private void PrintCalendar(object sender, RequestNavigateEventArgs e)
|
|
{
|
|
if(Scheduler.ActiveView.GetAppointments().Count == 0)
|
|
{
|
|
MessageBox.Show("Das Drucken ist nicht möglich, da im ausgewählten Intervall keine Termine vorhanden sind.",
|
|
"Drucken nicht möglich",
|
|
MessageBoxButton.OK,
|
|
MessageBoxImage.Error);
|
|
return;
|
|
}
|
|
|
|
var range = Scheduler.ActiveView.GetVisibleIntervals();
|
|
var datesList = new List<DateTime>();
|
|
|
|
if(range.GetType() == typeof(WeekIntervalCollection))
|
|
{
|
|
for(var i = 0; i < range.Duration.Days; i++)
|
|
{
|
|
datesList.Add(range.Start.AddDays(i));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
datesList.AddRange(range.Select(x => x.Start));
|
|
}
|
|
|
|
var absenceTimeOids = Scheduler.ActiveView.GetAppointments().Where(w => w.CF_IsAbsenceTime() && w.CF_AbsenceTimeOid().HasValue).Select(s => s.CF_AbsenceTimeOid()).ToList();
|
|
|
|
var apps = Scheduler.ActiveView.GetAppointments().Where(w => !w.CF_IsAbsenceTime()).ToList();
|
|
var appointmentOidListe = apps.Where(w => !w.IsOccurrence && !w.IsRecurring || w.IsException).Select(app => Convert.ToInt64(((SchedulerAppointmentVM) app.GetSourceObject(Scheduler.GetCoreStorage())).Id)).Distinct().ToList();
|
|
var serienTerminOids = apps.Where(w => w.IsRecurring || w.IsOccurrence).Select(app => Convert.ToInt64(((SchedulerAppointmentVM) app.RecurrencePattern.GetSourceObject(Scheduler.GetCoreStorage())).Id)).Distinct().ToList();
|
|
var serienTermine = new List<SchedulerAppointmentDC>();
|
|
var recurringAppointments = new List<Appointment>();
|
|
|
|
|
|
var deletedOccurrences = new List<SchedulerAppointmentDC>();
|
|
|
|
var st = apps.Where(app => app.IsRecurring || app.IsOccurrence).ToList();
|
|
var recurrenceIds = st.Select(s => s.RecurrenceInfo.Id.ToString()).Distinct().ToList();
|
|
|
|
foreach(var app in ViewModel.ActiveAppointmentViewModel.Appointments)
|
|
{
|
|
if(!(app.RecurrenceInfo is null))
|
|
{
|
|
var id = Utils.Utils.ExtractIdFromRecurrenceInfo(app.RecurrenceInfo);
|
|
|
|
if(recurrenceIds.Contains(id) && app.EventType == (int) AppointmentType.DeletedOccurrence)
|
|
{
|
|
if(app is SchedulerAppointmentVM vm)
|
|
{
|
|
deletedOccurrences.AddIfNotIn(vm.CommitToDataContract());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//var deletedOccurrences = apps.Where(w => w.Type == AppointmentType.DeletedOccurrence).ToList();
|
|
|
|
foreach(var app in apps.Where(w => w.IsOccurrence || w.IsRecurring).Where(app => !recurringAppointments.Any(a => a.RecurrenceInfo.Id.Equals(app.RecurrenceInfo.Id))))
|
|
{
|
|
recurringAppointments.Add(app);
|
|
}
|
|
|
|
foreach(var serienTermin in recurringAppointments)
|
|
{
|
|
var basistermin = (SchedulerAppointmentVM) serienTermin.RecurrencePattern.GetSourceObject(Scheduler.GetCoreStorage());
|
|
var info = serienTermin.RecurrenceInfo;
|
|
var ausnahmen = apps.Where(w => w.RecurrenceInfo != null && w.RecurrenceInfo.Id.Equals(info.Id) && w.IsException).ToList();
|
|
var calc = OccurrenceCalculator.CreateInstance(info);
|
|
var ttc = new TimeInterval(range.Start, range.End + new TimeSpan(1, 0, 0));
|
|
var kollektionOhneAusnahmen = calc.CalcOccurrences(ttc, serienTermin.RecurrencePattern).Where(w => w.RecurrenceIndex != 0 && !w.IsException).ToList();
|
|
|
|
if(ausnahmen.Any(appointment => appointment.IsException && appointment.RecurrenceIndex == 0) && basistermin.DataContract.SchedulerAppointmentOid != null)
|
|
{
|
|
serienTerminOids.Remove(basistermin.DataContract.SchedulerAppointmentOid.Value);
|
|
}
|
|
|
|
var neu = new List<Appointment>();
|
|
|
|
foreach (var app in kollektionOhneAusnahmen.Where(w => !ausnahmen.Select(s => s.RecurrenceIndex).Contains(w.RecurrenceIndex)))
|
|
{
|
|
var recurrenceId = app.RecurrenceInfo.Id.ToString();
|
|
|
|
if (app.IsOccurrence && deletedOccurrences.Any(a => a.RecurrenceId == recurrenceId && a.RecurrenceIndex == app.RecurrenceIndex))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
neu.AddIfNotIn(app);
|
|
}
|
|
|
|
if (ausnahmen.Count > 0)
|
|
{
|
|
kollektionOhneAusnahmen = kollektionOhneAusnahmen.Where(w => !ausnahmen.Select(s => s.RecurrenceIndex).Contains(w.RecurrenceIndex)).ToList();
|
|
}
|
|
|
|
foreach(var appointment in kollektionOhneAusnahmen)
|
|
{
|
|
var recurrenceId = appointment.RecurrenceInfo.Id.ToString();
|
|
var recurrenceIndex = appointment.RecurrenceIndex;
|
|
|
|
if (!(appointment.IsOccurrence && deletedOccurrences.Any(a => a.RecurrenceIdReference == recurrenceId && a.RecurrenceIndexReference == recurrenceIndex)))
|
|
{
|
|
serienTermine.AddIfNotIn(new SchedulerAppointmentDC
|
|
{
|
|
AllDay = appointment.AllDay,
|
|
CustomerList = basistermin.CustomerList,
|
|
EmployeeList = basistermin.EmployeeList.ToList(),
|
|
ResourceList = basistermin.ResourceList,
|
|
StartDate = appointment.Start,
|
|
EndDate = appointment.End,
|
|
Description = appointment.Description,
|
|
IsPrivate = basistermin.IsPrivate,
|
|
Location = appointment.Location,
|
|
Subject = appointment.Subject,
|
|
LabelKey = (long?) appointment.LabelKey,
|
|
Type = (int)appointment.Type,
|
|
Originator = basistermin.Originator,
|
|
RecurrenceInfo = appointment.RecurrenceInfo.ToXml(),
|
|
ServiceRecordList = basistermin.ServiceRecordList,
|
|
SupportConceptList = basistermin.SupportConceptList
|
|
});
|
|
}
|
|
}
|
|
|
|
//serienTermine.AddRangeIfElementsNotIn(kollektionOhneAusnahmen.Select(z => new SchedulerAppointmentDC
|
|
//{
|
|
// AllDay = z.AllDay, CustomerList = basistermin.CustomerList, EmployeeList = basistermin.EmployeeList.ToList(), ResourceList = basistermin.ResourceList, StartDate = z.Start, EndDate = z.End, Description = z.Description, IsPrivate = basistermin.IsPrivate, Location = z.Location, Subject = z.Subject, LabelId = z.LabelId, Type = (int) z.Type, Originator = basistermin.Originator, RecurrenceInfo = z.RecurrenceInfo.ToXml()
|
|
//}));
|
|
}
|
|
|
|
appointmentOidListe.AddRange(serienTerminOids.Where(w => !appointmentOidListe.Contains(w)));
|
|
|
|
var mehrTaegigeTermine = new List<SchedulerAppointmentDC>();
|
|
|
|
foreach (var app in apps.Where(a => !a.SameDay && !(!a.SameDay && a.AllDay && a.Duration == new TimeSpan(1, 0, 0, 0))))
|
|
{
|
|
var sourceObject = app.GetSourceObject(Scheduler.GetCoreStorage());
|
|
|
|
if(sourceObject is SchedulerAppointmentVM vm)
|
|
{
|
|
mehrTaegigeTermine.Add(vm.CommitToDataContract());
|
|
//BeWoApp.LogMessage($"{vm.Subject}: {vm.Start:dd.MM.yyyy HH:mm} - {vm.End:dd.MM.yyyy HH:mm}; {(AppointmentType) vm.EventType}", Colors.Green);
|
|
}
|
|
else
|
|
{
|
|
var occurrenceVM = new SchedulerAppointmentVM(app);
|
|
mehrTaegigeTermine.Add(occurrenceVM.CommitToDataContract());
|
|
//BeWoApp.LogMessage($"{occurrenceVM.Subject}: {occurrenceVM.Start:dd.MM.yyyy HH:mm} - {occurrenceVM.End:dd.MM.yyyy HH:mm}; {(AppointmentType)occurrenceVM.EventType}", Colors.Purple);
|
|
}
|
|
}
|
|
|
|
appointmentOidListe.RemoveRange(mehrTaegigeTermine.Where(w => w.SchedulerAppointmentOid.HasValue).Select(s => s.SchedulerAppointmentOid.Value));
|
|
|
|
var neueTermine = SchedulerUtils.GenerateSeveralDaysAppointments(mehrTaegigeTermine);
|
|
|
|
var variablenDictionary = new Dictionary<string, object>
|
|
{
|
|
{"appointmentOidListe", appointmentOidListe},
|
|
{"datesList", datesList},
|
|
{"employeeOid", BeWoApp.LoggedOnEmployee.EmployeeOid},
|
|
{"serienTermine", serienTermine},
|
|
{"mehrtaegigeTermine", neueTermine},
|
|
{"absenceTimeOids", absenceTimeOids}
|
|
};
|
|
|
|
BeWoUtils.ShowReport("Kalender", variablenDictionary, ReportEnum.KalenderMonatsReportEnum);
|
|
}
|
|
|
|
public void PreselectCustomer(long pCustomerOid)
|
|
{
|
|
if(AllCustomers.Any(c => c.CustomerOid.Equals(pCustomerOid)))
|
|
{
|
|
SelectedCustomers = new List<CompactCustomerDC> {AllCustomers.Find(f => f.CustomerOid.Equals(pCustomerOid))};
|
|
|
|
OnPropertyChanged(nameof(SelectedCustomers));
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
OnPropertyChanged(nameof(GefilterteKlienten));
|
|
}
|
|
}
|
|
|
|
private void DateNavigator_OnSelectedDatesChanged(object sender, EventArgs e)
|
|
{
|
|
_CurrentViewType = Scheduler.ActiveViewType;
|
|
|
|
var navigator = (DevExpress.Xpf.Editors.DateNavigator.DateNavigator) sender;
|
|
|
|
var selectedDates = navigator.SelectedDates;
|
|
|
|
var isSelectedDateFetched = _LastFetchedInterval.ContainsEveryDateFromList(selectedDates);
|
|
if(!isSelectedDateFetched && !(_LastFetchedInterval.Start.Equals(new DateTime(1, 1, 1, 0, 0, 0)) && _LastFetchedInterval.End.Equals(new DateTime(1, 1, 1, 0, 30, 0))))
|
|
{
|
|
ReloadVM();
|
|
}
|
|
}
|
|
|
|
private void MitarbeiterVerfuegbarkeitPruefenButtonItem_OnItemClick(object sender, ItemClickEventArgs e)
|
|
{
|
|
var intervall = Scheduler.ActiveView.SelectedInterval;
|
|
|
|
ServiceFacade.DoEmployeeServiceAsync(s1 => s1.GetAllActiveEmployeesCompact(),
|
|
dcs => ServiceFacade.DoReportServiceAsync(
|
|
s2 => s2.GetMitarbeiterverfuegbarkeiten(dcs, intervall.Start, intervall.End), s3 => this.Dispatch(() =>
|
|
{
|
|
var mviv = new MitarbeiterverfuegbarkeitsinfoView(s3, intervall.Start, intervall.End);
|
|
|
|
if(mviv.CommandBindings.Count == 0)
|
|
{
|
|
mviv.CommandBindings.Add(
|
|
new CommandBinding(
|
|
ApplicationCommands.Close,
|
|
(s, e2) =>
|
|
{
|
|
if(!mviv.DoSaveCheck())
|
|
{
|
|
return;
|
|
}
|
|
|
|
PopupContent.Visibility = Visibility.Hidden;
|
|
PopupContent.Child = null;
|
|
}));
|
|
}
|
|
|
|
PopupContent.Child = mviv;
|
|
PopupContent.Height = 400;
|
|
PopupContent.Width = 450;
|
|
PopupContent.Visibility = Visibility.Visible;
|
|
})));
|
|
}
|
|
|
|
private void MitarbeiterfarbenEinAusCheckBox_OnChecked(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox) sender;
|
|
IsEmployeeBrushVisible = cb.IsChecked ?? true;
|
|
}
|
|
|
|
private void NurMeineTermineEinAusCheckBox_OnChecked(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox) sender;
|
|
|
|
if(CheckBoxConverter != null && BeWoApp.CompactLoggedOnEmployee != null)
|
|
{
|
|
if(cb.IsChecked != null && cb.IsChecked.Value)
|
|
{
|
|
SelectedEmployees = new List<CompactEmployeeDC> {BeWoApp.CompactLoggedOnEmployee};
|
|
CheckBoxConverter.AktuellerMitarbeiter = BeWoApp.CompactLoggedOnEmployee;
|
|
}
|
|
else if(cb.IsChecked != null && !cb.IsChecked.Value && SelectedEmployees.Count == 1)
|
|
{
|
|
SelectedEmployees.Remove(BeWoApp.CompactLoggedOnEmployee);
|
|
CheckBoxConverter.AktuellerMitarbeiter = null;
|
|
}
|
|
|
|
OnPropertyChanged(nameof(SelectedEmployees));
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
|
|
ReloadVM(true);
|
|
}
|
|
}
|
|
|
|
private void AbwesenheitenEinAusCheckBox_OnChecked(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox) sender;
|
|
IsAbsenceTimeVisible = cb.IsChecked ?? true;
|
|
|
|
ReloadVM(true);
|
|
}
|
|
|
|
public static void WriteToDebugLog(string message, bool isWithoutTimestamp = false)
|
|
{
|
|
#if DEBUG
|
|
var callerName2 = new StackTrace().GetFrame(2).GetMethod().Name;
|
|
var callerName = new StackTrace().GetFrame(1).GetMethod().Name;
|
|
|
|
using(var file = new StreamWriter(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + @"\scheduler_log.txt", true))
|
|
{
|
|
var messageToWrite = isWithoutTimestamp ? message : $"{DateTime.Now:yyyy-MM-dd HH:mm:ss:ffff} {callerName2}->{callerName}: {message}";
|
|
|
|
file.WriteLine(messageToWrite);
|
|
}
|
|
|
|
|
|
Debug.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss:ffff} {callerName}: {message}");
|
|
#endif
|
|
}
|
|
|
|
public static void WriteMethodCallToLog(long pElapsedMilliseconds)
|
|
{
|
|
#if DEBUG
|
|
var callerName = new StackTrace().GetFrame(1).GetMethod().Name;
|
|
|
|
using(var logFile = new StreamWriter(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + @"\method_calls_log.txt", true))
|
|
{
|
|
logFile.WriteLine($"{callerName} took {pElapsedMilliseconds} ms");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private void Scheduler_OnInplaceEditorShowing(object sender, InplaceEditorEventArgs e)
|
|
{
|
|
if(_IsNew)
|
|
{
|
|
var n = new ObservableCollection<Employee2SchedulerAppointmentDC>(SelectedEmployees.Select(item => new Employee2SchedulerAppointmentDC {Employee = item, ParticipationAnswer = ParticipationAnswer.Offen}).ToList());
|
|
e.Appointment.CF_EmployeeList(n);
|
|
e.Appointment.CF_CustomerList(new List<CompactCustomerDC>(SelectedCustomers));
|
|
e.Appointment.CF_ResourceList(new List<ResourceDC>(SelectedResources));
|
|
|
|
_IsNew = false;
|
|
}
|
|
}
|
|
|
|
private void ButtonDeleteAppointmentsInInterval_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
DeleteAppointmentsPopup.IsOpen = true;
|
|
}
|
|
|
|
private void AbortDeletingAppointments_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
DeleteAppointmentsPopup.IsOpen = false;
|
|
}
|
|
|
|
private void DeleteAppointmentsForGood_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var employeesOnly = MitarbeiterEbenenCheckBox.IsChecked != null && MitarbeiterEbenenCheckBox.IsChecked.Value;
|
|
var customersOnly = KlientenEbenenCheckBox.IsChecked != null && KlientenEbenenCheckBox.IsChecked.Value;
|
|
var resourcesOnly = RessourcenEbenenCheckBox.IsChecked != null && RessourcenEbenenCheckBox.IsChecked.Value;
|
|
var onlyPrivateAppointments = ShowPrivateAppointmentsCheckBox.IsChecked != null && ShowPrivateAppointmentsCheckBox.IsChecked.Value;
|
|
var showOnlyMyAppointments = ZeigeNurMeineTermine;
|
|
|
|
var loggedOnUserHasRightToSeeAllAppointments = BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderKliententermineAlleAnsehen) || BeWoApp.LoggedOnUser.HasRight(UserRightType.ViewAll);
|
|
var loggedOnEmployeeOid = BeWoApp.LoggedOnEmployee.EmployeeOid.Value;
|
|
var date = DeleteForGoodIntervalEndDateEdit.DateTime;
|
|
|
|
var userRights = new Dictionary<UserRightType, bool>
|
|
{
|
|
{
|
|
UserRightType.KalenderKliententermineAendern, BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderKliententermineAendern)
|
|
},
|
|
{
|
|
UserRightType.KalenderMitarbeitertermineAendern, BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderMitarbeitertermineAendern)
|
|
},
|
|
{
|
|
UserRightType.KalenderRessourcentermineAendern, BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderRessourcentermineAendern)
|
|
},
|
|
{
|
|
UserRightType.KalenderRessourcentermineAndererAendern, BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderRessourcentermineAndererAendern)
|
|
}
|
|
};
|
|
|
|
var dialog = new MessageDialog(() =>
|
|
{
|
|
ServiceFacade.DoOperationsServiceAsync(s => s.DeleteAppointmentsInInterval(
|
|
loggedOnUserHasRightToSeeAllAppointments,
|
|
loggedOnEmployeeOid,
|
|
date,
|
|
SelectedEmployees.Select(employee => employee.EmployeeOid).ToList(),
|
|
SelectedCustomers.Select(customer => customer.CustomerOid).ToList(),
|
|
SelectedResources.Select(resource => resource.ResourceOid.Value).ToList(),
|
|
employeesOnly,
|
|
customersOnly,
|
|
resourcesOnly,
|
|
onlyPrivateAppointments,
|
|
showOnlyMyAppointments,
|
|
userRights), () =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
DeleteAppointmentsPopup.IsOpen = false;
|
|
ReloadVM(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
ServiceFacade.DoOperationsServiceAsync(
|
|
s => s.GetMessageFromServerForDeletingAppointments(
|
|
loggedOnUserHasRightToSeeAllAppointments,
|
|
loggedOnEmployeeOid,
|
|
date,
|
|
SelectedEmployees.Select(employee => employee.EmployeeOid).ToList(),
|
|
SelectedCustomers.Select(customer => customer.CustomerOid).ToList(),
|
|
SelectedResources.Select(resource => resource.ResourceOid.Value).ToList(),
|
|
employeesOnly,
|
|
customersOnly,
|
|
resourcesOnly,
|
|
onlyPrivateAppointments,
|
|
showOnlyMyAppointments,
|
|
userRights), xaml =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
dialog.SetXaml(xaml);
|
|
dialog.ShowDialog();
|
|
});
|
|
});
|
|
}
|
|
|
|
private void RestoreAppointmentButtonItem_OnItemClick(object sender, ItemClickEventArgs e)
|
|
{
|
|
var appointmentToRestore = Scheduler.SelectedAppointments[0];
|
|
|
|
var appointmentVM = (SchedulerAppointmentVM) appointmentToRestore.GetSourceObject(Scheduler.GetCoreStorage());
|
|
|
|
var appointmentDC = appointmentVM?.CommitToDataContract();
|
|
|
|
if(appointmentDC?.SchedulerAppointmentOid == null || appointmentDC.NewSchedulerAppointmentVersion == null || appointmentToRestore.Type != AppointmentType.ChangedOccurrence)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ServiceFacade.DoResourceServiceAsync(s => s.GetSchedulerAppointmentByid(appointmentDC.SchedulerAppointmentOid.Value), appointment =>
|
|
{
|
|
if(appointment.SchedulerAppointmentOid == null || appointment.NewSchedulerAppointmentVersion == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ServiceFacade.DoResourceServiceAsync(s => s.DeleteSchedulerAppointments(new Dictionary<long, long> {{appointment.SchedulerAppointmentOid.Value, appointment.NewSchedulerAppointmentVersion.Value}}),
|
|
() => { this.Dispatch(() => { ReloadVM(true); }); });
|
|
});
|
|
}
|
|
|
|
private void AufgabeAnlegen_OnItemClick(object sender, ItemClickEventArgs e)
|
|
{
|
|
// TODO: Durch eigenen Editor ersetzen, der mit dem Scheduler nichts am Hut hat!
|
|
|
|
// var dueDate = Scheduler.SelectedInterval.End;
|
|
//var end = dueDate.GetShortDateTime().AddDays(1);
|
|
// var start = Scheduler.SelectedInterval.Start.GetShortDateTime();
|
|
|
|
// var newTask = Scheduler.Storage.CreateAppointment(AppointmentType.Normal, start, end, "Neue Aufgabe");
|
|
|
|
// newTask.AllDay = true;
|
|
|
|
//var employees2Appointments = SelectedEmployees.Select(item => new Employee2SchedulerAppointmentDC { Employee = item, ParticipationAnswer = ParticipationAnswer.Offen }).ToList();
|
|
|
|
// ViewModel.InitNewTask(newTask, dueDate, employees2Appointments, SelectedCustomers, SelectedResources, new List<CompactSupportConceptDC>());
|
|
|
|
// Scheduler.ShowEditAppointmentForm(newTask);
|
|
}
|
|
|
|
private void ShowTasksCheckBox_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox) sender;
|
|
IsTasksVisible = cb.IsChecked ?? false;
|
|
|
|
ReloadVM(true);
|
|
}
|
|
|
|
private void Scheduler_OnAppointmentDrag(object sender, AppointmentDragEventArgs e)
|
|
{
|
|
var editedAppointment = e.EditedAppointment;
|
|
|
|
var editedIsTask = editedAppointment.CF_IsTask();
|
|
var editedEnd = editedAppointment.End;
|
|
var editedDueDate = editedAppointment.CF_DueDate();
|
|
|
|
var sourceAppointment = e.SourceAppointment;
|
|
|
|
var sourceIsTask = sourceAppointment.CF_IsTask();
|
|
var sourceEnd = sourceAppointment.End;
|
|
|
|
if(editedIsTask)
|
|
{
|
|
editedAppointment.AllDay = true;
|
|
}
|
|
|
|
if(editedIsTask && sourceIsTask && !Equals(editedEnd, sourceEnd) && editedDueDate.HasValue)
|
|
{
|
|
editedDueDate = editedEnd.MergeDatesByDate(editedDueDate.Value).AddDays(-1);
|
|
|
|
editedAppointment.CF_DueDate(editedDueDate);
|
|
}
|
|
}
|
|
|
|
private static void WriteToDebug(string pText)
|
|
{
|
|
Debug.WriteLine($"-----------------------> {pText}");
|
|
}
|
|
|
|
private void LogStorage()
|
|
{
|
|
var storageAppointments = Scheduler.Storage.AppointmentStorage.Items.ToList();
|
|
|
|
var sb = new StringBuilder();
|
|
sb.Append("AppointmentStorage-Inhalt:\n");
|
|
|
|
foreach(var app in storageAppointments)
|
|
{
|
|
sb.Append($"{app.Subject} {app.Start:dd.MM.yyyy HH:mm}-{app.End:dd.MM.yyyy HH:mm}\n");
|
|
}
|
|
|
|
WriteToDebug(sb.ToString());
|
|
}
|
|
|
|
private void Scheduler_OnAppointmentDrop(object sender, AppointmentDragEventArgs e)
|
|
{
|
|
|
|
}
|
|
|
|
private void ListView_PreviewMouseRightButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
var datacontext = (ListView) sender;
|
|
var selected = datacontext.SelectedItem;
|
|
}
|
|
|
|
private void btn_showEmployeeInformation_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (Button)sender;
|
|
var datacontext = cb.DataContext;
|
|
CompactEmployeeDC emp = (CompactEmployeeDC)datacontext;
|
|
|
|
var control = new InformationView();
|
|
control.SetXaml(ServiceFacade.DoOperationsServiceSync(s => s.GetXAMLInformationStringForEmployee(emp.EmployeeOid)));
|
|
|
|
var beWoWindow = new BeWoWindow();
|
|
|
|
control.ButtonCloseClicked += () => beWoWindow.Close();
|
|
|
|
beWoWindow.Height = 200;
|
|
beWoWindow.Width = 400;
|
|
beWoWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
|
|
beWoWindow.GroupBoxContent = control;
|
|
beWoWindow.Owner = BeWoApp.CurrentBeWo.MainWindow;
|
|
beWoWindow.rootGroupBox.Header = "Infos zu " + emp.FirstName + " " + emp.LastName;
|
|
beWoWindow.ShowDialog();
|
|
}
|
|
|
|
private void btn_showCustomerInformation_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (Button)sender;
|
|
var datacontext = cb.DataContext;
|
|
CompactCustomerDC customer = (CompactCustomerDC)datacontext;
|
|
|
|
var control = new InformationView();
|
|
control.SetXaml(ServiceFacade.DoOperationsServiceSync(s => s.GetXAMLInformationStringForScheduler(customer.CustomerOid)));
|
|
|
|
var beWoWindow = new BeWoWindow();
|
|
|
|
control.ButtonCloseClicked += () => beWoWindow.Close();
|
|
|
|
beWoWindow.Height = 200;
|
|
beWoWindow.Width = 600;
|
|
beWoWindow.WindowStartupLocation = WindowStartupLocation.CenterOwner;
|
|
beWoWindow.GroupBoxContent = control;
|
|
beWoWindow.Owner = BeWoApp.CurrentBeWo.MainWindow;
|
|
beWoWindow.rootGroupBox.Header = "Infos zu " + customer.FirstName + " " + customer.LastName;
|
|
beWoWindow.ShowDialog();
|
|
}
|
|
|
|
private void SpinEditTimelineViewDayCount_OnLostFocus(object sender, RoutedEventArgs e)
|
|
{
|
|
BeWoApp.SaveAppSettings();
|
|
}
|
|
|
|
private void SpinEditDayViewDayCount_OnLostFocus(object sender, RoutedEventArgs e)
|
|
{
|
|
BeWoApp.SaveAppSettings();
|
|
}
|
|
|
|
private void MyTeamsCheckBox_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
if(sender is CheckBox checkBox)
|
|
{
|
|
var isChecked = checkBox.IsChecked ?? false;
|
|
|
|
if(isChecked)
|
|
{
|
|
Cache.GetInstance().GetAllTeamMemberForEmployee(BeWoApp.CompactLoggedOnEmployee, teamMembers =>
|
|
{
|
|
this.Dispatch(() =>
|
|
{
|
|
SelectedEmployees = new List<CompactEmployeeDC>(AllEmployees.Where(employee => teamMembers.Contains(employee)));
|
|
|
|
AlleMitarbeiterCB.IsChecked = ListEquals(AllEmployees, SelectedEmployees);
|
|
|
|
OnPropertyChanged(nameof(SelectedEmployees));
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
|
|
ReloadVM(true);
|
|
});
|
|
});
|
|
}
|
|
else
|
|
{
|
|
SelectedEmployees = new List<CompactEmployeeDC>();
|
|
|
|
OnPropertyChanged(nameof(SelectedEmployees));
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
|
|
ReloadVM(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void NewSchedulerView_OnLoaded(object sender, RoutedEventArgs e)
|
|
{
|
|
ReloadVM(true);
|
|
}
|
|
}
|
|
|
|
#region Converter
|
|
|
|
public static class ViewTypeConvert
|
|
{
|
|
public static AppointmentViewType ToAppointmentViewType(SchedulerViewType svt)
|
|
{
|
|
switch(svt)
|
|
{
|
|
case SchedulerViewType.Day:
|
|
return AppointmentViewType.Day;
|
|
case SchedulerViewType.Week:
|
|
return AppointmentViewType.Week;
|
|
case SchedulerViewType.Timeline:
|
|
return AppointmentViewType.Timeline;
|
|
case SchedulerViewType.Month:
|
|
return AppointmentViewType.Month;
|
|
default:
|
|
return AppointmentViewType.WorkWeek;
|
|
}
|
|
}
|
|
}
|
|
|
|
public class TextFromIDataContractConverter : IValueConverter
|
|
{
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
if(value is ResourceDC resourceDC)
|
|
{
|
|
return resourceDC.Name;
|
|
}
|
|
|
|
if(value is Employee2SchedulerAppointmentDC dc)
|
|
{
|
|
return dc.Employee.SimpleDescription;
|
|
}
|
|
|
|
var filterableDC = value as IFilterableDC;
|
|
return filterableDC?.SimpleDescription;
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public class GermanEditorLocalizer : EditorLocalizer
|
|
{
|
|
public override string Language => "Deutsch";
|
|
|
|
public override string GetLocalizedString(EditorStringId id)
|
|
{
|
|
return id.Equals(EditorStringId.Today) ? "Heute" : base.GetLocalizedString(id);
|
|
}
|
|
}
|
|
|
|
public class ViewInfo2CustomFieldsConverter : IValueConverter
|
|
{
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
if(value is CustomFieldCollection customFields)
|
|
{
|
|
var customFieldStorage = (CustomFieldStorage)customFields[nameof(CustomFieldStorage)];
|
|
|
|
if (customFieldStorage != null && parameter != null && parameter.Equals("AlleRessourcen"))
|
|
{
|
|
return customFieldStorage.ResourceList;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public class AppointmentToolTipConverter : IValueConverter
|
|
{
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
try
|
|
{
|
|
var customFields = (CustomFieldCollection) value;
|
|
|
|
if(customFields == null)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
|
|
var customFieldStorage = (CustomFieldStorage) customFields[nameof(CustomFieldStorage)];
|
|
|
|
var mitarbeiter = customFieldStorage.EmployeeList;
|
|
var ressourcen = customFieldStorage.ResourceList;
|
|
var klienten = customFieldStorage.CustomerList;
|
|
var tooltip = string.Empty;
|
|
var seperator = "; ";
|
|
|
|
if(parameter == null)
|
|
{
|
|
return tooltip;
|
|
}
|
|
|
|
var auswahl = new List<IFilterableDC>();
|
|
switch(parameter.ToString())
|
|
{
|
|
case "Ressourcen":
|
|
seperator = ", ";
|
|
if(ressourcen != null)
|
|
{
|
|
auswahl = ressourcen.Cast<IFilterableDC>().ToList();
|
|
}
|
|
|
|
break;
|
|
case "Mitarbeiter":
|
|
if(mitarbeiter != null)
|
|
{
|
|
auswahl = mitarbeiter.Select(s => s.Employee).Cast<IFilterableDC>().ToList();
|
|
}
|
|
|
|
break;
|
|
case "Klienten":
|
|
if(klienten != null)
|
|
{
|
|
auswahl = klienten.Cast<IFilterableDC>().ToList();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
foreach(var item in auswahl)
|
|
{
|
|
var index = auswahl.IndexOf(item);
|
|
|
|
if(index % 3 == 0 && index < auswahl.Count - 1 && index > 0)
|
|
{
|
|
tooltip += "\n";
|
|
}
|
|
|
|
tooltip += item.ToString();
|
|
|
|
if(index < auswahl.Count - 1)
|
|
{
|
|
tooltip += seperator;
|
|
}
|
|
}
|
|
|
|
return tooltip;
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public class WidthAdditionMultiConverter : IMultiValueConverter
|
|
{
|
|
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
var w1 = System.Convert.ToDouble(values[0]);
|
|
var w2 = System.Convert.ToDouble(values[1]);
|
|
|
|
return w1 + w2;
|
|
}
|
|
|
|
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public class FilterBackgroundConverter : IMultiValueConverter
|
|
{
|
|
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
var farbe = Color.FromRgb(192, 255, 208);
|
|
|
|
try
|
|
{
|
|
if(!(values[0] is List<IDataContract> selectedItems) || !selectedItems.Any())
|
|
{
|
|
return new LinearGradientBrush(new GradientStopCollection {new GradientStop(farbe, 1)}, new Point(.5, 0), new Point(.5, 1));
|
|
}
|
|
|
|
if(!(values[1] is CustomFieldCollection customViewInfo))
|
|
{
|
|
return new LinearGradientBrush(new GradientStopCollection {new GradientStop(farbe, 1)}, new Point(.5, 0), new Point(.5, 1));
|
|
}
|
|
|
|
var customFieldStorage = (CustomFieldStorage) customViewInfo[nameof(CustomFieldStorage)];
|
|
|
|
var isTask = customFieldStorage.IsTask;
|
|
|
|
if(isTask)
|
|
{
|
|
farbe = Color.FromRgb(153, 59, 59);
|
|
}
|
|
|
|
if(customFieldStorage.IsAbsenceTime && customFieldStorage.IsCustomerAbsenceTime)
|
|
{
|
|
farbe = Color.FromRgb(59, 119, 153);
|
|
}
|
|
|
|
var appointmentCustomers = customFieldStorage.CustomerList;
|
|
var appointmentResources = customFieldStorage.ResourceList;
|
|
|
|
var gradientCollection = new GradientStopCollection();
|
|
var farbKollektion = new List<Color>();
|
|
|
|
if(selectedItems.Any(appointmentCustomers.Contains))
|
|
{
|
|
farbKollektion.Add(Color.FromRgb(59, 119, 153));
|
|
}
|
|
|
|
if(selectedItems.Any(appointmentResources.Contains))
|
|
{
|
|
farbKollektion.Add(Color.FromRgb(4, 180, 208));
|
|
}
|
|
|
|
switch(farbKollektion.Count)
|
|
{
|
|
case 1:
|
|
if(BeWoApp.AppSettings.ShowMultipleResourceColors)
|
|
{
|
|
AddResourceColors(gradientCollection, appointmentResources, appointmentCustomers.Any());
|
|
}
|
|
//else
|
|
{
|
|
var first = appointmentResources.FirstOrDefault();
|
|
|
|
gradientCollection.Add(first != null ? new GradientStop((Color)(ColorConverter.ConvertFromString(first.Color) ?? Color.FromRgb(4, 180, 208)), 1) : new GradientStop(farbKollektion[0], 1));
|
|
}
|
|
|
|
break;
|
|
case 2:
|
|
// 1. Klientenfarbe
|
|
gradientCollection.Add(new GradientStop(farbKollektion[0], 0.5));
|
|
|
|
// 2. Resourcenfarben
|
|
if(BeWoApp.AppSettings.ShowMultipleResourceColors)
|
|
{
|
|
AddResourceColors(gradientCollection, appointmentResources, true);
|
|
}
|
|
else
|
|
{
|
|
var first2 = appointmentResources.FirstOrDefault();
|
|
|
|
if (first2 != null)
|
|
{
|
|
gradientCollection.Add(new GradientStop((Color)(ColorConverter.ConvertFromString(first2.Color) ?? Color.FromRgb(4, 180, 208)), 0.5));
|
|
}
|
|
}
|
|
|
|
break;
|
|
default:
|
|
gradientCollection.Add(new GradientStop(farbe, 1));
|
|
break;
|
|
}
|
|
|
|
return new LinearGradientBrush(gradientCollection, new Point(.5, 0), new Point(.5, 1));
|
|
}
|
|
catch(Exception)
|
|
{
|
|
return new LinearGradientBrush(new GradientStopCollection {new GradientStop(farbe, 1)}, new Point(.5, 0), new Point(.5, 1));
|
|
}
|
|
}
|
|
|
|
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
private static void AddResourceColors(GradientStopCollection gradientCollection, IReadOnlyList<ResourceDC> resourceList, bool hasCustomers)
|
|
{
|
|
var previousOffset = hasCustomers ? 0.5 : 0;
|
|
|
|
var numberOfResources = resourceList.Count;
|
|
|
|
if(numberOfResources == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(numberOfResources > 4)
|
|
{
|
|
numberOfResources = 4;
|
|
}
|
|
|
|
var iterator = hasCustomers == false ? 1d / numberOfResources : previousOffset / numberOfResources;
|
|
|
|
for(var i = 0; i < numberOfResources; i++)
|
|
{
|
|
var resource = resourceList[i];
|
|
|
|
var currentOffset = previousOffset;
|
|
var nextOffset = currentOffset + iterator;
|
|
|
|
if(nextOffset > 1)
|
|
{
|
|
nextOffset = 1;
|
|
}
|
|
|
|
previousOffset = nextOffset;
|
|
|
|
gradientCollection.Add(new GradientStop((Color)(ColorConverter.ConvertFromString(resource.Color) ?? Color.FromRgb(4, 180, 208)), currentOffset));
|
|
gradientCollection.Add(new GradientStop((Color)(ColorConverter.ConvertFromString(resource.Color) ?? Color.FromRgb(4, 180, 208)), nextOffset));
|
|
}
|
|
}
|
|
}
|
|
|
|
public class AppointmentBorderZusageConverter : IValueConverter
|
|
{
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
try
|
|
{
|
|
var customFields = (CustomFieldCollection) value;
|
|
|
|
if(customFields == null)
|
|
{
|
|
return new SolidColorBrush(Color.FromRgb(192, 255, 208));
|
|
}
|
|
|
|
var customFieldStorage = (CustomFieldStorage) customFields[nameof(CustomFieldStorage)];
|
|
|
|
var employeeList = customFieldStorage.EmployeeList;
|
|
var isTask = customFieldStorage.IsTask;
|
|
|
|
return employeeList.Any(e => e.Employee.EmployeeOid.Equals(BeWoApp.LoggedOnEmployee.EmployeeOid) && e.ParticipationAnswer == ParticipationAnswer.Vorbehalt) ? new SolidColorBrush(Color.FromRgb(185, 39, 217)) :
|
|
isTask ? new SolidColorBrush(Color.FromRgb(153, 59, 59)) : new SolidColorBrush(Color.FromRgb(192, 255, 208));
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
return new SolidColorBrush(Color.FromRgb(192, 255, 208));
|
|
}
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public class NichtNochEinConverter : IValueConverter
|
|
{
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
if(value is Employee2SchedulerAppointmentDC employee2SchedulerAppointment)
|
|
{
|
|
if (parameter != null && parameter.Equals("GibName"))
|
|
{
|
|
return employee2SchedulerAppointment.Employee.DetailDescription;
|
|
}
|
|
|
|
var color = Color.FromRgb(255, 255, 255);
|
|
|
|
switch (employee2SchedulerAppointment.ParticipationAnswer)
|
|
{
|
|
case ParticipationAnswer.Vorbehalt:
|
|
color = Color.FromRgb(185, 39, 217);
|
|
break;
|
|
case ParticipationAnswer.Zusage:
|
|
color = Color.FromRgb(72, 212, 78);
|
|
break;
|
|
case ParticipationAnswer.Absage:
|
|
color = Color.FromRgb(171, 0, 48);
|
|
break;
|
|
}
|
|
|
|
return new SolidColorBrush(color);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public class InformationButtonVisibilityConverter : IValueConverter
|
|
{
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
if (BeWoApp.AppSettings.ShowInfoButtonInCalender == true)
|
|
{
|
|
return Visibility.Visible;
|
|
}
|
|
else
|
|
return Visibility.Collapsed;
|
|
}
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
}
|