3369 lines
138 KiB
C#
3369 lines
138 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 is null && dic2 != null || dic2 is null && _Category2ResourcesDictionary != null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return _Category2ResourcesDictionary is null && dic2 is 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 is null && list2 is null)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if(list1 is null && list2 != null || list1 != null && list2 is 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();
|
|
//PruefeObAbwesenheitsuebertragungErlaubt();
|
|
}
|
|
|
|
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 static void GetCacheObjects(Action<List<CompactCustomerDC>, List<CompactEmployeeDC>, Dictionary<ValueListEntryDC, List<ResourceDC>>> callback)
|
|
{
|
|
Cache.GetInstance().GetSchedulerObjects(callback);
|
|
}
|
|
|
|
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();
|
|
|
|
if(settings is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
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;
|
|
|
|
AbwesenheitButtonItem.IsVisible = BeWoApp.LoggedOnUser.HasRight(UserRightType.KalenderInAbwesenheitenUebernehmen) ? true : false;
|
|
}
|
|
|
|
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 beWoAppointment = exc.GetSourceObject(Scheduler.GetCoreStorage()) as IBeWoAppointment;
|
|
if(beWoAppointment?.CustomFields is null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
foreach(var field in beWoAppointment.CustomFields)
|
|
{
|
|
exc.CustomFields[field.Key] = field.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(bapp?.CustomFields is 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 RessourcenKategorieCB_OnClick(object sender, RoutedEventArgs e)
|
|
{
|
|
var cb = (CheckBox)sender;
|
|
if (!cb.IsChecked.HasValue)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var list = cb.Tag as List<ResourceDC>;
|
|
|
|
if (SelectedResources == null)
|
|
{
|
|
SelectedResources = new List<ResourceDC>();
|
|
}
|
|
foreach (var item in list)
|
|
{
|
|
if (cb.IsChecked.Value && !SelectedResources.Contains(item))
|
|
{
|
|
SelectedResources.Add(item);
|
|
}
|
|
else if (!cb.IsChecked.Value && SelectedResources.Contains(item))
|
|
{
|
|
SelectedResources.Remove(item);
|
|
}
|
|
}
|
|
if (CheckBoxConverter != null)
|
|
{
|
|
OnPropertyChanged(nameof(SelectedResources));
|
|
OnPropertyChanged(nameof(SelectedItems));
|
|
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 employees2Appointments = new ObservableCollection<Employee2SchedulerAppointmentDC>(SelectedEmployees.Select(item => new Employee2SchedulerAppointmentDC {Employee = item, ParticipationAnswer = ParticipationAnswer.Offen}).ToList());
|
|
e.Appointment.CF_EmployeeList(employees2Appointments);
|
|
e.Appointment.CF_CustomerList(new List<CompactCustomerDC>(SelectedCustomers));
|
|
e.Appointment.CF_ResourceList(new List<ResourceDC>(SelectedResources));
|
|
}
|
|
|
|
var app = e.Appointment;
|
|
if (app.AllDay) // Neue Ganztägige Termine funktionieren nicht richtig, wenn man das Ganztägig wegklickt, wird das Enddatum falsch gesetzt
|
|
{
|
|
if (app.CustomFields != null && app.CustomFields.Count > 0)
|
|
{
|
|
var cf = app.CustomFields[0] as CustomFieldStorage;
|
|
if (cf != null && !cf.SchedulerAppointmentOid.HasValue) // Nur bei neuen Terminen
|
|
{
|
|
app.AllDay = true;
|
|
//app.Start = app.Start.Date.AddHours(8);
|
|
//app.End = app.Start.Date.AddHours(9);
|
|
app.Start = app.Start.Date;
|
|
app.End = app.Start.Date;
|
|
}
|
|
|
|
}
|
|
}
|
|
var form = ViewModel.GetEditAppointmentForm(control, e.Appointment);
|
|
if(form is 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 appointment = e.ViewInfo.Appointment;
|
|
|
|
var customFields = e.ViewInfo.Appointment.CustomFields;
|
|
|
|
if(customFields[nameof(CustomFieldStorage)] is 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;
|
|
|
|
bool canBeEdited = appointment.CF_CanBeEdited();
|
|
|
|
if (!istErsteller && appointment.CF_IsPrivate() && !mitarbeiterliste.Any(a => Equals(a.Employee, BeWoApp.CompactLoggedOnEmployee)) || !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 zuBestaetigen = InitAppointmentsToAnswer(neueListe);
|
|
|
|
var updates = InitAppointmentStatusUpdates(neueListe);
|
|
|
|
if(!zuBestaetigen.Any() && !updates.Any())
|
|
{
|
|
return;
|
|
}
|
|
|
|
var requestAnswerView = new RequestAnswerView(zuBestaetigen, updates);
|
|
|
|
requestAnswerView.Closed += RequestAnswerViewClosedEvent;
|
|
requestAnswerView.ParticipationChanged += UpdateRequestStringEvent;
|
|
requestAnswerView.ParticipationChanged += UpdateBeiParticipationChanged;
|
|
|
|
requestAnswerView.Show();
|
|
}
|
|
|
|
public static List<IBeWoAppointment> InitAppointmentsToAnswer(SchedulerAppointmentListVM listVm)
|
|
{
|
|
return listVm.Appointments.Where(app =>
|
|
{
|
|
var customFieldStorage = (CustomFieldStorage)app.CustomFields[nameof(CustomFieldStorage)];
|
|
|
|
var originator = customFieldStorage.Originator;
|
|
|
|
if(customFieldStorage.EmployeeList is 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();
|
|
}
|
|
|
|
public static List<IBeWoAppointment> InitAppointmentStatusUpdates(SchedulerAppointmentListVM listVm)
|
|
{
|
|
return listVm.Appointments.Where(app =>
|
|
{
|
|
var customFieldStorage = (CustomFieldStorage)app.CustomFields[nameof(CustomFieldStorage)];
|
|
|
|
if(customFieldStorage.Originator is null || customFieldStorage.EmployeeList is 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();
|
|
}
|
|
|
|
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();
|
|
String notice = appointment.Description;
|
|
if (String.IsNullOrEmpty(notice))
|
|
{
|
|
notice = appointment.Subject;
|
|
}
|
|
|
|
BeWoUtils.CreateZeiterfassung(appointment.Start, appointment.End, customerList, employeeList, notice, 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 void AbwesenheitButtonItem_OnItemClick(object sender, ItemClickEventArgs e)
|
|
{
|
|
// Wenn nichts ausgewählt wurde, nichts tun
|
|
if (Scheduler.SelectedAppointments.Count <= 0)
|
|
{
|
|
return;
|
|
}
|
|
var appointment = Scheduler.SelectedAppointments.FirstOrDefault();
|
|
if (appointment is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Listen der teilnehmenden Personen füllen
|
|
var employee2SchedulerAppointmentList = appointment.CF_EmployeeList();
|
|
var customerList = appointment.CF_CustomerList();
|
|
var employeeList = employee2SchedulerAppointmentList.Select(employee2SchedulerAppointment => employee2SchedulerAppointment.Employee).ToList();
|
|
|
|
// Betreff des Termins als Notiz der einzutragenden Abwesenheit nutzen
|
|
String notice = "(aus Kalender übertragen)";
|
|
if (appointment.Subject.IsNotNullOrEmpty())
|
|
{
|
|
notice = appointment.Subject + " " + notice;
|
|
}
|
|
|
|
BeWoUtils.CreateAbsenceTime(appointment.Start, appointment.End, customerList, employeeList, notice, appointment, absenceTimes =>
|
|
{
|
|
try
|
|
{
|
|
IgnoreManualAppointmentCreation = true;
|
|
IgnoreChangeEvents = true;
|
|
}
|
|
finally
|
|
{
|
|
IgnoreManualAppointmentCreation = false;
|
|
IgnoreChangeEvents = false;
|
|
}
|
|
});
|
|
}
|
|
|
|
private bool IgnoreManualAppointmentCreation { get; set; }
|
|
|
|
private void MeinTB_OnChecked(object sender, RoutedEventArgs e)
|
|
{
|
|
var toggleButton = (ToggleButton) sender;
|
|
|
|
if(toggleButton?.IsChecked is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!toggleButton.IsChecked.Value)
|
|
{
|
|
MitarbeiterSuchGrid.Visibility = Visibility.Collapsed;
|
|
MitarbeiterSuchTextBox.Clear();
|
|
}
|
|
else
|
|
{
|
|
MitarbeiterSuchGrid.Visibility = Visibility.Visible;
|
|
MitarbeiterSuchTextBox.Focus();
|
|
}
|
|
}
|
|
|
|
private void MeinTB2_OnChecked(object sender, RoutedEventArgs e)
|
|
{
|
|
var toggleButton = (ToggleButton) sender;
|
|
|
|
if(toggleButton?.IsChecked is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(!toggleButton.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;
|
|
|
|
public TimeInterval FetchingInterval { get; set; }
|
|
|
|
private void ReloadVM(bool shouldForceReload = false)
|
|
{
|
|
if(_ReloadingViewModel)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_ReloadingViewModel = true;
|
|
|
|
if(ViewModel is null)
|
|
{
|
|
_ReloadingViewModel = false;
|
|
return;
|
|
}
|
|
|
|
var range = Scheduler.ActiveView.GetVisibleIntervals();
|
|
var start = range.Start;
|
|
var end = range.End;
|
|
|
|
FetchingInterval = 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 && FetchingInterval.Equals(_LastFetchedInterval))
|
|
{
|
|
_ReloadingViewModel = false;
|
|
return;
|
|
}
|
|
|
|
_LastFetchedInterval = FetchingInterval;
|
|
|
|
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, Action callback = null)
|
|
{
|
|
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 is 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.FirstOrDefault(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.FirstOrDefault(appointment => appointment.RecurrenceInfo.Id.ToString().Equals(_SelectedAppointmentFromHomePanelView.RecurrenceId));
|
|
|
|
if(appointmentToOpen != null)
|
|
{
|
|
Scheduler.ShowEditAppointmentForm(appointmentToOpen);
|
|
}
|
|
}
|
|
|
|
_IsComingFromHomeDragPanel = false;
|
|
}
|
|
|
|
callback?.Invoke();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
}
|
|
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 is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
var productIdentifier = $"-//{BeWoApp.Mandator}//DXScheduler iCalendarExchange Example//DE";
|
|
var exporter = new iCalendarExporter(Scheduler.GetCoreStorage()) {ProductIdentifier = productIdentifier};
|
|
|
|
exporter.AppointmentExporting += OnAppointmentExporting;
|
|
exporter.Export(stream);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
MessageBox.Show($"Der Kalender konnte leider nicht exportiert werden.\n{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)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
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 checkBox = (CheckBox) sender;
|
|
|
|
if(CheckBoxConverter is null || BeWoApp.CompactLoggedOnEmployee is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(checkBox.IsChecked != null && checkBox.IsChecked.Value)
|
|
{
|
|
SelectedEmployees = new List<CompactEmployeeDC> {BeWoApp.CompactLoggedOnEmployee};
|
|
CheckBoxConverter.AktuellerMitarbeiter = BeWoApp.CompactLoggedOnEmployee;
|
|
}
|
|
else if(checkBox.IsChecked != null && !checkBox.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)
|
|
{
|
|
return;
|
|
}
|
|
|
|
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 is null || appointmentDC.NewSchedulerAppointmentVersion is null || appointmentToRestore.Type != AppointmentType.ChangedOccurrence)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ServiceFacade.DoResourceServiceAsync(s => s.GetSchedulerAppointmentByid(appointmentDC.SchedulerAppointmentOid.Value), appointment =>
|
|
{
|
|
if(appointment.SchedulerAppointmentOid is null || appointment.NewSchedulerAppointmentVersion is 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 checkBox = (CheckBox) sender;
|
|
IsTasksVisible = checkBox.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 stringBuilder = new StringBuilder();
|
|
stringBuilder.Append("AppointmentStorage-Inhalt:\n");
|
|
|
|
foreach(var app in storageAppointments)
|
|
{
|
|
stringBuilder.Append($"{app.Subject} {app.Start:dd.MM.yyyy HH:mm}-{app.End:dd.MM.yyyy HH:mm}\n");
|
|
}
|
|
|
|
WriteToDebug(stringBuilder.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 schedulerViewType)
|
|
{
|
|
switch(schedulerViewType)
|
|
{
|
|
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 is 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 is 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 is 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))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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)
|
|
{
|
|
return BeWoApp.AppSettings.ShowInfoButtonInCalender ? Visibility.Visible : Visibility.Collapsed;
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
#endregion
|
|
}
|