EmployeeTracker/InvestTracker/VM/EmployeeBrowseVM.cs

using InvestTracker.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using Prism.Commands;
using Prism.Mvvm;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;

namespace InvestTracker.VM
{
    public class EmployeeBrowseVM : BindableBase
    {
        #region Команды
        public DelegateCommand UndoCommand { get; set; }
        public DelegateCommand SaveCommand { get; set; }
        public DelegateCommand NewCommand { get; set; }
        public DelegateCommand EditCommand { get; set; }
        public DelegateCommand DeleteCommand { get; set; }
        public DelegateCommand FindCommand { get; set; }
        public DelegateCommand ToggleFilterCommand { get; set; }
        #endregion

        /// <summary>
        /// Определяет можно ли редактировать значения в сетке данных
        /// </summary>
        public bool GridBlocked { get; set; }

        /// <summary>
        /// Контекст БД
        /// </summary>
        private InvestContext _dbContext;

        /// <summary>
        /// Определяет состояние приложения
        /// </summary>
        private bool isDirty = false;

        /// <summary>
        /// Список всех сотрудников
        /// </summary>
        public ObservableCollection<Employee> Employees { get; set; }

        /// <summary>
        /// Список всех должностей для выбора в колонках
        /// </summary>
        public ObservableCollection<Title> AllTitles { get; set; }

        /// <summary>
        /// Выбранный на данный момент сотрудник
        /// </summary>
        public Employee? SelectedEmployee { get; set; }

        /// <summary>
        /// По какой фамилии фильтровать поиск
        /// </summary>
        public string? FilterSurname { get; set; }

        /// <summary>
        /// По какой должности фильтровать поиск
        /// </summary>
        public Entities.Title? FilterTitle { get; set; }

        /// <summary>
        /// Активен ли фильтр в данный момент
        /// </summary>
        public bool FilterActive { get; set; }

        public EmployeeBrowseVM()
        {
            UndoCommand         = new DelegateCommand(Undo_Executed,                WhenDirty);
            SaveCommand         = new DelegateCommand(Save_Executed,                WhenDirty);
            NewCommand          = new DelegateCommand(New_Executed,                 WhenClean);
            EditCommand         = new DelegateCommand(Edit_Executed,                WhenClean);
            DeleteCommand       = new DelegateCommand(Delete_Executed,              WhenClean);
            FindCommand         = new DelegateCommand(Find_Executed,                WhenClean);
            ToggleFilterCommand = new DelegateCommand(ToggleFilterCommand_Executed, WhenClean);

            GridBlocked     = true;

            _dbContext      = new InvestContext();
            Employees       = new ObservableCollection<Employee>(_dbContext.Employees.ToList());
            AllTitles       = new ObservableCollection<Title>(_dbContext.Titles.ToList());

            FilterActive    = false;
        }

        /// <summary>
        /// Выполняет отмену
        /// </summary>
        private void Undo_Executed()
        {
            // http://stackoverflow.com/questions/5466677/ddg#17967959
            var changedEntries = _dbContext.ChangeTracker.Entries()
                .Where(x => x.State != EntityState.Unchanged)
                .ToList();

            foreach (var entry in changedEntries)
            {
                switch (entry.State)
                {
                    case EntityState.Modified:
                        entry.CurrentValues.SetValues(entry.OriginalValues);
                        entry.State = EntityState.Unchanged;
                        break;
                    case EntityState.Added:
                        entry.State = EntityState.Detached;
                        break;
                    case EntityState.Deleted:
                        entry.State = EntityState.Unchanged;
                        break;
                }
            }

            Employees = new ObservableCollection<Employee>(_dbContext.Employees.ToList());
            _dbContext.SaveChanges();

            GridBlocked = true;
            isDirty = false;
            RaisePropertyChanged(nameof(GridBlocked));
            RaisePropertyChanged(nameof(Employees));
            ReEvaluateCommands();
        }

        /// <summary>
        /// Сохраняет все изменения
        /// </summary>
        private void Save_Executed()
        {
            try
            {
                _dbContext.SaveChanges();
            } catch (DbUpdateException ex)
            {
                string message = "Введённые данные о сотруднике не верны.";
                if (ex.InnerException != null)
                {
                    message += "\r\n" + ex.InnerException.Message;
                }
                MessageBox.Show(message);
                return;
            }
            
            GridBlocked = true;
            isDirty = false;

            RaisePropertyChanged(nameof(GridBlocked));
            ReEvaluateCommands();
        }
        
        /// <summary>
        /// Добавляет нового пользователя
        /// </summary>
        private void New_Executed()
        {
            Employee newEmployee = new Employee();
            _dbContext.Attach(newEmployee);
            Employees.Add(newEmployee);

            GridBlocked = false;
            isDirty = true;

            RaisePropertyChanged(nameof(GridBlocked));
            ReEvaluateCommands();
        }
        
        /// <summary>
        /// Переводит DataGrid в режим редактирования
        /// </summary>
        private void Edit_Executed()
        {
            GridBlocked = false;
            isDirty = true;

            RaisePropertyChanged(nameof(GridBlocked));
            ReEvaluateCommands();
        }
        
        /// <summary>
        /// Удаляет сотрудника
        /// </summary>
        private void Delete_Executed()
        {
            if (SelectedEmployee == null)
            {
                MessageBox.Show("Не выбрана строка для удаления");
                return;
            }
            
            MessageBoxResult result = MessageBox.Show(
                $"Удалить сотрудника: {SelectedEmployee.Surname} {SelectedEmployee.Name} {SelectedEmployee.Patronymic}",
                "Предупреждение",
                MessageBoxButton.OKCancel);

            if (result != MessageBoxResult.OK)
            {
                return;
            }
            
            _dbContext.Employees.Remove(SelectedEmployee);
            Employees.Remove(SelectedEmployee);
            isDirty = true;
            RaisePropertyChanged(nameof(isDirty));
            RaisePropertyChanged(nameof(SelectedEmployee));
            ReEvaluateCommands();
        }
        
        /// <summary>
        /// Выполняет поиск
        /// </summary>
        private void Find_Executed()
        {
            // 1. Установить список сотрудников по условиям
            Func<Employee, bool> filter = (Employee e) => {
                if (FilterSurname.IsNullOrEmpty() == false)
                {
                    if (e.Surname != FilterSurname)
                    {
                        // Не совпадают фамилии
                        return false;
                    }
                }

                if (FilterTitle != null)
                {
                    if (e.Title != FilterTitle)
                    {
                        // Не совпадают должности
                        return false;
                    }
                }

                return true;
            };
            
            var filteredEmployees = _dbContext.Employees
                .Where(filter)
                .ToList();

            // 2. Проверить результаты
            if (filteredEmployees.Count == 0)
            {
                MessageBox.Show("Не найдено ни одного сотрудника, используя заданные параметры");
                return;
            }

            // 3. Перезаписать сотрудников
            Employees = new ObservableCollection<Employee>(filteredEmployees);
            RaisePropertyChanged(nameof(Employees));
        }
        
        /// <summary>
        /// CanExecute когда isDirty = false
        /// </summary>
        private bool WhenClean()
        {
            if (isDirty == false)
            {
                return true;
            } else
            {
                return false;
            }
        }

        /// <summary>
        /// CanExecute когда isDirty = true
        /// </summary>
        private bool WhenDirty()
        {
            if (isDirty == true)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        private void ToggleFilterCommand_Executed()
        {
            FilterActive = !FilterActive;
            if (FilterActive == false)
            {
                // Сбрасываем фильтр
                Employees = new ObservableCollection<Employee>(_dbContext.Employees.ToList());
                RaisePropertyChanged(nameof(Employees));
            }
            RaisePropertyChanged(nameof(FilterActive));
        }

        /// <summary>
        /// Заставляет все команды вызвать свои методы .RaiseExecuteChanged
        /// </summary>
        private void ReEvaluateCommands()
        {
            UndoCommand.RaiseCanExecuteChanged();
            SaveCommand.RaiseCanExecuteChanged();
            NewCommand.RaiseCanExecuteChanged();
            EditCommand.RaiseCanExecuteChanged();
            DeleteCommand.RaiseCanExecuteChanged();
            FindCommand.RaiseCanExecuteChanged();
            ToggleFilterCommand.RaiseCanExecuteChanged();
        }
    }
}