BeWoPlaner/BeWo/View/NotizenView.xaml.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

using BeWo.Annotations;
using BeWo.Core;
using BeWo.ServiceProxy;
using BeWo.Validation;
using BeWo.View.Controls;
using BeWo.ViewModel;
using BeWo.ViewModel.ListViewModel;

using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.Extensions;

using DevExpress.Utils;
using DevExpress.Xpf.Editors;
using DevExpress.Xpf.Editors.Settings;
using DevExpress.Xpf.Grid;
using DevExpress.XtraRichEdit.Mouse;

namespace BeWo.View
{
    public partial class NotizenView : INotifyPropertyChanged
    {
        private ObservableSortCollection<ValueListEntryDC> _AlleEintragKategorien;
        private ObservableSortCollection<ValueListEntryDC> _AlleEintragKategorienMitLeereintrag;

        public NotizenView(TableID objectTid, long objectOid, ObservableSortCollection<ValueListEntryDC> possibleKategoriesDCs)
        {
            InitializeComponent();

            _JahresComboBoxSource = new List<int>();
            for (var i = 9; i >= 0; i--)
            {
                _JahresComboBoxSource.Add(DateTime.Now.Year - i);
            }

            _MonatsComboBoxSource = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

            currentObjectOid = objectOid;
            currentObjectTid = objectTid;

            NewNotizenEintrag = new NotizenEintragVM(new NotizenEintragDC { Datum = DateTime.Now.Date });

            InitRights();

            ReloadViewModel();
            
            if (tabcontrol_NotizenKategorien != null && tabcontrol_NotizenKategorien.SelectedIndex == -1)
            {
                tabcontrol_NotizenKategorien.SelectedIndex = 0;
            }

            _AlleEintragKategorien = possibleKategoriesDCs;
            _AlleEintragKategorienMitLeereintrag = new ObservableSortCollection<ValueListEntryDC>();
            _AlleEintragKategorienMitLeereintrag.Add(new ValueListEntryDC {TypeDescription = " ", ValueListEntryOid = -1});
            _AlleEintragKategorienMitLeereintrag.AddRange(possibleKategoriesDCs);
        }

        public NotizenEintragVM NewNotizenEintrag { get; set; }

        [Validation(ValidationRule = ValidationRules.NotNullOrStringEmpty)]
        public NotizenKategorieVM SelectedNotizenKategorie { get; set; }

        public static DateTime PreselectedStartDate
        {
            get { return new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);; }
        }

        public static DateTime PreselectedEndDate
        {
            get
            {
                return new DateTime(DateTime.Now.Year, DateTime.Now.Month,DateTime.DaysInMonth(DateTime.Now.Year,DateTime.Now.Month));
                
            }
        }

        public static int PreselectedMonth
        {
            get { return DateTime.Now.Month; }
        }
        public static int PreselectedYear
        {
            get { return DateTime.Now.Year; }
        }

        private readonly List<int> _JahresComboBoxSource; 
        public IEnumerable<int> JahresComboBoxSource 
        {
            get { return _JahresComboBoxSource; }
        }

        private readonly List<int> _MonatsComboBoxSource;
        public IEnumerable<int> MonatsComboBoxSource
        {
            get { return _MonatsComboBoxSource; }
        }

        private static bool darfNotizenEintraegeBearbeiten;
        private static DefaultBoolean darfNotizenEintraegeBearbeitenAsDefaultBoolean;
        private static bool darfNotizenEintraegeAnlegen;
        private static bool darfNotizenEintraegeLoeschen;

        public static bool DarfNotizenEintraegeBearbeiten
        {
            get { return darfNotizenEintraegeBearbeiten; }
        }

        public static DefaultBoolean NotizenEintraegeBearbeitenAlsDefaultBooelan
        {
            get { return darfNotizenEintraegeBearbeitenAsDefaultBoolean; }
        }

        public static bool DarfNotizenEintraegeLoeschen
        {
            get { return darfNotizenEintraegeLoeschen; }
        }

        public static bool DarfNotizenEintraegeAnlegen
        {
            get { return darfNotizenEintraegeAnlegen; }
        }

        private NotizenKategorieListVM _ViewModel;

        private NotizenKategorieListVM ViewModel
        {
            get { return _ViewModel; }
            set
            {
                DataContext = value;
                _ViewModel  = value;
            }
        }

        public ObservableSortCollection<ValueListEntryDC> EintragKategorien => _AlleEintragKategorien;

        public ObservableSortCollection<ValueListEntryDC> EintragKategorienMitLeereintrag => _AlleEintragKategorienMitLeereintrag;

        private readonly TableID currentObjectTid;
        private readonly long    currentObjectOid;

        public override bool IsDirty
        {
            get
            {
                return ViewModel != null && ViewModel.IsDirty;
            }
        }
        
        private void InitRights()
        {
            //bool editRight;
            //DefaultBoolean editRightAsDefaultBoolean;
            //bool deleteRight;
            //bool createRight;

            //if (currentObjectTid == TableID.Customer)
            //{
            //    editRight = BeWoApp.LoggedOnUser.HasRight(UserRightType.BargeldverwaltungBearbeiten) || BeWoApp.LoggedOnUser.HasRight(UserRightType.EditAll);
            //    editRightAsDefaultBoolean = (DefaultBoolean)(Convert.ToInt32((BeWoApp.LoggedOnUser.HasRight(UserRightType.BargeldverwaltungBearbeiten)) || BeWoApp.LoggedOnUser.HasRight(UserRightType.EditAll)) + 1);

            //    deleteRight = BeWoApp.LoggedOnUser.HasRight(UserRightType.BargeldverwaltungLoeschen) || BeWoApp.LoggedOnUser.HasRight(UserRightType.DeleteAll);
            //    createRight = BeWoApp.LoggedOnUser.HasRight(UserRightType.BargeldverwaltungAnlegen) || BeWoApp.LoggedOnUser.HasRight(UserRightType.CreateAll);
            //}
            //else
            //{
            //    editRight = BeWoApp.LoggedOnUser.HasRight(UserRightType.BargeldverwaltungFinanzenBearbeiten) || BeWoApp.LoggedOnUser.HasRight(UserRightType.EditAll);
            //    editRightAsDefaultBoolean = (DefaultBoolean)(Convert.ToInt32((BeWoApp.LoggedOnUser.HasRight(UserRightType.BargeldverwaltungFinanzenBearbeiten)) || BeWoApp.LoggedOnUser.HasRight(UserRightType.EditAll)) + 1);

            //    deleteRight = BeWoApp.LoggedOnUser.HasRight(UserRightType.BargeldverwaltungFinanzenLoeschen) || BeWoApp.LoggedOnUser.HasRight(UserRightType.DeleteAll);
            //    createRight = BeWoApp.LoggedOnUser.HasRight(UserRightType.BargeldverwaltungFinanzenAnlegen) || BeWoApp.LoggedOnUser.HasRight(UserRightType.CreateAll);
            //}

            //darfBargeldTransaktionenBearbeiten = editRight;
            //darfBargeldTransaktionenBearbeitenAsDefaultBoolean = editRightAsDefaultBoolean;
            //darfBargeldTransaktionenLoeschen = deleteRight;
            //darfBargeldTransaktionenAnlegen = createRight;
            
            darfNotizenEintraegeAnlegen = true;
            darfNotizenEintraegeBearbeiten = true;
            darfNotizenEintraegeBearbeitenAsDefaultBoolean = DefaultBoolean.True;
            darfNotizenEintraegeLoeschen = true;

            if (currentObjectTid == TableID.Customer)
            {
                darfNotizenEintraegeAnlegen = BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_EditNotizen);
                darfNotizenEintraegeBearbeiten = BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_EditNotizen);
                darfNotizenEintraegeBearbeitenAsDefaultBoolean = BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_EditNotizen) ? DefaultBoolean.True : DefaultBoolean.False;
                darfNotizenEintraegeLoeschen = BeWoApp.LoggedOnUser.HasRight(UserRightType.Customer_DeleteNotizen);
            }
            else if (currentObjectTid == TableID.Employee)
            {
                darfNotizenEintraegeAnlegen = BeWoApp.LoggedOnUser.HasRight(UserRightType.Employee_EditNotizen);
                darfNotizenEintraegeBearbeiten = BeWoApp.LoggedOnUser.HasRight(UserRightType.Employee_EditNotizen);
                darfNotizenEintraegeBearbeitenAsDefaultBoolean = BeWoApp.LoggedOnUser.HasRight(UserRightType.Employee_EditNotizen) ? DefaultBoolean.True : DefaultBoolean.False;
                darfNotizenEintraegeLoeschen = BeWoApp.LoggedOnUser.HasRight(UserRightType.Employee_DeleteNotizen);
            }

            
        }

        private void ReloadViewModel()
        {
            var previouslySelectedTab = tabcontrol_NotizenKategorien.SelectedIndex;

            ServiceFacade.DoOperationsServiceAsync(s => s.LoadNotizenKategorienForObject(currentObjectTid, currentObjectOid), r => this.Dispatch(
                    delegate
                    {
                        if (r.Any())
                        {
                            int? alteAnzahl = null;

                            if (ViewModel != null)
                            {
                                alteAnzahl = ViewModel.VMList.Count;
                            }

                            ViewModel = new NotizenKategorieListVM(r);

                            var neueAnzahl = ViewModel.VMList.Count;

                            if (alteAnzahl != null && neueAnzahl > alteAnzahl)
                            {
                                tabcontrol_NotizenKategorien.SelectedIndex = neueAnzahl - 1;
                            }
                            else if (previouslySelectedTab > -1)
                            {
                                tabcontrol_NotizenKategorien.SelectedIndex = previouslySelectedTab;
                            }
                            else
                            {
                                tabcontrol_NotizenKategorien.SelectedIndex = 0;
                            }
                            

                            ViewModel.VMList.DoForEach(d => d.NotizenEintraege.VMList.ListChanged += (sender, args) =>
                            {
                                var isRelevantProperty = false;

                                if (args.PropertyDescriptor != null)
                                {
                                    isRelevantProperty = args.PropertyDescriptor.Name.Equals(NotizenEintragVM.PropertyName_Datum) ||
                                                         args.PropertyDescriptor.Name.Equals(NotizenEintragVM.PropertyName_Notice) ||
                                                         args.PropertyDescriptor.Name.Equals(NotizenEintragVM.PropertyName_EintragKategorieDC);
                                }

                                if (args.ListChangedType.Equals(ListChangedType.ItemChanged) && isRelevantProperty)
                                {
                                    var eintraege = (BindingList<NotizenEintragVM>) sender;
                                    var kategorie             = ViewModel.VMList.FirstOrDefault(f => f.NotizenEintraege.VMList.Equals(eintraege));
                                    
                                    if (kategorie != null)
                                    {
                                        ServiceFacade.DoOperationsServiceAsync(s => s.UpdateNotizenKategorie(kategorie.CommitToDataContract()), r2 => this.Dispatch(ReloadViewModel));
                                    }
                                }
                            });
                        }
                        else
                        {
                            ViewModel = new NotizenKategorieListVM(new List<NotizenKategorieDC>());
                        }
                    }));
        }

        private void GridNotizenEintraegeOnCustomColumnSort(object sender, CustomColumnSortEventArgs e)
        {
            e.Result = DateTime.Compare(Convert.ToDateTime(e.Value1), Convert.ToDateTime(e.Value2));
            e.Handled = true;
        }

        private void KategorieLinkOnPreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            var textBlock = (TextBlock) sender;
            var kategorie = ((NotizenKategorieVM) textBlock.Tag).CommitToDataContract();

            var parentStackPanel = (StackPanel) textBlock.Parent;
            var kinder           = parentStackPanel.Children;

            var startzeitraum = (DateEdit)kinder[2];
            var endzeitraum = (DateEdit) kinder[4];


            string url = BeWoApp.SiteOfOrigin + "/ReportView.aspx?katOid=" + kategorie.NotizenKategorieOid.Value + "&start=" + String.Format("{0:dd.MM.yyyy}", startzeitraum.DateTime) + "&end=" + String.Format("{0:dd.MM.yyyy}", endzeitraum.DateTime) + "&type=" + Utils.EnumName(ReportTypes.NotizenKategorie);
            

            BeWoUtils.NavigateToReportUri(url, "Druckvorschau");

            //ServiceFacade.DoReportServiceAsync(strom => strom.CreateKassenbuchReportImZeitraum(zeitraum, endzeitraum, kasse, objectOid, objectTid), ms => BeWoApp.MainControl.Dispatch(() => ShowReportWindow(ms, title)));

            //BeWoUtils.ShowReport("Kassenbuch", new Dictionary<String, Object> { { "bargeldkasse", kategorie }, { "zeitraum", startzeitraum.DateTime }, { "endzeitraum", endzeitraum.DateTime }, { "objectoid", kategorie.ObjectOid }, { "objecttid", kategorie.ObjectTid } }, ReportEnum.KassenbuchReportEnum);
        }

        private void ButtonNotizenEintragDeleteClick(object sender, RoutedEventArgs e)
        {
            var btn = ((Button) sender);

            var eintrag = ((NotizenEintragVM) ((EditGridCellData) btn.Tag).RowData.Row);

            if (MessageBox.Show("Möchten Sie den Eintrag wirklich löschen?", "Eintrag löschen", MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.No)
            {
                return;
            }

            var cellEditor           = ((CellEditor) btn.TemplatedParent).RowData.View;
            var selectedNotizenKategorie = (NotizenKategorieVM) cellEditor.DataControl.Tag;
            
            var removingSuccessfull = selectedNotizenKategorie.NotizenEintraege.VMList.Remove(eintrag);

            ServiceFacade.DoOperationsServiceAsync(s => s.DeactivateNotizenEintrag(eintrag.DataContract.NotizenEintragOid.Value, eintrag.DataContract.NotizenEintragVersion.Value), () => this.Dispatch(ReloadViewModel));

            //ServiceFacade.DoOperationsServiceAsync(s => s.UpdateNotizenKategorie(selectedNotizenKategorie.CommitToDataContract()), r => this.Dispatch(ReloadViewModel));
        }

        private void ButtonAddNotizenKategorieClick(object sender, RoutedEventArgs e)
        {
            if (!Validate(groupbox_newNotizenKategorie))
            {
                return;
            }

            var neu       = ViewModel.NewVM;
            neu.ObjectOid = currentObjectOid;
            neu.ObjectTid = currentObjectTid;

            ServiceFacade.DoOperationsServiceAsync(s => s.InsertNewNotizenKategorie(neu.CommitToDataContract()), r => this.Dispatch(delegate
            {
                popup_newNotizenKategorie.IsOpen = false;

                ViewModel.NewVM = new NotizenKategorieVM(new NotizenKategorieDC());

                ReloadViewModel();
            }));
        }
		
		private void ButtonCancelAddNotizenKategorieClick(object sender, RoutedEventArgs e)
        {
            popup_newNotizenKategorie.IsOpen = false;
        }

        private void ButtonOpenAddNotizenKategorieClick(object sender, RoutedEventArgs e)
        {
            popup_newNotizenKategorie.IsOpen = true;
        }

        private void ButtonAddNotizenEintragClick(object sender, RoutedEventArgs e)
        {
            if (!Validate(groupbox_newNotizenEintrag))
            {
                return;
            }

            
            SelectedNotizenKategorie.NotizenEintraege.NewVM = NewNotizenEintrag;
            SelectedNotizenKategorie.NotizenEintraege.AddNewVMToList();
            
            NewNotizenEintrag = new NotizenEintragVM(new NotizenEintragDC { Datum = DateTime.Now.Date });

            ServiceFacade.DoOperationsServiceAsync(s => s.UpdateNotizenKategorie(SelectedNotizenKategorie.CommitToDataContract()), r => this.Dispatch(delegate
            {
                popup_newNotizenEintrag.IsOpen = false;

                NewNotizenEintrag = new NotizenEintragVM(new NotizenEintragDC { Datum = DateTime.Now.Date });
                SelectedNotizenKategorie = null;

                OnPropertyChanged("NewNotizenEintrag");
                OnPropertyChanged("SelectedNotizenKategorie");

                ReloadViewModel();
            }));
        }

        private void ButtonCancelAddNotizenEintragClick(object sender, RoutedEventArgs e)
        {
            NewNotizenEintrag = new NotizenEintragVM(new NotizenEintragDC { Datum = DateTime.Now.Date });
            SelectedNotizenKategorie = null;

            OnPropertyChanged("NewNotizenEintrag");
            OnPropertyChanged("SelectedNotizenKategorie");

            popup_newNotizenEintrag.IsOpen = false;
        }

        private void ButtonOpenAddNotizenEintragClick(object sender, RoutedEventArgs e)
        {
            var abc = ((Button) sender).Tag;

            if (abc != null)
            {
                SelectedNotizenKategorie = (NotizenKategorieVM)abc;
                OnPropertyChanged("SelectedNotizenKategorie");
            }

            popup_newNotizenEintrag.IsOpen = true;
        }

        private void BtnDeleteNotizenKategorieClick(object sender, RoutedEventArgs e)
        {
            var button               = (Button) sender;
            var selectedNotizenKategorie = (NotizenKategorieVM) button.Tag;

            var result = MessageBox.Show(string.Format("Möchten Sie die Kategorie \"{0}\" wirklich löschen?", selectedNotizenKategorie.KategorieName), "Kategorie löschen", MessageBoxButton.YesNo, MessageBoxImage.Warning);

            if (result == MessageBoxResult.No)
            {
                return;
            }

            ViewModel.VMList.Remove(selectedNotizenKategorie);

            ServiceFacade.DoOperationsServiceAsync(s => s.DeactivateNotizenKategorie(selectedNotizenKategorie.DataContract.NotizenKategorieOid.Value, selectedNotizenKategorie.DataContract.NotizenKategorieVersion.Value), () => this.Dispatch(ReloadViewModel));
        }
        

        public event PropertyChangedEventHandler PropertyChanged;

        [NotifyPropertyChangedInvocator]
        protected virtual void OnPropertyChanged(string propertyName)
        {
            var handler = PropertyChanged;

            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        private void KategorienamenChangeButtonClick(object sender, RoutedEventArgs e)
        {
            var btn   = (Button) sender;
            var panel = (StackPanel) btn.Parent;
            var popup = (PopupNonTopmost) panel.Children[2];

            popup.IsOpen = !popup.IsOpen;
        }

        private void KategorienamenChangeCancelButtonClick(object sender, RoutedEventArgs e)
        {
            var btn                 = (Button) sender;
            var popupMostInnerChild = BeWoWpfUtils.FindParent<Border>(btn);
            var popup               = (PopupNonTopmost) LogicalTreeHelper.GetParent(popupMostInnerChild);

            popup.IsOpen = false;
        }

        private void KategorienamenChangeSaveButtonClick(object sender, RoutedEventArgs e)
        {
            var btn                 = (Button) sender;
            var popupMostInnerChild = BeWoWpfUtils.FindParent<Border>(btn);
            var popup               = (PopupNonTopmost) LogicalTreeHelper.GetParent(popupMostInnerChild);
            var notizenKategorie = (NotizenKategorieVM)tabcontrol_NotizenKategorien.SelectedItem;

            ServiceFacade.DoOperationsServiceAsync(s => s.UpdateNotizenKategorie(notizenKategorie.CommitToDataContract()), r => this.Dispatch(delegate
            {
                popup.IsOpen = false;

                ReloadViewModel();
            }));
        }

        private void Grid_OnLoaded(object sender, RoutedEventArgs e)
        {
            var grid = sender as GridControl;
            SetColumnNoticeEditSettings(grid);
        }

        private void SetColumnNoticeEditSettings(GridControl grid)
        {
            if (grid != null && grid.Columns.Count > 0 && DarfNotizenEintraegeBearbeiten)
            {
                var ms = new MemoEditSettings();
                ms.TextWrapping = TextWrapping.Wrap;
                ms.AcceptsReturn = true;
                ms.MemoTextWrapping = TextWrapping.Wrap;
                ms.MemoAcceptsReturn = true;
                ms.ShowIcon = false;
                ms.ShowTooltipForTrimmedText = true;


                grid.Columns[grid.Columns.Count - 1].EditSettings = ms;
            }
        }
    }
}