on.nemtina/DD.WellWorkover.Cloud
1
0
Fork 0
forked from ddrilling/AsbCloudServer
Code Pull Requests Activity

Убрано лишнее

Browse Source
This commit is contained in:
Olga Nemt 2024-04-10 12:21:11 +05:00
parent 878dfb3daa
commit dfa7f628ec
1 changed files with 272 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

548
AsbCloudWebApi/Controllers/WellOperationController.cs
View File

@ -16,9 +16,6 @@ using AsbCloudApp.Requests.ExportOptions;
using AsbCloudApp.Requests.ParserOptions; using AsbCloudApp.Requests.ParserOptions;
using AsbCloudDb.Model; using AsbCloudDb.Model;
using AsbCloudInfrastructure.Services.WellOperations.Factories; using AsbCloudInfrastructure.Services.WellOperations.Factories;
using ClosedXML.Excel;
using AsbCloudInfrastructure.Services.ProcessMapPlan.Export;
using AsbCloudApp.Services.Export;
namespace AsbCloudWebApi.Controllers; namespace AsbCloudWebApi.Controllers;
@ -30,324 +27,323 @@ namespace AsbCloudWebApi.Controllers;
[Authorize] [Authorize]
public class WellOperationController : ControllerBase public class WellOperationController : ControllerBase
{ {
private readonly IDictionary<int, string> templateNames = new Dictionary<int, string> private readonly IDictionary<int, string> templateNames = new Dictionary<int, string>
{ {
{ WellOperation.IdOperationTypeFact, "ЕЦП_шаблон_файла_фактические_операции.xlsx" }, { WellOperation.IdOperationTypeFact, "ЕЦП_шаблон_файла_фактические_операции.xlsx" },
{ WellOperation.IdOperationTypePlan, "ЕЦП_шаблон_файла_плановые_операции.xlsx" } { WellOperation.IdOperationTypePlan, "ЕЦП_шаблон_файла_плановые_операции.xlsx" }
}; };
private readonly IUserRepository userRepository; private readonly IUserRepository userRepository;
private readonly IWellOperationRepository wellOperationRepository; private readonly IWellOperationRepository wellOperationRepository;
private readonly IWellOperationCategoryRepository wellOperationCategoryRepository; private readonly IWellOperationCategoryRepository wellOperationCategoryRepository;
private readonly IWellService wellService; private readonly IWellService wellService;
private readonly WellOperationParserFactory wellOperationParserFactory; private readonly WellOperationParserFactory wellOperationParserFactory;
private readonly WellOperationExportServiceFactory wellOperationExportServiceFactory; private readonly WellOperationExportServiceFactory wellOperationExportServiceFactory;
//private readonly IExportService<WellRelatedExportRequest> templateService;
public WellOperationController(IWellOperationRepository wellOperationRepository, public WellOperationController(IWellOperationRepository wellOperationRepository,
IWellOperationCategoryRepository wellOperationCategoryRepository, IWellOperationCategoryRepository wellOperationCategoryRepository,
IWellService wellService, IWellService wellService,
IUserRepository userRepository, IUserRepository userRepository,
WellOperationParserFactory wellOperationParserFactory, WellOperationParserFactory wellOperationParserFactory,
WellOperationExportServiceFactory wellOperationExportServiceFactory) WellOperationExportServiceFactory wellOperationExportServiceFactory)
{ {
this.wellOperationRepository = wellOperationRepository; this.wellOperationRepository = wellOperationRepository;
this.wellOperationCategoryRepository = wellOperationCategoryRepository; this.wellOperationCategoryRepository = wellOperationCategoryRepository;
this.wellService = wellService; this.wellService = wellService;
this.userRepository = userRepository; this.userRepository = userRepository;
this.wellOperationParserFactory = wellOperationParserFactory; this.wellOperationParserFactory = wellOperationParserFactory;
this.wellOperationExportServiceFactory = wellOperationExportServiceFactory; this.wellOperationExportServiceFactory = wellOperationExportServiceFactory;
} }
/// <summary> /// <summary>
/// Добавляет новые операции на скважине /// Добавляет новые операции на скважине
/// </summary> /// </summary>
/// <param name="idWell">Id скважины</param> /// <param name="idWell">Id скважины</param>
/// <param name="dtos">Добавляемые операции</param> /// <param name="dtos">Добавляемые операции</param>
/// <param name="deleteBeforeInsert">Удалить операции перед сохранением</param> /// <param name="deleteBeforeInsert">Удалить операции перед сохранением</param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns>Количество добавленных в БД записей</returns> /// <returns>Количество добавленных в БД записей</returns>
[HttpPost("{deleteBeforeInsert:bool}")] [HttpPost("{deleteBeforeInsert:bool}")]
[Permission] [Permission]
[ProducesResponseType(typeof(int), StatusCodes.Status200OK)] [ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)] [ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
public async Task<IActionResult> InsertRangeAsync( public async Task<IActionResult> InsertRangeAsync(
[Range(1, int.MaxValue, ErrorMessage = "Id скважины не может быть меньше 1")] [Range(1, int.MaxValue, ErrorMessage = "Id скважины не может быть меньше 1")]
int idWell, int idWell,
bool deleteBeforeInsert, bool deleteBeforeInsert,
[FromBody] IEnumerable<WellOperationDto> dtos, [FromBody] IEnumerable<WellOperationDto> dtos,
CancellationToken cancellationToken) CancellationToken cancellationToken)
{ {
if (!await CanUserAccessToWellAsync(idWell, cancellationToken)) if (!await CanUserAccessToWellAsync(idWell, cancellationToken))
return Forbid(); return Forbid();
if (!await CanUserEditWellOperationsAsync(idWell, cancellationToken)) if (!await CanUserEditWellOperationsAsync(idWell, cancellationToken))
return Forbid(); return Forbid();
foreach (var dto in dtos) foreach (var dto in dtos)
{ {
dto.IdWell = idWell; dto.IdWell = idWell;
dto.LastUpdateDate = null; dto.LastUpdateDate = null;
dto.IdUser = User.GetUserId(); dto.IdUser = User.GetUserId();
} }
var result = await wellOperationRepository.InsertRangeAsync(dtos, deleteBeforeInsert, cancellationToken); var result = await wellOperationRepository.InsertRangeAsync(dtos, deleteBeforeInsert, cancellationToken);
return Ok(result); return Ok(result);
} }
/// <summary> /// <summary>
/// Обновляет выбранную операцию на скважине /// Обновляет выбранную операцию на скважине
/// </summary> /// </summary>
/// <param name="idWell">id скважины</param> /// <param name="idWell">id скважины</param>
/// <param name="dtos"></param> /// <param name="dtos"></param>
/// <param name="token">Токен отмены задачи</param> /// <param name="token">Токен отмены задачи</param>
/// <returns>Количество обновленных в БД строк</returns> /// <returns>Количество обновленных в БД строк</returns>
[HttpPut] [HttpPut]
[Permission] [Permission]
[ProducesResponseType(typeof(int), StatusCodes.Status200OK)] [ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
public async Task<IActionResult> UpdateRangeAsync(int idWell, public async Task<IActionResult> UpdateRangeAsync(int idWell,
[FromBody] IEnumerable<WellOperationDto> dtos, [FromBody] IEnumerable<WellOperationDto> dtos,
CancellationToken token) CancellationToken token)
{ {
if (!await CanUserAccessToWellAsync(idWell, token)) if (!await CanUserAccessToWellAsync(idWell, token))
return Forbid(); return Forbid();
if (!await CanUserEditWellOperationsAsync(idWell, token)) if (!await CanUserEditWellOperationsAsync(idWell, token))
return Forbid(); return Forbid();
foreach (var dto in dtos) foreach (var dto in dtos)
{ {
dto.IdWell = idWell; dto.IdWell = idWell;
dto.IdUser = User.GetUserId(); dto.IdUser = User.GetUserId();
dto.LastUpdateDate = DateTimeOffset.UtcNow; dto.LastUpdateDate = DateTimeOffset.UtcNow;
} }
var result = await wellOperationRepository.UpdateRangeAsync(dtos, token); var result = await wellOperationRepository.UpdateRangeAsync(dtos, token);
return Ok(result); return Ok(result);
} }
/// <summary> /// <summary>
/// Возвращает словарь типов секций /// Возвращает словарь типов секций
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
[HttpGet("sectionTypes")] [HttpGet("sectionTypes")]
[Permission] [Permission]
[ProducesResponseType(typeof(IEnumerable<WellSectionTypeDto>), StatusCodes.Status200OK)] [ProducesResponseType(typeof(IEnumerable<WellSectionTypeDto>), StatusCodes.Status200OK)]
public IActionResult GetSectionTypes() public IActionResult GetSectionTypes()
{ {
var result = wellOperationRepository.GetSectionTypes(); var result = wellOperationRepository.GetSectionTypes();
return Ok(result); return Ok(result);
} }
/// <summary> /// <summary>
/// Статистика операций по скважине, группированная по категориям /// Статистика операций по скважине, группированная по категориям
/// </summary> /// </summary>
/// <param name="idWell">id скважины</param> /// <param name="idWell">id скважины</param>
/// <param name="request"></param> /// <param name="request"></param>
/// <param name="token"></param> /// <param name="token"></param>
/// <returns></returns> /// <returns></returns>
[HttpGet("groupStat")] [HttpGet("groupStat")]
[Permission] [Permission]
[ProducesResponseType(typeof(IEnumerable<WellGroupOpertionDto>), (int)System.Net.HttpStatusCode.OK)] [ProducesResponseType(typeof(IEnumerable<WellGroupOpertionDto>), (int)System.Net.HttpStatusCode.OK)]
public async Task<IActionResult> GetGroupOperationsAsync( public async Task<IActionResult> GetGroupOperationsAsync(
[FromRoute] int idWell, [FromRoute] int idWell,
[FromQuery] WellOperationRequestBase request, [FromQuery] WellOperationRequestBase request,
CancellationToken token) CancellationToken token)
{ {
if (!await CanUserAccessToWellAsync(idWell, token).ConfigureAwait(false)) if (!await CanUserAccessToWellAsync(idWell, token).ConfigureAwait(false))
return Forbid(); return Forbid();
var requestToservice = new WellOperationRequest(request, new[] { idWell }); var requestToservice = new WellOperationRequest(request, new[] { idWell });
var result = await wellOperationRepository.GetGroupOperationsStatAsync(requestToservice, token);
return Ok(result);
}
/// <summary> var result = await wellOperationRepository.GetGroupOperationsStatAsync(requestToservice, token);
/// Возвращает список имен типов операций на скважине return Ok(result);
/// </summary> }
/// <param name="includeParents">флаг, нужно ли включать родителей в список</param>
/// <returns></returns>
[HttpGet("categories")]
[Permission]
[ProducesResponseType(typeof(IEnumerable<WellOperationCategoryDto>), StatusCodes.Status200OK)]
public IActionResult GetCategories(bool includeParents = true)
{
var result = wellOperationCategoryRepository.Get(includeParents);
return Ok(result);
}
/// <summary> /// <summary>
/// Постраничный список операций на скважине. /// Возвращает список имен типов операций на скважине
/// </summary> /// </summary>
/// <param name="idWell">id скважины</param> /// <param name="includeParents">флаг, нужно ли включать родителей в список</param>
/// <param name="request"></param> /// <returns></returns>
/// <param name="token"></param> [HttpGet("categories")]
/// <returns>Список операций на скважине</returns> [Permission]
[HttpGet] [ProducesResponseType(typeof(IEnumerable<WellOperationCategoryDto>), StatusCodes.Status200OK)]
[Permission] public IActionResult GetCategories(bool includeParents = true)
[ProducesResponseType(typeof(PaginationContainer<WellOperationDto>), StatusCodes.Status200OK)] {
public async Task<IActionResult> GetPageOperationsAsync( var result = wellOperationCategoryRepository.Get(includeParents);
[FromRoute] int idWell, return Ok(result);
[FromQuery] WellOperationRequestBase request, }
CancellationToken token)
{
if (!await CanUserAccessToWellAsync(idWell, token))
return Forbid();
var requestToService = new WellOperationRequest(request, new[] { idWell }); /// <summary>
/// Постраничный список операций на скважине.
var result = await wellOperationRepository.GetPageAsync(requestToService, token); /// </summary>
return Ok(result); /// <param name="idWell">id скважины</param>
} /// <param name="request"></param>
/// <param name="token"></param>
/// <returns>Список операций на скважине</returns>
[HttpGet]
[Permission]
[ProducesResponseType(typeof(PaginationContainer<WellOperationDto>), StatusCodes.Status200OK)]
public async Task<IActionResult> GetPageOperationsAsync(
[FromRoute] int idWell,
[FromQuery] WellOperationRequestBase request,
CancellationToken token)
{
if (!await CanUserAccessToWellAsync(idWell, token))
return Forbid();
/// <summary> var requestToService = new WellOperationRequest(request, new[] { idWell });
/// Создает excel файл с "сетевым графиком"
/// </summary>
/// <param name="idWell">id скважины</param>
/// <param name="scheduleReportService"></param>
/// <param name="token"></param>
/// <returns>Запрашиваемый файл</returns>
[HttpGet("scheduleReport")]
[Permission]
[ProducesResponseType(typeof(PhysicalFileResult), StatusCodes.Status200OK)]
public async Task<IActionResult> ScheduleReportAsync([FromRoute] int idWell,
[FromServices] IScheduleReportService scheduleReportService,
CancellationToken token)
{
var idCompany = User.GetCompanyId();
if (idCompany is null) var result = await wellOperationRepository.GetPageAsync(requestToService, token);
return Forbid(); return Ok(result);
}
if (!await wellService.IsCompanyInvolvedInWellAsync(idCompany.Value, idWell, token)) /// <summary>
return Forbid(); /// Создает excel файл с "сетевым графиком"
/// </summary>
/// <param name="idWell">id скважины</param>
/// <param name="scheduleReportService"></param>
/// <param name="token"></param>
/// <returns>Запрашиваемый файл</returns>
[HttpGet("scheduleReport")]
[Permission]
[ProducesResponseType(typeof(PhysicalFileResult), StatusCodes.Status200OK)]
public async Task<IActionResult> ScheduleReportAsync([FromRoute] int idWell,
[FromServices] IScheduleReportService scheduleReportService,
CancellationToken token)
{
var idCompany = User.GetCompanyId();
var stream = await scheduleReportService.MakeReportAsync(idWell, token); if (idCompany is null)
var fileName = await wellService.GetWellCaptionByIdAsync(idWell, token) + "_ScheduleReport.xlsx"; return Forbid();
return File(stream, "application/octet-stream", fileName);
}
/// <summary> if (!await wellService.IsCompanyInvolvedInWellAsync(idCompany.Value, idWell, token))
/// Удаляет выбранную операцию на скважине return Forbid();
/// </summary>
/// <param name="idWell">id скважины</param>
/// <param name="idOperation">id выбранной операции</param>
/// <param name="token">Токен отмены задачи</param>
/// <returns>Количество удаленных из БД строк</returns>
[HttpDelete("{idOperation}")]
[Permission]
[ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
public async Task<IActionResult> DeleteAsync(int idWell, int idOperation, CancellationToken token)
{
if (!await CanUserAccessToWellAsync(idWell, token))
return Forbid();
if (!await CanUserEditWellOperationsAsync(idWell, token)) var stream = await scheduleReportService.MakeReportAsync(idWell, token);
return Forbid(); var fileName = await wellService.GetWellCaptionByIdAsync(idWell, token) + "_ScheduleReport.xlsx";
return File(stream, "application/octet-stream", fileName);
}
var result = await wellOperationRepository.DeleteRangeAsync(new[] { idOperation }, token); /// <summary>
/// Удаляет выбранную операцию на скважине
/// </summary>
/// <param name="idWell">id скважины</param>
/// <param name="idOperation">id выбранной операции</param>
/// <param name="token">Токен отмены задачи</param>
/// <returns>Количество удаленных из БД строк</returns>
[HttpDelete("{idOperation}")]
[Permission]
[ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
public async Task<IActionResult> DeleteAsync(int idWell, int idOperation, CancellationToken token)
{
if (!await CanUserAccessToWellAsync(idWell, token))
return Forbid();
return Ok(result); if (!await CanUserEditWellOperationsAsync(idWell, token))
} return Forbid();
/// <summary> var result = await wellOperationRepository.DeleteRangeAsync(new[] { idOperation }, token);
/// Формирование excel файла с операциями на скважине
/// </summary>
/// <param name="idWell"></param>
/// <param name="idType"></param>
/// <param name="token"></param>
/// <returns></returns>
[HttpGet("export")]
[ProducesResponseType(typeof(PhysicalFileResult), StatusCodes.Status200OK, "application/octet-stream")]
public async Task<IActionResult> ExportAsync(int idWell,
int idType,
CancellationToken token)
{
var options = new WellOperationExportRequest(idWell, idType);
var exportService = wellOperationExportServiceFactory.CreateExportService<WellOperationExportRequest>(idType);
var (fileName, file) = await exportService.ExportAsync(options, token); return Ok(result);
}
return File(file, "application/octet-stream", fileName); /// <summary>
} /// Формирование excel файла с операциями на скважине
/// </summary>
/// <param name="idWell"></param>
/// <param name="idType"></param>
/// <param name="token"></param>
/// <returns></returns>
[HttpGet("export")]
[ProducesResponseType(typeof(PhysicalFileResult), StatusCodes.Status200OK, "application/octet-stream")]
public async Task<IActionResult> ExportAsync(int idWell,
int idType,
CancellationToken token)
{
var options = new WellOperationExportRequest(idWell, idType);
var exportService = wellOperationExportServiceFactory.CreateExportService<WellOperationExportRequest>(idType);
/// <summary> var (fileName, file) = await exportService.ExportAsync(options, token);
/// Парсинг ГГД из excel (xlsx) файла
/// </summary>
/// <param name="idWell"></param>
/// <param name="idType"></param>
/// <param name="file"></param>
/// <param name="token"></param>
/// <returns></returns>
[HttpPost("parse/{idType}")]
[Permission]
[ProducesResponseType(typeof(ParserResultDto<WellOperationDto>), StatusCodes.Status200OK)]
public async Task<IActionResult> ParseAsync(int idWell,
int idType,
[Required] IFormFile file,
CancellationToken token)
{
if (!await CanUserAccessToWellAsync(idWell, token))
return Forbid();
if (!await CanUserEditWellOperationsAsync(idWell, token)) return File(file, "application/octet-stream", fileName);
return Forbid(); }
var stream = file.GetExcelFile(); /// <summary>
/// Парсинг ГГД из excel (xlsx) файла
/// </summary>
/// <param name="idWell"></param>
/// <param name="idType"></param>
/// <param name="file"></param>
/// <param name="token"></param>
/// <returns></returns>
[HttpPost("parse/{idType}")]
[Permission]
[ProducesResponseType(typeof(ParserResultDto<WellOperationDto>), StatusCodes.Status200OK)]
public async Task<IActionResult> ParseAsync(int idWell,
int idType,
[Required] IFormFile file,
CancellationToken token)
{
if (!await CanUserAccessToWellAsync(idWell, token))
return Forbid();
try if (!await CanUserEditWellOperationsAsync(idWell, token))
{ return Forbid();
var timezone = wellService.GetTimezone(idWell);
var options = new WellOperationParserRequest(idWell, idType, timezone);
var parser = wellOperationParserFactory.CreateParser<WellOperationParserRequest>(idType);
var result = parser.Parse(stream, options);
return Ok(result); var stream = file.GetExcelFile();
}
catch (FileFormatException ex)
{
return this.ValidationBadRequest(nameof(file), ex.Message);
}
}
/// <summary> try
/// Получение шаблона для заполнения ГГД {
/// </summary> var timezone = wellService.GetTimezone(idWell);
/// <returns></returns> var options = new WellOperationParserRequest(idWell, idType, timezone);
[HttpGet("template")] var parser = wellOperationParserFactory.CreateParser<WellOperationParserRequest>(idType);
[AllowAnonymous] var result = parser.Parse(stream, options);
[ProducesResponseType(typeof(PhysicalFileResult), StatusCodes.Status200OK, "application/octet-stream")]
return Ok(result);
}
catch (FileFormatException ex)
{
return this.ValidationBadRequest(nameof(file), ex.Message);
}
}
/// <summary>
/// Получение шаблона для заполнения ГГД
/// </summary>
/// <returns></returns>
[HttpGet("template")]
[AllowAnonymous]
[ProducesResponseType(typeof(PhysicalFileResult), StatusCodes.Status200OK, "application/octet-stream")]
public IActionResult GetTemplate(int idType) public IActionResult GetTemplate(int idType)
{ {
var parser = wellOperationParserFactory.CreateParser<WellOperationParserRequest>(idType); var parser = wellOperationParserFactory.CreateParser<WellOperationParserRequest>(idType);
var stream = parser.GetTemplateFile(); var stream = parser.GetTemplateFile();
return File(stream, "application/octet-stream", templateNames[idType]); return File(stream, "application/octet-stream", templateNames[idType]);
} }
private async Task<bool> CanUserAccessToWellAsync(int idWell, CancellationToken token) private async Task<bool> CanUserAccessToWellAsync(int idWell, CancellationToken token)
{ {
var idCompany = User.GetCompanyId(); var idCompany = User.GetCompanyId();
return idCompany is not null && await wellService.IsCompanyInvolvedInWellAsync((int)idCompany, return idCompany is not null && await wellService.IsCompanyInvolvedInWellAsync((int)idCompany,
idWell, token).ConfigureAwait(false); idWell, token).ConfigureAwait(false);
} }
private async Task<bool> CanUserEditWellOperationsAsync(int idWell, CancellationToken token) private async Task<bool> CanUserEditWellOperationsAsync(int idWell, CancellationToken token)
{ {
var idUser = User.GetUserId(); var idUser = User.GetUserId();
if (!idUser.HasValue) if (!idUser.HasValue)
return false; return false;
var well = await wellService.GetOrDefaultAsync(idWell, token); var well = await wellService.GetOrDefaultAsync(idWell, token);
if (well is null) if (well is null)
return false; return false;
return well.IdState != 2 || userRepository.HasPermission(idUser.Value, "WellOperation.editCompletedWell"); return well.IdState != 2 || userRepository.HasPermission(idUser.Value, "WellOperation.editCompletedWell");
} }
} }