DD.WellWorkover.Cloud/AsbCloudWebApi/Controllers/ProcessMaps/ProcessMapBaseController.cs

using System;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data;
using AsbCloudApp.Data.ProcessMaps;
using AsbCloudApp.Exceptions;
using AsbCloudApp.Repositories;
using AsbCloudApp.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace AsbCloudWebApi.Controllers.ProcessMaps;

/// <summary>
/// РТК
/// </summary>
[ApiController]
[Route("api/well/{idWell}/[controller]")]
[Authorize]
public abstract class ProcessMapBaseController<T> : ControllerBase
    where T : ProcessMapPlanBaseDto
{
    protected int IdUser
    {
        get
        {
            var idUser = User.GetUserId();

            if (!idUser.HasValue)
                throw new ForbidException("Неизвестный пользователь");

            return idUser.Value;
        }
    }

    private readonly IWellService wellService;
    private readonly IUserRepository userRepository;
    private readonly ICrudRepository<WellSectionTypeDto> wellSectionRepository;

    protected readonly IRepositoryWellRelated<T> repository;

    protected ProcessMapBaseController(IWellService wellService,
        IProcessMapPlanRepository<T> repository,
        IUserRepository userRepository,
	   ICrudRepository<WellSectionTypeDto> wellSectionRepository)
    {
        this.wellService = wellService;
        this.repository = repository;
        this.userRepository = userRepository;
        this.wellSectionRepository = wellSectionRepository;
    }

    /// <summary>
    /// Создание РТК
    /// </summary>
    /// <param name="processMap">Тело запроса</param>
    /// <param name="idWell">Id скважины</param>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    [HttpPost]
    [ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
    public virtual async Task<IActionResult> InsertAsync(T processMap, int idWell, CancellationToken cancellationToken)
    {
	   processMap.IdWell = idWell;
        processMap.IdUser = IdUser;
        processMap.LastUpdate = DateTime.UtcNow;

	   await CheckIsExistsWellSectionTypeAsync(processMap.IdWellSectionType, cancellationToken);

	   await AssertUserHasAccessToEditProcessMapAsync(processMap.IdWell, cancellationToken);

        var result = await repository.InsertAsync(processMap, cancellationToken);

        return Ok(result);
    }

    /// <summary>
    /// Обновление РТК
    /// </summary>
    /// <param name="processMap">Тело запроса</param>
    /// <param name="idWell">Id скважины</param>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    [HttpPut]
    [ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
    public virtual async Task<IActionResult> UpdateAsync(T processMap, int idWell, CancellationToken cancellationToken)
    {
        processMap.IdWell = idWell;
        processMap.IdUser = IdUser;
        processMap.LastUpdate = DateTime.UtcNow;

	   await CheckIsExistsWellSectionTypeAsync(processMap.IdWellSectionType, cancellationToken);

	   await AssertUserHasAccessToEditProcessMapAsync(idWell, cancellationToken);

        var result = await repository.UpdateAsync(processMap, cancellationToken);

        if (result == ICrudRepository<T>.ErrorIdNotFound)
            return this.ValidationBadRequest(nameof(processMap.Id), $"РТК с Id: {processMap.Id} не существует");

        return Ok(result);
    }

    /// <summary>
    /// Удаление РТК
    /// </summary>
    /// <param name="id">Id удаляемой РТК</param>
    /// <param name="idWell">Id скважины</param>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    [HttpDelete]
    [ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
    public virtual async Task<IActionResult> DeleteAsync(int id, int idWell, CancellationToken cancellationToken)
    {
	   await AssertUserHasAccessToEditProcessMapAsync(idWell, cancellationToken);

        var result = await repository.DeleteAsync(id, cancellationToken);

        return Ok(result);
    }

    /// <summary>
    /// Получение РТК по Id скважины
    /// </summary>
    /// <param name="idWell">Id скважины</param>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    [HttpGet]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    public async Task<IActionResult> GetAsync(int idWell, CancellationToken cancellationToken)
    {
        var processMaps = await repository.GetByIdWellAsync(idWell, cancellationToken);

        return Ok(processMaps);
    }

    protected async Task AssertUserHasAccessToEditProcessMapAsync(int idWell, CancellationToken cancellationToken)
    {
        var well = await wellService.GetOrDefaultAsync(idWell, cancellationToken)
                   ?? throw new ArgumentInvalidException(nameof(idWell),$"Скважины с {idWell} не существует");

        var idCompany = User.GetCompanyId();

        if (!idCompany.HasValue ||
            !await wellService.IsCompanyInvolvedInWellAsync(idCompany.Value, idWell, cancellationToken))
            throw new ForbidException("Нет доступа к скважине");

        if (well.IdState == 2 && !userRepository.HasPermission(IdUser, "ProcessMap.editCompletedWell"))
            throw new ForbidException("Недостаточно прав для редактирования РТК завершенной скважины");
    }

    private async Task CheckIsExistsWellSectionTypeAsync(int idWellSectionType, CancellationToken cancellationToken)
    {
	   var wellSection = await wellSectionRepository.GetOrDefaultAsync(idWellSectionType, cancellationToken);

	   if (wellSection is null)
		  throw new ArgumentInvalidException(nameof(ProcessMapPlanWellDrillingDto.IdWellSectionType), $"Тип секции с Id: {idWellSectionType} не найден");
    }
}