EmployeeTracker/InvestTracker/VM/EmployeeBrowseVM.cs

using InvestTracker.Entities;
using Microsoft.EntityFrameworkCore;
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; }
        #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; }

        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);

            GridBlocked     = true;

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

        /// <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()
        {
            MessageBox.Show("Searching...");
            ReEvaluateCommands();
        }
        
        /// <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;
            }
        }

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