ViewModels/WorkRecordsViewModel.cs - master - WorkerTime/WorkerTimeDiplom

ViewModels/WorkRecordsViewModel.cs
424 строки14 KB
nikit
Логирование, автосохранение, восстановление пароля
05 июн 2026, 19:24
05 июн 2026, 19:24715eb3d
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Windows;
using System.Windows.Input;
using WorkerTime.Services;
using WorkerTime.Views;

namespace WorkerTime.ViewModels
{
    public class DayHeader
    {
        public int Day { get; set; }
        public string DayName { get; set; }
        public bool IsExtra { get; set; }
    }

    public class WorkMonthRow
    {
        public string EmployeeName { get; set; }
        public string Position { get; set; }
        public string Department { get; set; }
        public List<WorkDayCell> Days { get; set; }
    }

    public class WorkDayCell : INotifyPropertyChanged
    {
        public int Day { get; set; }
        public string Date { get; set; }
        public int EmployeeId { get; set; }
        public int RecordId { get; set; }

        private string _workCode;
        public string WorkCode
        {
            get { return _workCode; }
            set
            {
                _workCode = value;
                OnPropertyChanged(nameof(WorkCode));
            }
        }

        private double _hours;
        public double Hours
        {
            get { return _hours; }
            set
            {
                _hours = value;
                OnPropertyChanged(nameof(Hours));
            }
        }

        public bool IsExtra { get; set; }

        public event PropertyChangedEventHandler PropertyChanged;

        public void OnPropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
            {
                handler.Invoke(this, new PropertyChangedEventArgs(propertyName));
            }
        }
    }

    public class WorkRecordsViewModel : BaseViewModel
    {
        private readonly EmployeeService _employeeService;
        private readonly WorkRecordService _workRecordService;
        private readonly ReportService _reportService;
        private readonly ExportService _exportService;
        private readonly SettingsService _settingsService;

        public ObservableCollection<WorkMonthRow> Rows { get; set; }
        public ObservableCollection<DayHeader> DayHeaders { get; set; }

        public List<int> Years { get; set; }
        public List<string> Months { get; set; }
        public List<Department> AllDepartments { get; set; }

        private int _selectedYear;
        public int SelectedYear
        {
            get { return _selectedYear; }
            set
            {
                _selectedYear = value;
                OnPropertyChanged();
                LoadData();
            }
        }

        private int _selectedMonth;
        public int SelectedMonth
        {
            get { return _selectedMonth; }
            set
            {
                _selectedMonth = value;
                OnPropertyChanged();
                LoadData();
            }
        }

        private int _selectedDepartmentId;
        public int SelectedDepartmentId
        {
            get { return _selectedDepartmentId; }
            set
            {
                _selectedDepartmentId = value;
                OnPropertyChanged();
                LoadData();
            }
        }

        public ICommand FillCommand { get; set; }
        public ICommand SaveCommand { get; set; }
        public ICommand ExportCommand { get; set; }
        public ICommand ResetFilterCommand { get; set; }

        public WorkRecordsViewModel()
        {
            _employeeService = new EmployeeService(App.DbContext);
            _workRecordService = new WorkRecordService(App.DbContext);
            _reportService = new ReportService(App.DbContext);
            _exportService = new ExportService();
            _settingsService = new SettingsService(App.DbContext);

            Rows = new ObservableCollection<WorkMonthRow>();
            DayHeaders = new ObservableCollection<DayHeader>();

            int currentYear = DateTime.Now.Year;

            Years = new List<int>();
            Years.Add(currentYear - 1);
            Years.Add(currentYear);
            Years.Add(currentYear + 1);

            Months = new List<string>();
            Months.Add("Январь");
            Months.Add("Февраль");
            Months.Add("Март");
            Months.Add("Апрель");
            Months.Add("Май");
            Months.Add("Июнь");
            Months.Add("Июль");
            Months.Add("Август");
            Months.Add("Сентябрь");
            Months.Add("Октябрь");
            Months.Add("Ноябрь");
            Months.Add("Декабрь");

            //Список подразделений для фильтра
            AllDepartments = new List<Department>();
            foreach (Department d in App.DbContext.Departments)
            {
                AllDepartments.Add(d);
            }

            _selectedYear = currentYear;
            _selectedMonth = DateTime.Now.Month - 1;
            _selectedDepartmentId = 0; //0 = все подразделения

            FillCommand = new RelayCommand(_ => FillAll());
            SaveCommand = new RelayCommand(_ => SaveAll());
            ExportCommand = new RelayCommand(_ => ExportToExcel());
            ResetFilterCommand = new RelayCommand(_ => ResetFilter());

            LoadData();
        }

        private int RealMonth()
        {
            return _selectedMonth + 1;
        }

        //Загружает дни месяца, сотрудников и их записи
        public void LoadData()
        {
            SaveAllSilent();

            int month = RealMonth();
            int daysInMonth = DateTime.DaysInMonth(_selectedYear, month);

            string[] dayNames = { "вс", "пн", "вт", "ср", "чт", "пт", "сб" };

            //Ставит даты и дни недели в календарь
            DayHeaders.Clear();
            for (int day = 1; day <= 31; day++)
            {
                DayHeader header = new DayHeader();
                header.Day = day;
                header.DayName = "";
                header.IsExtra = false;

                if (day > daysInMonth)
                {
                    header.IsExtra = true;
                }
                else
                {
                    DateTime dt = new DateTime(_selectedYear, month, day);
                    header.DayName = dayNames[(int)dt.DayOfWeek];
                }

                DayHeaders.Add(header);
            }

            List<Employee> allEmployees = _employeeService.GetAll();

            //Фильтр по подразделению
            if (_selectedDepartmentId != 0)
            {
                List<Employee> filtered = new List<Employee>();
                foreach (Employee e in allEmployees)
                {
                    if (e.DepartmentId == _selectedDepartmentId)
                    {
                        filtered.Add(e);
                    }
                }
                allEmployees = filtered;
            }

            Rows.Clear();
            foreach (Employee employee in allEmployees)
            {
                List<WorkRecord> records = _workRecordService.GetByMonth(employee.Id, _selectedYear, month);

                //Создаёт инициалы
                string initials = employee.LastName;
                if (!string.IsNullOrEmpty(employee.FirstName))
                {
                    initials = initials + " " + employee.FirstName[0] + ".";
                }
                if (!string.IsNullOrEmpty(employee.MiddleName))
                {
                    initials = initials + " " + employee.MiddleName[0] + ".";
                }

                WorkMonthRow row = new WorkMonthRow();
                row.EmployeeName = initials;
                row.Position = employee.Position;
                row.Department = "";
                row.Days = new List<WorkDayCell>();

                if (employee.Department != null)
                {
                    row.Department = employee.Department.Name;
                }

                for (int day = 1; day <= 31; day++)
                {
                    WorkDayCell cell = new WorkDayCell();
                    cell.Day = day;
                    cell.EmployeeId = employee.Id;

                    if (day > daysInMonth)
                    {
                        cell.IsExtra = true;
                        cell.WorkCode = "X";
                        cell.Hours = 0;
                    }
                    else
                    {
                        string dateStr = _selectedYear + "-" + month.ToString("D2") + "-" + day.ToString("D2");

                        WorkRecord foundRecord = null;
                        foreach (WorkRecord r in records)
                        {
                            if (r.Date == dateStr)
                            {
                                foundRecord = r;
                                break;
                            }
                        }

                        if (foundRecord != null)
                        {
                            cell.RecordId = foundRecord.Id;
                            cell.WorkCode = foundRecord.WorkCode;
                            cell.Hours = foundRecord.Hours;
                        }
                    }

                    row.Days.Add(cell);
                }

                Rows.Add(row);
            }
        }

        private void FillAll()
        {
            int month = RealMonth();
            List<Employee> allEmployees = _employeeService.GetAll();

            foreach (Employee employee in allEmployees)
            {
                _workRecordService.FillBySchedule(employee.Id, _selectedYear, month);
            }

            LoadData();
            Logger.Log("Заполнение по графику", "месяц " + month.ToString() + "." + _selectedYear.ToString());
            MessageBox.Show("Месяц заполнен (5/2, 8-часовой день).", "Готово",
                MessageBoxButton.OK, MessageBoxImage.Information);
        }

        private void SaveAll()
        {
            foreach (WorkMonthRow row in Rows)
            {
                foreach (WorkDayCell cell in row.Days)
                {
                    if (cell.IsExtra) continue;
                    if (cell.RecordId == 0) continue;

                    WorkRecord record = _workRecordService.GetById(cell.RecordId);
                    if (record != null)
                    {
                        record.WorkCode = cell.WorkCode;
                        record.Hours = cell.Hours;
                        _workRecordService.Update(record);
                    }
                }
            }
            Logger.Log("Сохранение табеля", "месяц " + RealMonth().ToString() + "." + _selectedYear.ToString());
            MessageBox.Show("Сохранено.", "Готово", MessageBoxButton.OK, MessageBoxImage.Information);
        }

        private void SaveAllSilent()
        {
            foreach (WorkMonthRow row in Rows)
            {
                foreach (WorkDayCell cell in row.Days)
                {
                    if (cell.IsExtra) continue;
                    if (cell.RecordId == 0) continue;

                    WorkRecord record = _workRecordService.GetById(cell.RecordId);
                    if (record != null)
                    {
                        record.WorkCode = cell.WorkCode;
                        record.Hours = cell.Hours;
                        _workRecordService.Update(record);
                    }
                }
            }
        }

        private void ExportToExcel()
        {
            int month = RealMonth();

            List<Department> departments = new List<Department>();
            foreach (Department d in App.DbContext.Departments)
            {
                departments.Add(d);
            }

            if (departments.Count == 0)
            {
                MessageBox.Show("Нет созданных подразделений.", "Ошибка",
                    MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            ExportWindow exportWindow = new ExportWindow(departments);
            if (Application.Current.MainWindow != null && Application.Current.MainWindow != exportWindow)
            {
                exportWindow.Owner = Application.Current.MainWindow;
            }
            exportWindow.ShowDialog();

            if (!exportWindow.Confirmed) return;

            List<int> selectedIds = new List<int>();
            selectedIds.Add(exportWindow.SelectedDepartmentId);

            ReportService.Timesheet timesheet = _reportService.GenerateForDepartments(
                _selectedYear, month, selectedIds);

            AppSettings settings = _settingsService.GetSettings();
            timesheet.OrganizationName = settings.OrganizationName;

            Department selectedDept = null;
            foreach (Department d in departments)
            {
                if (d.Id == exportWindow.SelectedDepartmentId)
                {
                    selectedDept = d;
                    break;
                }
            }

            if (selectedDept != null)
            {
                timesheet.Department = selectedDept.Name;
            }

            string desktop = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
            string fileName = "Табель_T13_" + _selectedYear + "_" + month.ToString("D2") + ".xlsx";
            string filePath = Path.Combine(desktop, fileName);

            _exportService.ExportToExcel(timesheet, filePath, exportWindow.DocumentNumber,
                exportWindow.DocumentDate, settings.Okpo);

            Logger.Log("Экспорт в Excel", "подразделение: " + timesheet.Department + ", месяц " + month.ToString() + "." + _selectedYear.ToString());
            MessageBox.Show("Табель сохранён на рабочий стол:\n" + filePath, "Готово",
                MessageBoxButton.OK, MessageBoxImage.Information);
        }

        public void ResetFilter()
        {
            SelectedDepartmentId = 0;
        }
    }
}