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

Merge pull request 'ГГД - Добавить в справочник новые операции' (#248) from feature/#26940800-add-some-well-categories into dev

Browse Source 
Reviewed-on: http://test.digitaldrilling.ru:8080/DDrilling/AsbCloudServer/pulls/248
This commit is contained in:
Никита Фролов 2024-04-15 11:02:09 +05:00
commit 0b629afcf0
9 changed files with 11129 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AsbCloudApp/Repositories/IWellOperationCategoryRepository.cs
View File

@ -12,6 +12,6 @@ namespace AsbCloudApp.Repositories
/// список названий операций
/// </summary>
/// <returns></returns>
IEnumerable<WellOperationCategoryDto> Get(bool includeParents);
IEnumerable<WellOperationCategoryDto> Get(bool includeParents, bool includeHidden = true);
}
}

9590
AsbCloudDb/Migrations/20240408112202_Add_NewWellOperationCategories.Designer.cs generated Normal file
View File

File diff suppressed because it is too large Load Diff

1035
AsbCloudDb/Migrations/20240408112202_Add_NewWellOperationCategories.cs Normal file
View File

File diff suppressed because it is too large Load Diff

201
AsbCloudDb/Migrations/AsbCloudDbContextModelSnapshot.cs
View File

File diff suppressed because it is too large Load Diff

25
AsbCloudDb/Model/WellOperationCategory.cs
View File

@ -39,6 +39,11 @@ namespace AsbCloudDb.Model
/// </summary>
public const int IdNonProductiveTime = 3005;
/// <summary>
/// Заключительные работы
/// </summary>
public const int IdFinalWorks = 3006;
/// <summary>
/// КНБК
/// </summary>
@ -129,6 +134,11 @@ namespace AsbCloudDb.Model
/// </summary>
public const int IdOperationsNotIncludedGGD = 4017;
/// <summary>
/// Заключительные операции
/// </summary>
public const int IdFinalOperations = 4019;
/// <summary>
/// Разборка КНБК
/// </summary>
@ -240,6 +250,7 @@ namespace AsbCloudDb.Model
new() { Id = IdGFR, Name = "ГФР", KeyValueName = "dT", KeyValueUnits = "мин" },
new() { Id = IdAuxiliaryOperations, Name = "Вспомогательные операции", KeyValueName = "dT", KeyValueUnits = "мин" },
new() { Id = IdNonProductiveTime, Name = "Непроизводительное время (НПВ)", KeyValueName = "dT", KeyValueUnits = "мин" },
new() { Id = IdFinalWorks, Name = "Заключительные работы", KeyValueName = "dT", KeyValueUnits = "мин" },
};
/// <summary>
@ -265,6 +276,7 @@ namespace AsbCloudDb.Model
new () {Id = IdEmergencyWork, IdParent = 3005, Name = "Аварийные работы", KeyValueName = "dT", KeyValueUnits = "мин" },
new () {Id = IdComplication, IdParent = 3005, Name = "Осложнение", KeyValueName = "dT", KeyValueUnits = "мин" },
new () {Id = IdOperationsNotIncludedGGD, IdParent = 3005, Name = "Незаложенные в ГГД операции", KeyValueName = "dT", KeyValueUnits = "мин" },
new () {Id = IdFinalOperations, IdParent = IdFinalWorks, Name = "Заключительные операции", KeyValueName = "dT", KeyValueUnits = "мин" },
};
/// <summary>
@ -273,8 +285,8 @@ namespace AsbCloudDb.Model
public static WellOperationCategory[] WorkCategories { get; } = new WellOperationCategory[]{
new () {Id = IdBhaDisassembly, IdParent = 4000, Name = "Разборка КНБК", KeyValueName = "dT", KeyValueUnits = "мин" },
new () {Id = IdBhaAssembly, IdParent = 4000, Name = "Сборка КНБК", KeyValueName = "dT", KeyValueUnits = "мин" },
new () {Id = IdSlide, IdParent = 4001, Name = "Бурение слайдом", KeyValueName = "МСП", KeyValueUnits = "м/ч" },
new () {Id = IdRotor, IdParent = 4001, Name = "Бурение ротором", KeyValueName = "МСП", KeyValueUnits = "м/ч" },
new () {Id = IdSlide, IsHidden = true, IdParent = 4001, Name = "Бурение слайдом", KeyValueName = "МСП", KeyValueUnits = "м/ч" },
new () {Id = IdRotor, IsHidden = true, IdParent = 4001, Name = "Бурение ротором", KeyValueName = "МСП", KeyValueUnits = "м/ч" },
new () {Id = IdStaticSurveying, IdParent = 4002, Name = "Замер ЗТС (запись MWD)", KeyValueName = "dT", KeyValueUnits = "мин" },
new () {Id = IdFlashingBeforeConnection, IdParent = 4003, Name = "Промывка перед наращиванием", KeyValueName = "dT", KeyValueUnits = "мин" },
new () {Id = 5006, IdParent = 4003, Name = "Проработка во время бурения", KeyValueName = "dT", KeyValueUnits = "мин" },
@ -381,7 +393,12 @@ namespace AsbCloudDb.Model
new () {Id = 5109, IdParent = 4018, Name = "Стыковка стингера с хвостовиком основного ствола", KeyValueName = "dT", KeyValueUnits = "мин"},
new () {Id = 5110, IdParent = 4018, Name = "Ориентирование и установка стыковочного узла хвостовика", KeyValueName = "dT", KeyValueUnits = "мин"},
new () {Id = 5111, IdParent = 4001, Name = "Бурение с отбором керна", KeyValueName = "МСП", KeyValueUnits = "м/ч"},
new () {Id = 5112, IdParent = 4018, Name = "Работа пакером в обсадной колонне", KeyValueName = "dT", KeyValueUnits = "мин"}
new () {Id = 5112, IdParent = 4018, Name = "Работа пакером в обсадной колонне", KeyValueName = "dT", KeyValueUnits = "мин"},
new () {Id = 5113, IdParent = 4001, Name = "Бурение", KeyValueName = "МСП", KeyValueUnits = "м/ч"},
new () {Id = 5114, IdParent = 4013, Name = "ТО оборудования", KeyValueName = "dT", KeyValueUnits = "мин"},
new () {Id = 5115, IdParent = IdFinalOperations, Name = "Спуск НКТ", KeyValueName = "dT", KeyValueUnits = "мин"},
new () {Id = 5116, IdParent = IdAuxiliaryWork, Name = "Вырезка окна", KeyValueName = "dT", KeyValueUnits = "мин"},
new () {Id = 5117, IdParent = IdAuxiliaryWork, Name = "Расширение ствола", KeyValueName = "dT", KeyValueUnits = "мин"},
};
#endregion
@ -401,6 +418,8 @@ namespace AsbCloudDb.Model
[Column("key_value_units"), Comment("Единицы измерения ключевого показателя операции"), StringLength(16)]
public string? KeyValueUnits { get; set; }
public bool IsHidden { get; set; } = false;
[JsonIgnore]
[ForeignKey(nameof(IdParent))]
public virtual WellOperationCategory? Parent { get; set; } = null!;

5
AsbCloudInfrastructure/Repository/WellOperationCategoryRepository.cs
View File

@ -19,11 +19,14 @@ public class WellOperationCategoryRepository : IWellOperationCategoryRepository
this.memoryCache = memoryCache;
}
public IEnumerable<WellOperationCategoryDto> Get(bool includeParents)
public IEnumerable<WellOperationCategoryDto> Get(bool includeParents, bool includeHidden = true)
{
var categories = memoryCache
.GetOrCreateBasic(db.Set<WellOperationCategory>());
if (!includeHidden)
categories = categories.Where(o => o.IsHidden == false);
if (!includeParents)
{
var parentIds = categories

BIN
AsbCloudInfrastructure/Services/WellOperations/Templates/WellOperationFactTemplate.xlsx
View File

Binary file not shown.

BIN
AsbCloudInfrastructure/Services/WellOperations/Templates/WellOperationPlanTemplate.xlsx
View File

Binary file not shown.

552
AsbCloudWebApi/Controllers/WellOperationController.cs
View File

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