src/MatControl.Business/MovementService.cs - master - valzem/MatControl

src/MatControl.Business/MovementService.cs
575 строк22 KB
MatControl Dev
Этап 15: полировка UX и защита истории движений — горячие клавиши (Enter/Esc в диалогах, Ctrl+N/E/D в списках, Ctrl+I/R/J в движении МЗ, Ctrl+1..7 навигация), блокировка удаления ОС/МЗ/сотрудника при наличии записей в журнале движений, запрет смены состояния на 'Списан'/'К списанию' через редактирование, неотрицательный остаток МЗ, защита AutoFitColumns от пустого листа; инструкция, AGENTS.md, скиллы и задачи обновлены (89 тестов)
09 авг 2026, 13:05
09 авг 2026, 13:051c6a8bc
using MatControl.Domain;
using Microsoft.Extensions.Logging;

namespace MatControl.Business;

public record SupplyWithAvailable(Supply Supply, decimal Available, decimal Issued);

public record SupplyIssue(int EmployeeId, string EmployeeName, decimal Quantity);

public class MovementService
{
    private readonly IAssetRepository _assets;
    private readonly ISupplyRepository _supplies;
    private readonly IEmployeeRepository _employees;
    private readonly IAssetMovementRepository _movements;
    private readonly ILogger<MovementService> _logger;

    public MovementService(
        IAssetRepository assets,
        ISupplyRepository supplies,
        IEmployeeRepository employees,
        IAssetMovementRepository movements,
        ILogger<MovementService> logger)
    {
        _assets = assets;
        _supplies = supplies;
        _employees = employees;
        _movements = movements;
        _logger = logger;
    }

    public async Task<OperationResult<List<AssetMovement>>> GetJournalAsync()
    {
        try
        {
            var movements = await _movements.GetAllAsync();
            return OperationResult<List<AssetMovement>>.Ok(movements);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении журнала движений");
            return OperationResult<List<AssetMovement>>.Fail("Не удалось получить журнал движений");
        }
    }

    public async Task<OperationResult<List<AssetMovement>>> GetSupplyJournalAsync()
    {
        try
        {
            var movements = await _movements.GetAllAsync();
            var supplyMovements = movements.Where(m => m.SupplyId.HasValue).ToList();
            return OperationResult<List<AssetMovement>>.Ok(supplyMovements);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении журнала движений по МЗ");
            return OperationResult<List<AssetMovement>>.Fail("Не удалось получить журнал движений");
        }
    }

    public async Task<OperationResult<List<Asset>>> GetAssignedAssetsByEmployeeAsync(int employeeId)
    {
        try
        {
            var movements = await _movements.GetByEmployeeAsync(employeeId);
            var assets = movements
                .Where(m => m.IsActive && m.AssetId.HasValue && m.ToEmployeeId == employeeId && m.Asset is not null)
                .Select(m => m.Asset!)
                .ToList();
            return OperationResult<List<Asset>>.Ok(assets);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении ОС сотрудника {EmployeeId}", employeeId);
            return OperationResult<List<Asset>>.Fail("Не удалось получить список ОС сотрудника");
        }
    }

    public async Task<OperationResult<List<Asset>>> GetAvailableAssetsAsync(int? excludeEmployeeId = null)
    {
        try
        {
            var assets = await _assets.GetAllAsync();
            var movements = await _movements.GetAllAsync();
            var responsible = await _employees.GetAllResponsibleAsync();
            var responsibleIds = responsible.Select(e => e.Id).ToHashSet();
            var defaultHolderId = responsible.Count > 0 ? responsible[0].Id : (int?)null;

            var holderByAssetId = movements
                .Where(m => m.IsActive && m.AssetId.HasValue)
                .GroupBy(m => m.AssetId!.Value)
                .ToDictionary(g => g.Key, g => g.MaxBy(m => m.TransferDate)!.ToEmployeeId);

            var available = assets
                .Where(a => a.State != AssetState.Списан)
                .Where(a =>
                {
                    if (holderByAssetId.TryGetValue(a.Id, out var currentHolderId))
                    {
                        if (excludeEmployeeId == currentHolderId)
                        {
                            return false;
                        }

                        return responsibleIds.Contains(currentHolderId);
                    }

                    if (defaultHolderId is null)
                    {
                        return true;
                    }

                    return excludeEmployeeId != defaultHolderId;
                })
                .ToList();
            return OperationResult<List<Asset>>.Ok(available);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении свободных ОС");
            return OperationResult<List<Asset>>.Fail("Не удалось получить список свободных ОС");
        }
    }

    public async Task<OperationResult<List<SupplyWithAvailable>>> GetSuppliesWithAvailableAsync()
    {
        try
        {
            var supplies = await _supplies.GetAllAsync();
            var active = await _movements.GetAllAsync();

            var issuedBySupplyId = active
                .Where(m => m.SupplyId.HasValue && m.IsActive)
                .GroupBy(m => m.SupplyId!.Value)
                .ToDictionary(g => g.Key, g => g.Sum(m => m.QuantityTransferred));

            var result = supplies.Select(s =>
            {
                var issued = issuedBySupplyId.TryGetValue(s.Id, out var qty) ? qty : 0;
                var available = Math.Max(0, s.Quantity - issued);
                return new SupplyWithAvailable(s, available, issued);
            }).ToList();

            return OperationResult<List<SupplyWithAvailable>>.Ok(result);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении МЗ с остатками");
            return OperationResult<List<SupplyWithAvailable>>.Fail("Не удалось получить список МЗ");
        }
    }

    public async Task<OperationResult<List<SupplyIssue>>> GetActiveSupplyIssuesAsync(int supplyId)
    {
        try
        {
            var active = await _movements.GetActiveBySupplyAsync(supplyId);
            var issues = active
                .Where(m => m.IsActive && m.ToEmployee is not null)
                .GroupBy(m => m.ToEmployeeId)
                .Select(g => new SupplyIssue(
                    g.Key,
                    g.First().ToEmployee!.FullName,
                    g.Sum(m => m.QuantityTransferred)))
                .ToList();
            return OperationResult<List<SupplyIssue>>.Ok(issues);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении активных выдач МЗ {SupplyId}", supplyId);
            return OperationResult<List<SupplyIssue>>.Fail("Не удалось получить активные выдачи МЗ");
        }
    }

    public async Task<OperationResult<List<AssetMovement>>> GetActiveAsync()
    {
        try
        {
            var all = await _movements.GetAllAsync();
            var active = all.Where(m => m.IsActive).ToList();
            return OperationResult<List<AssetMovement>>.Ok(active);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении активных движений");
            return OperationResult<List<AssetMovement>>.Fail("Не удалось получить активные движения");
        }
    }

    public async Task<OperationResult<List<Employee>>> GetAllEmployeesAsync()
    {
        try
        {
            var employees = await _employees.GetAllAsync();
            return OperationResult<List<Employee>>.Ok(employees);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении списка сотрудников");
            return OperationResult<List<Employee>>.Fail("Не удалось получить список сотрудников");
        }
    }

    public async Task<OperationResult<List<Asset>>> GetIssuableAssetsAsync()
    {
        try
        {
            var assets = await _assets.GetAllAsync();
            var issuable = assets.Where(a => a.State != AssetState.Списан).ToList();
            return OperationResult<List<Asset>>.Ok(issuable);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении списка ОС для выдачи");
            return OperationResult<List<Asset>>.Fail("Не удалось получить список ОС");
        }
    }

    public async Task<OperationResult<List<Supply>>> GetSuppliesAsync()
    {
        try
        {
            var supplies = await _supplies.GetAllAsync();
            return OperationResult<List<Supply>>.Ok(supplies);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении списка МЗ");
            return OperationResult<List<Supply>>.Fail("Не удалось получить список МЗ");
        }
    }

    public async Task<OperationResult<decimal>> GetAvailableQuantityAsync(int supplyId)
    {
        try
        {
            var supply = await _supplies.GetByIdAsync(supplyId);
            if (supply is null)
            {
                return OperationResult<decimal>.Fail("Материальный запас не найден");
            }

            var active = await _movements.GetActiveBySupplyAsync(supplyId);
            var issued = active.Where(m => m.IsActive).Sum(m => m.QuantityTransferred);
            var available = supply.Quantity - issued;
            return OperationResult<decimal>.Ok(available < 0 ? 0 : available);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при расчете остатка МЗ {Id}", supplyId);
            return OperationResult<decimal>.Fail("Не удалось рассчитать остаток");
        }
    }

    public async Task<OperationResult<Employee>> GetResponsibleAsync()
    {
        try
        {
            var mol = await _employees.GetResponsibleAsync();
            if (mol is null)
            {
                return OperationResult<Employee>.Fail("Материально ответственное лицо не назначено");
            }

            return OperationResult<Employee>.Ok(mol);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении МОЛ");
            return OperationResult<Employee>.Fail("Не удалось получить данные о МОЛ");
        }
    }

    public async Task<OperationResult> IssueAssetAsync(int assetId, int toEmployeeId, DateTime date)
    {
        try
        {
            var asset = await _assets.GetByIdAsync(assetId);
            if (asset is null)
            {
                return OperationResult.Fail("Основное средство не найдено");
            }

            if (asset.State == AssetState.Списан)
            {
                return OperationResult.Fail("Нельзя выдать списанное ОС");
            }

            var employee = await _employees.GetByIdAsync(toEmployeeId);
            if (employee is null)
            {
                return OperationResult.Fail("Сотрудник не найден");
            }

            if (date.Date > DateTime.Today)
            {
                return OperationResult.Fail("Дата выдачи не может быть позже текущей");
            }

            var mol = await _employees.GetResponsibleAsync();
            var activeMovements = await _movements.GetActiveByAssetAsync(assetId);
            var currentMovement = activeMovements.FirstOrDefault();
            var fromEmployeeId = currentMovement?.ToEmployeeId ?? mol?.Id ?? toEmployeeId;

            if (currentMovement is not null && currentMovement.ToEmployeeId == toEmployeeId)
            {
                return OperationResult.Fail("ОС уже числится за этим сотрудником");
            }

            if (currentMovement is not null)
            {
                currentMovement.IsActive = false;
                currentMovement.ReturnDate = date.Date;
                await _movements.UpdateAsync(currentMovement);
            }

            await _movements.AddAsync(new AssetMovement
            {
                AssetId = asset.Id,
                FromEmployeeId = fromEmployeeId,
                ToEmployeeId = employee.Id,
                TransferDate = date.Date,
                QuantityTransferred = 1,
                MovementType = MovementType.Выдача,
                IsActive = true
            });

            await _movements.SaveAsync();
            _logger.LogInformation("ОС {Inv} выдано сотруднику {Employee}", asset.InventoryNumber, employee.FullName);
            return OperationResult.Ok("ОС выдано");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при выдаче ОС {AssetId}", assetId);
            return OperationResult.Fail("Не удалось выдать ОС");
        }
    }

    public async Task<OperationResult> IssueSupplyAsync(int supplyId, int toEmployeeId, decimal quantity, DateTime date)
    {
        try
        {
            var supply = await _supplies.GetByIdAsync(supplyId);
            if (supply is null)
            {
                return OperationResult.Fail("Материальный запас не найден");
            }

            var employee = await _employees.GetByIdAsync(toEmployeeId);
            if (employee is null)
            {
                return OperationResult.Fail("Сотрудник не найден");
            }

            if (quantity <= 0)
            {
                return OperationResult.Fail("Укажите количество больше нуля");
            }

            if (date.Date > DateTime.Today)
            {
                return OperationResult.Fail("Дата выдачи не может быть позже текущей");
            }

            var activeMovements = await _movements.GetActiveBySupplyAsync(supplyId);
            var issued = activeMovements.Sum(m => m.QuantityTransferred);
            var available = Math.Max(0, supply.Quantity - issued);
            if (quantity > available)
            {
                return OperationResult.Fail($"Недостаточно на складе: доступно {available:0.##}");
            }

            var mol = await _employees.GetResponsibleAsync();
            await _movements.AddAsync(new AssetMovement
            {
                SupplyId = supply.Id,
                FromEmployeeId = mol?.Id ?? toEmployeeId,
                ToEmployeeId = employee.Id,
                TransferDate = date.Date,
                QuantityTransferred = quantity,
                MovementType = MovementType.Выдача,
                IsActive = true
            });

            await _movements.SaveAsync();
            _logger.LogInformation("МЗ {Name} выдано {Quantity} сотруднику {Employee}", supply.Name, quantity, employee.FullName);
            return OperationResult.Ok("МЗ выдано");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при выдаче МЗ {SupplyId}", supplyId);
            return OperationResult.Fail("Не удалось выдать МЗ");
        }
    }

    public async Task<OperationResult> ReturnAssetAsync(int assetId)
    {
        try
        {
            var activeMovements = await _movements.GetActiveByAssetAsync(assetId);
            var movement = activeMovements.FirstOrDefault();
            if (movement is null)
            {
                return OperationResult.Fail("Нет активной выдачи для возврата");
            }

            var mol = await _employees.GetResponsibleAsync();

            movement.IsActive = false;
            movement.ReturnDate = DateTime.Today;
            await _movements.UpdateAsync(movement);

            await _movements.AddAsync(new AssetMovement
            {
                AssetId = assetId,
                FromEmployeeId = movement.ToEmployeeId,
                ToEmployeeId = mol?.Id ?? movement.ToEmployeeId,
                TransferDate = DateTime.Today,
                QuantityTransferred = 1,
                MovementType = MovementType.Возврат,
                IsActive = false
            });

            await _movements.SaveAsync();
            _logger.LogInformation("Возвращено ОС {AssetId}", assetId);
            return OperationResult.Ok("ОС возвращено");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при возврате ОС {AssetId}", assetId);
            return OperationResult.Fail("Не удалось вернуть ОС");
        }
    }

    public async Task<OperationResult> ReturnSupplyAsync(int supplyId, decimal quantity, int? fromEmployeeId = null)
    {
        try
        {
            if (quantity <= 0)
            {
                return OperationResult.Fail("Укажите количество больше нуля");
            }

            var activeMovements = await _movements.GetActiveBySupplyAsync(supplyId);
            if (activeMovements.Count == 0)
            {
                return OperationResult.Fail("Нет активной выдачи для возврата");
            }

            int fromEmployeeIdResolved;
            if (fromEmployeeId.HasValue)
            {
                if (!activeMovements.Any(m => m.ToEmployeeId == fromEmployeeId.Value))
                {
                    return OperationResult.Fail("У этого сотрудника нет активной выдачи по данному МЗ");
                }

                fromEmployeeIdResolved = fromEmployeeId.Value;
            }
            else
            {
                fromEmployeeIdResolved = activeMovements[0].ToEmployeeId;
            }

            var employeeSet = activeMovements
                .Where(m => m.ToEmployeeId == fromEmployeeIdResolved)
                .ToList();
            var totalIssued = employeeSet.Sum(m => m.QuantityTransferred);
            if (quantity > totalIssued)
            {
                return OperationResult.Fail($"Нельзя вернуть больше, чем выдано ({totalIssued:0.##})");
            }

            var mol = await _employees.GetResponsibleAsync();

            var remaining = quantity;
            foreach (var movement in employeeSet.OrderBy(m => m.TransferDate))
            {
                if (remaining <= 0)
                {
                    break;
                }

                if (movement.QuantityTransferred <= remaining)
                {
                    remaining -= movement.QuantityTransferred;
                    movement.IsActive = false;
                    movement.ReturnDate = DateTime.Today;
                    await _movements.UpdateAsync(movement);
                }
                else
                {
                    movement.QuantityTransferred -= remaining;
                    remaining = 0;
                    await _movements.UpdateAsync(movement);
                }
            }

            await _movements.AddAsync(new AssetMovement
            {
                SupplyId = supplyId,
                FromEmployeeId = fromEmployeeIdResolved,
                ToEmployeeId = mol?.Id ?? fromEmployeeIdResolved,
                TransferDate = DateTime.Today,
                QuantityTransferred = quantity,
                MovementType = MovementType.Возврат,
                IsActive = false
            });

            await _movements.SaveAsync();
            _logger.LogInformation("Возвращено МЗ {SupplyId} в количестве {Quantity}", supplyId, quantity);
            return OperationResult.Ok("МЗ возвращено");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при возврате МЗ {SupplyId}", supplyId);
            return OperationResult.Fail("Не удалось вернуть МЗ");
        }
    }

    public async Task<OperationResult> WriteOffAssetAsync(int assetId, AssetState state)
    {
        try
        {
            if (state != AssetState.К_списанию && state != AssetState.Списан)
            {
                return OperationResult.Fail("Для списания допустимо состояние «К списанию» или «Списан»");
            }

            var asset = await _assets.GetByIdAsync(assetId);
            if (asset is null)
            {
                return OperationResult.Fail("Основное средство не найдено");
            }

            var mol = await _employees.GetResponsibleAsync();
            if (mol is null)
            {
                return OperationResult.Fail("Назначьте материально ответственное лицо перед списанием ОС");
            }

            var activeMovements = await _movements.GetActiveByAssetAsync(assetId);
            var movement = activeMovements.FirstOrDefault();

            if (movement is not null)
            {
                movement.IsActive = false;
                await _movements.UpdateAsync(movement);
            }

            await _movements.AddAsync(new AssetMovement
            {
                AssetId = asset.Id,
                FromEmployeeId = movement?.ToEmployeeId ?? mol.Id,
                ToEmployeeId = mol.Id,
                TransferDate = DateTime.Today,
                ReturnDate = DateTime.Today,
                QuantityTransferred = 1,
                MovementType = MovementType.Списание,
                IsActive = false
            });

            asset.State = state;
            await _assets.UpdateAsync(asset);
            await _movements.SaveAsync();
            _logger.LogInformation("ОС {Inv} переведено в состояние {State}", asset.InventoryNumber, state);
            return OperationResult.Ok("ОС списано");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при списании ОС {AssetId}", assetId);
            return OperationResult.Fail("Не удалось списать ОС");
        }
    }
}