public class EmployeesViewModel : ViewModelBase
{
    private IDataContext Context;
    private IWindowService WinService;

    public EmployeesViewModel(IUnityContainer container)
    {
        Context = container.Resolve<IDataContext>();
        WinService = container.Resolve<IWindowService>();

        Find(string.Empty);
    }

    public override void Dispose()
    {
        Context.Dispose();
    }

    private ObservableCollection<Employee> _employees;
    public ObservableCollection<Employee> Employees
    {
        get
        {
            return _employees;
        }
        set
        {
            _employees = value;
            OnPropertyChanged(() => Employees); 
        }
    }
        
    private string _lastName;
    public string LastName
    {
        get
        {
            return _lastName;
        }
        set
        {
            _lastName = value;
            OnPropertyChanged(() => LastName);                
        }
    }

    private int _totalRows;
    public int TotalRows
    {
        get
        {
            return _totalRows;
        }
        set
        {
            _totalRows = value;
            OnPropertyChanged(() => TotalRows);
        }
    }

    private Employee _currentEmployee;
    public Employee CurrentEmployee
    {
        get
        {
            return _currentEmployee;
        }
        set
        {
            _currentEmployee = value;
            OnPropertyChanged(() => CurrentEmployee);
        }
    }
        
    public void Update(Employee employee)
    {
        var result = WinService.OpenEmployeeDetailWindow(employee ?? new Employee());
        if (result != null)
        {
            if (result.EmployeeId > 0)
            {
                employee.FirstName = result.FirstName;
                employee.LastName = result.LastName;
                employee.Fired = result.Fired;
                employee.Birthday = result.Birthday;
                employee.Stage = result.Stage;
            }
            else
            {
                var employeeNew = Context.UpdateEmployee(result.EmployeeId, result.FirstName, result.LastName, result.Birthday, result.Fired, result.Stage);
                WinService.UpdateDetailWindowAfterCreate(employeeNew);
                TotalRows += 1;
            }
        }
    }

    public void Delete(IEnumerable<Employee> employees)
    {
        if (employees.Any())
        {
            if (WinService.IsOk("Удалить выбранные записи?", "Удаление"))
            {
                int count = employees.Count();
                if (Context.DeleteEmployees(employees))
                {
                    WinService.UpdateDetailWindowAfterDelete(employees);
                    TotalRows -= count;
                }
            }
        }
    }

    public void Find(string lastName)
    {
        var items = Enumerable.Empty<Employee>();

        if (!string.IsNullOrEmpty(LastName))
        {
            items = Context.GetEmployees().Where(d => d.LastName.Contains(lastName));
        }

        Employees = new ObservableCollection<Employee>(items);
        TotalRows = Employees.Count;        
    }

    private ICommand _findCommand;
    public ICommand FindCommand
    {
        get
        {
            if (_findCommand == null)
            {
                _findCommand = new RelayCommand(action => Find(this.LastName));
            }

            return _findCommand;
        }
    }

    private ICommand _updateCommand;
    public ICommand UpdateCommand
    {
        get
        {
            if (_updateCommand == null)
            {
                _updateCommand = new RelayCommand(action =>
                {
                    if (action != null)
                    {
                        Update((Employee)action);
                    }
                }, action => CurrentEmployee != null);
            }

            return _updateCommand;
        }
    }        

    private ICommand _createCommand;
    public ICommand CreateCommand
    {
        get
        {
            if (_createCommand == null)
            {
                _createCommand = new RelayCommand(action => Update(null), action => true);
            }

            return _createCommand;
        }
    }

    private ICommand _deleteCommand;
    public ICommand DeleteCommand
    {
        get
        {
            if (_deleteCommand == null)
            {
                _deleteCommand = new RelayCommand(action => Delete((action as IList).Cast<Employee>()), action => CurrentEmployee != null);
            }

            return _deleteCommand;
        }
    }


    private ICommand _closeCommand;
    public ICommand CloseCommand
    {
        get
        {
            if (_closeCommand == null)
            {
                _closeCommand = new RelayCommand(action => { WinService.CloseActiveWindow(); });
            }

            return _closeCommand;
        }
    }

    private ICommand _excelCommand;
    public ICommand ExcelCommand
    {
        get
        {
            if (_excelCommand == null)
            {
                _excelCommand = new RelayCommand(action => { });
            }

            return _excelCommand;
        }
    }        
}