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

Merge branch 'dev' into feature/#29885445-detector-flashing

Browse Source
This commit is contained in:
on.nemtina 2024-03-15 14:58:05 +05:00
commit b3f31711b7
66 changed files with 2356 additions and 1396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
AsbCloudApp/Data/ProcessMaps/ProcessMapPlanBaseDto.cs
View File

@ -10,7 +10,6 @@ public abstract class ProcessMapPlanBaseDto : ChangeLogAbstract, IId, IWellRelat
/// <summary>
/// Id скважины
/// </summary>
[Range(1, int.MaxValue, ErrorMessage = "Id скважины не может быть меньше 1")]
public int IdWell { get; set; }
/// <summary>

2
AsbCloudApp/Data/ProcessMaps/ProcessMapPlanDrillingDto.cs
View File

@ -17,7 +17,7 @@ public class ProcessMapPlanDrillingDto : ProcessMapPlanBaseDto
/// Название режима бурения
/// </summary>
public string? Mode { get; set; }
/// <summary>
/// Осевая нагрузка, т план
/// </summary>

39
AsbCloudApp/Data/WellOperationDataDto.cs Normal file
View File

@ -0,0 +1,39 @@
namespace AsbCloudApp.Data
{
/// Операция на скважине
public class WellOperationDataDto : IWellRelated
{
/// <inheritdoc/>
public int IdWell { get; set; }
/// <summary>
/// id секции скважины
/// </summary>
public int IdWellSectionType { get; set; }
/// <summary>
/// id категории операции
/// </summary>
public int IdCategory { get; set; }
/// <summary>
/// Глубина на начало операции, м
/// </summary>
public double DepthStart { get; set; }
/// <summary>
/// Продолжительность, часы
/// </summary>
public double DurationHours { get; set; }
/// <summary>
/// Наименование секции
/// </summary>
public string WellSectionTypeCaption { get; set; } = string.Empty;
/// <summary>
/// Наименование категории
/// </summary>
public string OperationCategoryName { get; set; } = string.Empty;
}
}

8
AsbCloudApp/Repositories/IWellOperationRepository.cs
View File

@ -42,6 +42,14 @@ namespace AsbCloudApp.Repositories
/// <returns></returns>
Task<IEnumerable<WellOperationDto>> GetAsync(WellOperationRequest request, CancellationToken token);
/// <summary>
/// Получить список операций по запросу
/// </summary>
/// <param name="request"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<WellOperationDataDto>> GetAsync(WellsOperationRequest request, CancellationToken token);
/// <summary>
/// Получить страницу списка операций
/// </summary>

8
AsbCloudApp/Requests/ExportOptions/IExportOptionsRequest.cs Normal file
View File

@ -0,0 +1,8 @@
namespace AsbCloudApp.Requests.ExportOptions;
/// <summary>
/// Параметры экспорта
/// </summary>
public interface IExportOptionsRequest
{
}

21
AsbCloudApp/Requests/ExportOptions/WellRelatedExportRequest.cs Normal file
View File

@ -0,0 +1,21 @@
namespace AsbCloudApp.Requests.ExportOptions;
/// <summary>
/// Параметры экспорта
/// </summary>
public class WellRelatedExportRequest : IExportOptionsRequest
{
/// <summary>
/// Конструктор
/// </summary>
/// <param name="idWell">Id скважины</param>
public WellRelatedExportRequest(int idWell)
{
IdWell = idWell;
}
/// <summary>
/// Id скважины
/// </summary>
public int IdWell { get; }
}

21
AsbCloudApp/Requests/ParserOptions/WellRelatedParserRequest.cs Normal file
View File

@ -0,0 +1,21 @@
namespace AsbCloudApp.Requests.ParserOptions;
/// <summary>
/// Параметры парсинга
/// </summary>
public class WellRelatedParserRequest : IParserOptionsRequest
{
/// <summary>
/// Конструктор
/// </summary>
/// <param name="idWell">Id скважины</param>
public WellRelatedParserRequest(int idWell)
{
IdWell = idWell;
}
/// <summary>
/// Id скважины
/// </summary>
public int IdWell { get; }
}

61
AsbCloudApp/Requests/WellOperationRequest.cs
View File

@ -6,7 +6,7 @@ namespace AsbCloudApp.Requests
/// <summary>
/// параметры для запроса списка операций
/// </summary>
public class WellOperationRequestBase: RequestBase
public class WellOperationRequestBase : RequestBase
{
/// <summary>
/// фильтр по дате начала операции
@ -42,12 +42,40 @@ namespace AsbCloudApp.Requests
/// фильтр по списку id конструкций секции
/// </summary>
public IEnumerable<int>? SectionTypeIds { get; set; }
/// <summary>
/// Параметры для запроса списка операций.
/// Базовый конструктор
/// </summary>
public WellOperationRequestBase()
{ }
/// <summary>
/// Параметры для запроса списка операций.
/// Копирующий конструктор
/// </summary>
/// <param name="request"></param>
public WellOperationRequestBase(WellOperationRequestBase request)
{
GeDepth = request.GeDepth;
LeDepth = request.LeDepth;
GeDate = request.GeDate;
LtDate = request.LtDate;
OperationCategoryIds = request.OperationCategoryIds;
OperationType = request.OperationType;
SectionTypeIds = request.SectionTypeIds;
Skip = request.Skip;
Take = request.Take;
SortFields = request.SortFields;
}
}
/// <summary>
/// Параметры для запроса списка операций (с id скважины)
/// </summary>
public class WellOperationRequest: WellOperationRequestBase
public class WellOperationRequest : WellOperationRequestBase
{
/// <summary>
/// id скважины
@ -57,7 +85,7 @@ namespace AsbCloudApp.Requests
/// <summary>
/// ctor
/// </summary>
public WellOperationRequest(){}
public WellOperationRequest() { }
/// <summary>
/// копирующий конструктор
@ -65,21 +93,20 @@ namespace AsbCloudApp.Requests
/// <param name="request"></param>
/// <param name="idWell"></param>
public WellOperationRequest(WellOperationRequestBase request, int idWell)
:base(request)
{
this.IdWell = idWell;
this.GeDepth = request.GeDepth;
this.LeDepth = request.LeDepth;
this.GeDate = request.GeDate;
this.LtDate = request.LtDate;
this.OperationCategoryIds = request.OperationCategoryIds;
this.OperationType = request.OperationType;
this.SectionTypeIds = request.SectionTypeIds;
this.Skip= request.Skip;
this.Take= request.Take;
this.SortFields = request.SortFields;
IdWell = idWell;
}
}
/// <summary>
/// Параметры для запроса списка операций (с массивом id скважин)
/// </summary>
public class WellsOperationRequest : WellOperationRequestBase
{
/// <summary>
/// ids скважин
/// </summary>
public IEnumerable<int> IdsWell { get; set; } = null!;
}
}

21
AsbCloudApp/Services/IExportService.cs Normal file
View File

@ -0,0 +1,21 @@
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Requests.ExportOptions;
namespace AsbCloudApp.Services;
/// <summary>
/// Экспорт данных
/// </summary>
public interface IExportService<in TOptions>
where TOptions : IExportOptionsRequest
{
/// <summary>
/// Экспортировать данные
/// </summary>
/// <param name="options"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<(string FileName, Stream File)> ExportAsync(TOptions options, CancellationToken token);
}

14
AsbCloudApp/Services/IParserService.cs
View File

@ -8,8 +8,10 @@ namespace AsbCloudApp.Services;
/// Сервис парсинга
/// </summary>
/// <typeparam name="TDto"></typeparam>
public interface IParserService<TDto> : IParserService
/// <typeparam name="TOptions"></typeparam>
public interface IParserService<TDto, in TOptions>
where TDto : class, IId
where TOptions : IParserOptionsRequest
{
/// <summary>
/// Распарсить файл
@ -17,19 +19,11 @@ public interface IParserService<TDto> : IParserService
/// <param name="file"></param>
/// <param name="options"></param>
/// <returns></returns>
ParserResultDto<TDto> Parse<TOptions>(Stream file, TOptions options)
where TOptions : IParserOptionsRequest;
ParserResultDto<TDto> Parse(Stream file, TOptions options);
/// <summary>
/// Получение шаблона для заполнения
/// </summary>
/// <returns></returns>
Stream GetTemplateFile();
}
/// <summary>
/// Сервис парсинга(интерфейс маркер)
/// </summary>
public interface IParserService
{
}

21
AsbCloudApp/Services/IWellCompositeOperationService.cs Normal file
View File

@ -0,0 +1,21 @@
using AsbCloudApp.Data;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
namespace AsbCloudApp.Services
{
/// <summary>
/// Интерфейс для вычисления композитной скважины
/// </summary>
public interface IWellCompositeOperationService
{
/// <summary>
/// Получение данных для построения композитной скважины
/// </summary>
/// <param name="idsWells"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<List<Dictionary<int, WellOperationDataDto>>> GetAsync(IEnumerable<int> idsWells, CancellationToken token);
}
}

16
AsbCloudInfrastructure/Background/PeriodicWorks/WorkDataSaubStat.cs
View File

@ -154,13 +154,19 @@ namespace AsbCloudInfrastructure.Background.PeriodicWorks
var hasOscillation = EnabledSubsystemsFlags.AutoOscillation.HasEnabledSubsystems(operation.EnabledSubsystems);
var aggregatedValues = CalcAggregate(span);
var dateStart = span[0].DateTime;
var dateEnd = span[^1].DateTime;
var depthStart = span[0].WellDepth;
var depthEnd = span[^1].WellDepth;
var speed = ((depthEnd - depthStart) / (dateEnd - dateStart).TotalHours);
var processMapDrillingCacheItem = new DataSaubStatDto
{
DateStart = operation.DateStart,
DateEnd = operation.DateEnd,
DepthStart = operation.DepthStart,
DepthEnd = operation.DepthEnd,
Speed = (operation.DepthEnd - operation.DepthStart) / ((operation.DateEnd - operation.DateStart).TotalHours),
DateStart = dateStart,
DateEnd = dateEnd,
DepthStart = depthStart,
DepthEnd = depthEnd,
Speed = speed,
BlockSpeedSp = span[0].BlockSpeedSp,
Pressure = aggregatedValues.Pressure,
PressureIdle = span[0].PressureIdle,

12
AsbCloudInfrastructure/DependencyInjection.cs
View File

@ -45,6 +45,7 @@ using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using System;
using AsbCloudInfrastructure.Services.ProcessMapPlan.Export;
namespace AsbCloudInfrastructure
{
@ -161,9 +162,6 @@ namespace AsbCloudInfrastructure
services.AddScoped<IWellService, WellService>();
services.AddTransient<IWellOperationImportService, WellOperationImportService>();
services.AddTransient<IProcessMapReportDrillingExportService, ProcessMapReportDataSaubStatExportService>();
services.AddTransient<TrajectoryPlanExportService>();
services.AddTransient<TrajectoryFactManualExportService>();
services.AddTransient<TrajectoryFactNnbExportService>();
services.AddTransient<IWellOperationRepository, WellOperationRepository>();
services.AddTransient<IDailyReportService, DailyReportService>();
services.AddTransient<IDetectedOperationService, DetectedOperationService>();
@ -198,6 +196,7 @@ namespace AsbCloudInfrastructure
services.AddTransient<ICrudRepository<NotificationCategoryDto>, CrudCacheRepositoryBase<NotificationCategoryDto,
NotificationCategory>>();
services.AddTransient<IDrillTestRepository, DrillTestRepository>();
services.AddTransient<IWellCompositeOperationService, WellCompositeOperationService>();
// admin crud services:
services.AddTransient<ICrudRepository<TelemetryDto>, CrudCacheRepositoryBase<TelemetryDto, Telemetry>>(s =>
@ -294,7 +293,14 @@ namespace AsbCloudInfrastructure
services.AddTransient<TrajectoryFactManualParser>();
services.AddTransient<ProcessMapPlanDrillingParser>();
services.AddTransient<ProcessMapPlanReamParser>();
services.AddTransient<TrajectoryPlanExportService>();
services.AddTransient<TrajectoryFactManualExportService>();
services.AddTransient<TrajectoryFactNnbExportService>();
services.AddTransient<ProcessMapPlanDrillingExportService>();
services.AddTransient<ProcessMapPlanReamExportService>();
return services;
}
}

8
AsbCloudInfrastructure/Repository/ProcessMapPlanBaseRepository.cs
View File

@ -28,6 +28,7 @@ public class ProcessMapPlanBaseRepository<TDto, TEntity> : ChangeLogRepositoryAb
.Include(e => e.Author)
.Include(e => e.Editor)
.Include(e => e.Well)
.Include(e => e.WellSectionType)
.Where(e => e.IdWell == request.IdWell);
if (request.IdWellSectionType.HasValue)
@ -56,4 +57,11 @@ public class ProcessMapPlanBaseRepository<TDto, TEntity> : ChangeLogRepositoryAb
var offset = TimeSpan.FromHours(timezone.Hours);
return offset;
}
protected override TDto Convert(TEntity entity, TimeSpan offset)
{
var dto = base.Convert(entity, offset);
dto.Section = entity.WellSectionType.Caption;
return dto;
}
}

57
AsbCloudInfrastructure/Repository/WellOperationRepository.cs
View File

@ -205,6 +205,17 @@ public class WellOperationRepository : IWellOperationRepository
return dtos.Select(Convert);
}
public async Task<IEnumerable<WellOperationDataDto>> GetAsync(
WellsOperationRequest request,
CancellationToken token)
{
var query = BuildQuery(request)
.AsNoTracking();
var dtos = await query.ToArrayAsync(token);
return dtos;
}
/// <inheritdoc/>
public async Task<PaginationContainer<WellOperationDto>> GetPageAsync(
WellOperationRequest request,
@ -385,7 +396,6 @@ public class WellOperationRepository : IWellOperationRepository
.Include(s => s.OperationCategory)
.Where(o => o.IdWell == request.IdWell);
if (request.OperationType.HasValue)
query = query.Where(e => e.IdType == request.OperationType.Value);
@ -420,6 +430,7 @@ public class WellOperationRepository : IWellOperationRepository
.Where(subOp => subOp.IdType == 1)
.Where(subOp => WellOperationCategory.NonProductiveTimeSubIds.Contains(subOp.IdCategory));
// TODO: Вынести query.Select из метода BuildQuery
var dtos = query.Select(o => new WellOperationDto
{
Id = o.Id,
@ -472,6 +483,50 @@ public class WellOperationRepository : IWellOperationRepository
return dtos.AsNoTracking();
}
/// <summary>
/// Получение данных по запросу
/// </summary>
/// <param name="request"></param>
/// <param name="token"></param>
/// <returns></returns>
private IQueryable<WellOperationDataDto> BuildQuery(WellsOperationRequest request)
{
var query = db.WellOperations
.Where(o => request.IdsWell.Contains(o.IdWell))
.Where(o => request.OperationType == o.IdType);
if (request.SectionTypeIds?.Any() == true)
query = query.Where(o => request.SectionTypeIds.Contains(o.IdWellSectionType));
if (request.OperationCategoryIds?.Any() == true)
query = query.Where(o => request.OperationCategoryIds.Contains(o.IdCategory));
// TODO: Вынести query.Select из метода BuildQuery
var dtos = query.Select(o => new WellOperationDataDto
{
DepthStart = o.DepthStart,
DurationHours = o.DurationHours,
IdCategory = o.IdCategory,
IdWell = o.IdWell,
IdWellSectionType = o.IdWellSectionType,
OperationCategoryName = o.OperationCategory.Name,
WellSectionTypeCaption = o.WellSectionType.Caption,
});
if (request.SortFields?.Any() == true)
{
dtos = dtos.SortBy(request.SortFields);
}
if (request.Skip.HasValue)
dtos = dtos.Skip(request.Skip.Value);
if (request.Take.HasValue)
dtos = dtos.Take(request.Take.Value);
return dtos.AsNoTracking();
}
private WellOperationDto Convert(WellOperationDto dto)
{
var timezone = wellService.GetTimezone(dto.IdWell);

2
AsbCloudInfrastructure/Services/Parser/Cell.cs → AsbCloudInfrastructure/Services/ExcelServices/Cell.cs
View File

@ -3,7 +3,7 @@ using System.Collections.Generic;
using System.IO;
using ClosedXML.Excel;
namespace AsbCloudInfrastructure.Services.Parser;
namespace AsbCloudInfrastructure.Services.ExcelServices;
public class Cell
{

75
AsbCloudInfrastructure/Services/ExcelServices/ExportExcelService.cs Normal file
View File

@ -0,0 +1,75 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Requests.ExportOptions;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using ClosedXML.Excel;
using Mapster;
namespace AsbCloudInfrastructure.Services.ExcelServices;
public abstract class ExportExcelService<TDto, TOptions> : IExportService<TOptions>
where TOptions : IExportOptionsRequest
{
protected abstract ITemplateParameters TemplateParameters { get; }
protected abstract Task<string> BuildFileNameAsync(TOptions options, CancellationToken token);
protected abstract Task<IEnumerable<TDto>> GetDtosAsync(TOptions options, CancellationToken token);
public async Task<(string FileName, Stream File)> ExportAsync(TOptions options, CancellationToken token)
{
var dtos = await GetDtosAsync(options, token);
var fileName = await BuildFileNameAsync(options, token);
var file = BuildFile(dtos);
return (fileName, file);
}
private Stream BuildFile(IEnumerable<TDto> dtos)
{
using var template = GetTemplateFile();
using var workbook = new XLWorkbook(template);
AddDtosToWorkbook(workbook, dtos);
var memoryStream = new MemoryStream();
workbook.SaveAs(memoryStream, new SaveOptions { });
memoryStream.Seek(0, SeekOrigin.Begin);
return memoryStream;
}
private void AddDtosToWorkbook(XLWorkbook workbook, IEnumerable<TDto> dtos)
{
var dtosToArray = dtos.ToArray();
if (!dtosToArray.Any())
return;
var sheet = workbook.GetWorksheet(TemplateParameters.SheetName);
for (var i = 0; i < dtosToArray.Length; i++)
{
var row = sheet.Row(1 + i + TemplateParameters.HeaderRowsCount);
AddRow(row, dtosToArray[i]);
}
}
private void AddRow(IXLRow xlRow, TDto dto)
{
var properties = dto.Adapt<IDictionary<string, object>>();
foreach (var (name, cellValue) in properties)
{
if (TemplateParameters.Cells.TryGetValue(name, out var cell))
xlRow.Cell(cell.ColumnNumber).SetCellValue(cellValue);
}
}
private Stream GetTemplateFile() =>
Assembly.GetExecutingAssembly().GetTemplateCopyStream(TemplateParameters.FileName)
?? throw new ArgumentNullException($"Файл '{TemplateParameters.FileName}' не найден");
}

36
AsbCloudInfrastructure/Services/Parser/ParserExcelService.cs → AsbCloudInfrastructure/Services/ExcelServices/ParserExcelService.cs
View File

@ -7,39 +7,34 @@ using System.Reflection;
using AsbCloudApp.Data;
using AsbCloudApp.Requests.ParserOptions;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using ClosedXML.Excel;
using Mapster;
namespace AsbCloudInfrastructure.Services.Parser;
namespace AsbCloudInfrastructure.Services.ExcelServices;
public abstract class ParserExcelService<TDto> : IParserService<TDto>
public abstract class ParserExcelService<TDto, TOptions> : IParserService<TDto, TOptions>
where TDto : class, IValidatableObject, IId
where TOptions : IParserOptionsRequest
{
protected abstract string SheetName { get; }
protected abstract ITemplateParameters TemplateParameters { get; }
protected virtual int HeaderRowsCount => 0;
protected abstract string TemplateFileName { get; }
protected abstract IDictionary<string, Cell> Cells { get; }
public virtual ParserResultDto<TDto> Parse<TOptions>(Stream file, TOptions options)
where TOptions : IParserOptionsRequest
public virtual ParserResultDto<TDto> Parse(Stream file, TOptions options)
{
using var workbook = new XLWorkbook(file);
var sheet = workbook.GetWorksheet(SheetName);
var sheet = workbook.GetWorksheet(TemplateParameters.SheetName);
var dtos = ParseExcelSheet(sheet);
return dtos;
}
public virtual Stream GetTemplateFile() =>
Assembly.GetExecutingAssembly().GetTemplateCopyStream(TemplateFileName)
?? throw new ArgumentNullException($"Файл '{TemplateFileName}' не найден");
Assembly.GetExecutingAssembly().GetTemplateCopyStream(TemplateParameters.FileName)
?? throw new ArgumentNullException($"Файл '{TemplateParameters.FileName}' не найден");
protected virtual IDictionary<string, object?> ParseRow(IXLRow xlRow)
{
var cells = Cells.ToDictionary(x => x.Key, x =>
var cells = TemplateParameters.Cells.ToDictionary(x => x.Key, x =>
{
var columnNumber = x.Value.ColumnNumber;
var xlCell = xlRow.Cell(columnNumber);
@ -72,7 +67,7 @@ public abstract class ParserExcelService<TDto> : IParserService<TDto>
return validDto;
}
var columnsDict = Cells.ToDictionary(x => x.Key, x => x.Value.ColumnNumber);
var columnsDict = TemplateParameters.Cells.ToDictionary(x => x.Key, x => x.Value.ColumnNumber);
var invalidDto = new ValidationResultDto<TDto>
{
@ -84,7 +79,10 @@ public abstract class ParserExcelService<TDto> : IParserService<TDto>
{
var columnNumber = columnsDict[m];
var errorMessage = v.ErrorMessage;
var warningMessage = string.Format(XLExtentions.ProblemDetailsTemplate, SheetName, rowNumber, columnNumber,
var warningMessage = string.Format(XLExtentions.ProblemDetailsTemplate,
TemplateParameters.SheetName,
rowNumber,
columnNumber,
errorMessage);
var warning = new ValidationResult(warningMessage, new[] { m });
return warning;
@ -96,7 +94,7 @@ public abstract class ParserExcelService<TDto> : IParserService<TDto>
protected virtual ParserResultDto<TDto> ParseExcelSheet(IXLWorksheet sheet)
{
var count = sheet.RowsUsed().Count() - HeaderRowsCount;
var count = sheet.RowsUsed().Count() - TemplateParameters.HeaderRowsCount;
if (count <= 0)
return new ParserResultDto<TDto>();
@ -105,7 +103,7 @@ public abstract class ParserExcelService<TDto> : IParserService<TDto>
for (var i = 0; i < count; i++)
{
var xlRow = sheet.Row(1 + i + HeaderRowsCount);
var xlRow = sheet.Row(1 + i + TemplateParameters.HeaderRowsCount);
var rowNumber = xlRow.RowNumber();
try

14
AsbCloudInfrastructure/Services/ExcelServices/Templates/ITemplateParameters.cs Normal file
View File

@ -0,0 +1,14 @@
using System.Collections.Generic;
namespace AsbCloudInfrastructure.Services.ExcelServices.Templates;
public interface ITemplateParameters
{
string SheetName { get; }
int HeaderRowsCount { get; }
string FileName { get; }
IDictionary<string, Cell> Cells { get; }
}

35
AsbCloudInfrastructure/Services/ExcelServices/Templates/ProcessMapPlanTemplates/ProcessMapPlanDrillingTemplate.cs Normal file
View File

@ -0,0 +1,35 @@
using System.Collections.Generic;
using AsbCloudApp.Data.ProcessMaps;
namespace AsbCloudInfrastructure.Services.ExcelServices.Templates.ProcessMapPlanTemplates;
public class ProcessMapPlanDrillingTemplate : ITemplateParameters
{
public string SheetName => "План";
public int HeaderRowsCount => 2;
public string FileName => "ProcessMapPlanDrillingTemplate.xlsx";
public IDictionary<string, Cell> Cells => new Dictionary<string, Cell>
{
{ nameof(ProcessMapPlanDrillingDto.Section), new Cell(1, typeof(string)) },
{ nameof(ProcessMapPlanDrillingDto.Mode), new Cell(2, typeof(string)) },
{ nameof(ProcessMapPlanDrillingDto.DepthStart), new Cell(3, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.DepthEnd), new Cell(4, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.DeltaPressurePlan), new Cell(5, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.DeltaPressureLimitMax), new Cell(6, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.AxialLoadPlan), new Cell(7, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.AxialLoadLimitMax), new Cell(8, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.TopDriveTorquePlan), new Cell(9, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.TopDriveTorqueLimitMax), new Cell(10, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.TopDriveSpeedPlan), new Cell(11, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.TopDriveSpeedLimitMax), new Cell(12, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.FlowPlan), new Cell(13, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.FlowLimitMax), new Cell(14, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.RopPlan), new Cell(15, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.UsageSaub), new Cell(16, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.UsageSpin), new Cell(17, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.Comment), new Cell(18, typeof(string)) }
};
}

29
AsbCloudInfrastructure/Services/ExcelServices/Templates/ProcessMapPlanTemplates/ProcessMapPlanReamTemplate.cs Normal file
View File

@ -0,0 +1,29 @@
using System.Collections.Generic;
using AsbCloudApp.Data.ProcessMaps;
namespace AsbCloudInfrastructure.Services.ExcelServices.Templates.ProcessMapPlanTemplates;
public class ProcessMapPlanReamTemplate : ITemplateParameters
{
public string SheetName => "План";
public int HeaderRowsCount => 1;
public string FileName => "ProcessMapPlanReamTemplate.xlsx";
public IDictionary<string, Cell> Cells => new Dictionary<string, Cell>
{
{ nameof(ProcessMapPlanReamDto.Section), new Cell(1, typeof(string)) },
{ nameof(ProcessMapPlanReamDto.DepthStart), new Cell(2, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.DepthEnd), new Cell(3, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.Repeats), new Cell(4, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SpinUpward), new Cell(5, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SpinDownward), new Cell(6, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SpeedUpward), new Cell(7, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SpeedDownward), new Cell(8, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SetpointDrag), new Cell(9, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SetpointTight), new Cell(10, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.Pressure), new Cell(11, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.Torque), new Cell(12, typeof(double)) },
};
}

23
AsbCloudInfrastructure/Services/ExcelServices/Templates/TrajectoryTemplates/TrajectoryFactManualTemplate.cs Normal file
View File

@ -0,0 +1,23 @@
using System.Collections.Generic;
using AsbCloudApp.Data.Trajectory;
namespace AsbCloudInfrastructure.Services.ExcelServices.Templates.TrajectoryTemplates;
public class TrajectoryFactManualTemplate : ITemplateParameters
{
public string SheetName => "Фактическая траектория";
public int HeaderRowsCount => 2;
public string FileName => "TrajectoryFactManualTemplate.xlsx";
public IDictionary<string, Cell> Cells => new Dictionary<string, Cell>
{
{ nameof(TrajectoryGeoFactDto.WellboreDepth), new Cell(1, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.ZenithAngle), new Cell(2, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.AzimuthGeo), new Cell(3, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.AzimuthMagnetic), new Cell(4, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.VerticalDepth), new Cell(5, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.Comment), new Cell(6, typeof(string)) }
};
}

23
AsbCloudInfrastructure/Services/ExcelServices/Templates/TrajectoryTemplates/TrajectoryFactNnbTemplate.cs Normal file
View File

@ -0,0 +1,23 @@
using System.Collections.Generic;
using AsbCloudApp.Data.Trajectory;
namespace AsbCloudInfrastructure.Services.ExcelServices.Templates.TrajectoryTemplates;
public class TrajectoryFactNnbTemplate : ITemplateParameters
{
public string SheetName => "Фактическая ннб-траектория";
public int HeaderRowsCount => 2;
public string FileName => "TrajectoryFactNnbTemplate.xlsx";
public IDictionary<string, Cell> Cells => new Dictionary<string, Cell>
{
{ nameof(TrajectoryGeoFactDto.WellboreDepth), new Cell(1, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.ZenithAngle), new Cell(2, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.AzimuthGeo), new Cell(3, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.AzimuthMagnetic), new Cell(4, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.VerticalDepth), new Cell(5, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.Comment), new Cell(6, typeof(string)) }
};
}

21
AsbCloudInfrastructure/Services/ExcelServices/Templates/TrajectoryTemplates/TrajectoryPlanTemplate.cs Normal file
View File

@ -0,0 +1,21 @@
using System.Collections.Generic;
using AsbCloudApp.Data.Trajectory;
namespace AsbCloudInfrastructure.Services.ExcelServices.Templates.TrajectoryTemplates;
public class TrajectoryPlanTemplate : ITemplateParameters
{
public string SheetName => "Плановая траектория";
public int HeaderRowsCount => 2;
public string FileName => "TrajectoryPlanTemplate.xlsx";
public IDictionary<string, Cell> Cells => new Dictionary<string, Cell>
{
{ nameof(TrajectoryGeoPlanDto.WellboreDepth), new Cell(1, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.ZenithAngle), new Cell(2, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.AzimuthGeo), new Cell(3, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.AzimuthMagnetic), new Cell(4, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.VerticalDepth), new Cell(5, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.Radius), new Cell(6, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.Comment), new Cell(7, typeof(string)) }
};
}

52
AsbCloudInfrastructure/Services/ProcessMapPlan/Export/ProcessMapPlanDrillingExportService.cs Normal file
View File

@ -0,0 +1,52 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data.ProcessMaps;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Requests.ExportOptions;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using AsbCloudInfrastructure.Services.ExcelServices.Templates.ProcessMapPlanTemplates;
namespace AsbCloudInfrastructure.Services.ProcessMapPlan.Export;
public class ProcessMapPlanDrillingExportService : ProcessMapPlanExportService<ProcessMapPlanDrillingDto>
{
public ProcessMapPlanDrillingExportService(
IChangeLogRepository<ProcessMapPlanDrillingDto, ProcessMapPlanBaseRequestWithWell> processMapPlanRepository,
IWellService wellService)
: base(processMapPlanRepository, wellService)
{
}
protected override ITemplateParameters TemplateParameters => new ProcessMapPlanDrillingTemplate();
protected override async Task<string> BuildFileNameAsync(WellRelatedExportRequest options, CancellationToken token)
{
var caption = await wellService.GetWellCaptionByIdAsync(options.IdWell, token);
return $"{caption}_РТК_План_бурение.xlsx";
}
protected override async Task<IEnumerable<ProcessMapPlanDrillingDto>> GetDtosAsync(WellRelatedExportRequest options,
CancellationToken token)
{
var dtos = await base.GetDtosAsync(options, token);
var dtosWithMode = dtos.Select(dto =>
{
dto.Mode = dto.IdMode switch
{
1 => "Ротор",
2 => "Слайд",
_ => throw new ArgumentOutOfRangeException()
};
return dto;
});
return dtosWithMode;
}
}

33
AsbCloudInfrastructure/Services/ProcessMapPlan/Export/ProcessMapPlanExportService.cs Normal file
View File

@ -0,0 +1,33 @@
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Requests.ExportOptions;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services.ExcelServices;
namespace AsbCloudInfrastructure.Services.ProcessMapPlan.Export;
public abstract class ProcessMapPlanExportService<TDto> : ExportExcelService<TDto, WellRelatedExportRequest>
where TDto : ChangeLogAbstract
{
protected readonly IWellService wellService;
private readonly IChangeLogRepository<TDto, ProcessMapPlanBaseRequestWithWell> processMapPlanRepository;
protected ProcessMapPlanExportService(IChangeLogRepository<TDto, ProcessMapPlanBaseRequestWithWell> processMapPlanRepository,
IWellService wellService)
{
this.processMapPlanRepository = processMapPlanRepository;
this.wellService = wellService;
}
protected override async Task<IEnumerable<TDto>> GetDtosAsync(WellRelatedExportRequest options, CancellationToken token)
{
var request = new ProcessMapPlanBaseRequestWithWell(options.IdWell);
var dtos = await processMapPlanRepository.Get(request, token);
return dtos;
}
}

30
AsbCloudInfrastructure/Services/ProcessMapPlan/Export/ProcessMapPlanReamExportService.cs Normal file
View File

@ -0,0 +1,30 @@
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data.ProcessMaps;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Requests.ExportOptions;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using AsbCloudInfrastructure.Services.ExcelServices.Templates.ProcessMapPlanTemplates;
namespace AsbCloudInfrastructure.Services.ProcessMapPlan.Export;
public class ProcessMapPlanReamExportService : ProcessMapPlanExportService<ProcessMapPlanReamDto>
{
protected override ITemplateParameters TemplateParameters => new ProcessMapPlanReamTemplate();
public ProcessMapPlanReamExportService(
IChangeLogRepository<ProcessMapPlanReamDto, ProcessMapPlanBaseRequestWithWell> processMapPlanRepository,
IWellService wellService)
: base(processMapPlanRepository, wellService)
{
}
protected override async Task<string> BuildFileNameAsync(WellRelatedExportRequest options, CancellationToken token)
{
var caption = await wellService.GetWellCaptionByIdAsync(options.IdWell, token);
return $"{caption}_РТК_План_проработка.xlsx";
}
}

47
AsbCloudInfrastructure/Services/ProcessMapPlan/Parser/ProcessMapPlanDrillingParser.cs
View File

@ -2,50 +2,21 @@ using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using AsbCloudApp.Data;
using AsbCloudApp.Data.ProcessMaps;
using AsbCloudApp.Repositories;
using AsbCloudInfrastructure.Services.Parser;
using Microsoft.Extensions.DependencyInjection;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using AsbCloudInfrastructure.Services.ExcelServices.Templates.ProcessMapPlanTemplates;
namespace AsbCloudInfrastructure.Services.ProcessMapPlan.Parser;
public class ProcessMapPlanDrillingParser : ProcessMapPlanParser<ProcessMapPlanDrillingDto>
{
private readonly IEnumerable<WellSectionTypeDto> sections;
public ProcessMapPlanDrillingParser(IWellOperationRepository wellOperationRepository)
: base(wellOperationRepository)
{
sections = wellOperationRepository.GetSectionTypes();
}
protected override string SheetName => "План";
protected override string TemplateFileName => "ProcessMapPlanDrillingTemplate.xlsx";
private const int ColumnSection = 1;
private const int ColumnMode = 2;
protected override IDictionary<string, Cell> Cells => new Dictionary<string, Cell>
{
{ nameof(ProcessMapPlanDrillingDto.Section), new Cell(ColumnSection, typeof(string)) },
{ nameof(ProcessMapPlanDrillingDto.Mode), new Cell(ColumnMode, typeof(string)) },
{ nameof(ProcessMapPlanDrillingDto.DepthStart), new Cell(3, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.DepthEnd), new Cell(4, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.DeltaPressurePlan), new Cell(5, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.DeltaPressureLimitMax), new Cell(6, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.AxialLoadPlan), new Cell(7, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.AxialLoadLimitMax), new Cell(8, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.TopDriveTorquePlan), new Cell(9, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.TopDriveTorqueLimitMax), new Cell(10, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.TopDriveSpeedPlan), new Cell(11, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.TopDriveSpeedLimitMax), new Cell(12, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.FlowPlan), new Cell(13, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.FlowLimitMax), new Cell(14, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.RopPlan), new Cell(15, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.UsageSaub), new Cell(16, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.UsageSpin), new Cell(17, typeof(double)) },
{ nameof(ProcessMapPlanDrillingDto.Comment), new Cell(18, typeof(string)) }
};
protected override ITemplateParameters TemplateParameters => new ProcessMapPlanDrillingTemplate();
protected override ProcessMapPlanDrillingDto BuildDto(IDictionary<string, object?> row, int rowNumber)
{
@ -56,7 +27,10 @@ public class ProcessMapPlanDrillingParser : ProcessMapPlanParser<ProcessMapPlanD
if (section is null)
{
var message = string.Format(XLExtentions.ProblemDetailsTemplate, SheetName, rowNumber, ColumnSection,
var message = string.Format(XLExtentions.ProblemDetailsTemplate,
TemplateParameters.SheetName,
rowNumber,
TemplateParameters.Cells[nameof(ProcessMapPlanDrillingDto.Section)],
"Указана некорректная секция");
throw new FileFormatException(message);
}
@ -65,7 +39,10 @@ public class ProcessMapPlanDrillingParser : ProcessMapPlanParser<ProcessMapPlanD
if (idMode is null)
{
var message = string.Format(XLExtentions.ProblemDetailsTemplate, SheetName, rowNumber, ColumnSection,
var message = string.Format(XLExtentions.ProblemDetailsTemplate,
TemplateParameters.SheetName,
rowNumber,
TemplateParameters.Cells[nameof(ProcessMapPlanDrillingDto.Mode)],
"Указан некорректный режим бурения");
throw new FileFormatException(message);
}

27
AsbCloudInfrastructure/Services/ProcessMapPlan/Parser/ProcessMapPlanParser.cs
View File

@ -1,13 +1,32 @@
using System;
using System.Collections.Generic;
using System.IO;
using AsbCloudApp.Data;
using AsbCloudApp.Data.ProcessMaps;
using AsbCloudInfrastructure.Services.Parser;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests.ParserOptions;
using AsbCloudInfrastructure.Services.ExcelServices;
namespace AsbCloudInfrastructure.Services.ProcessMapPlan.Parser;
public abstract class ProcessMapPlanParser<TDto> : ParserExcelService<TDto>
public abstract class ProcessMapPlanParser<TDto> : ParserExcelService<TDto, WellRelatedParserRequest>
where TDto : ProcessMapPlanBaseDto
{
protected override int HeaderRowsCount => 2;
protected readonly IEnumerable<WellSectionTypeDto> sections;
protected ProcessMapPlanParser(IWellOperationRepository wellOperationRepository)
{
sections = wellOperationRepository.GetSectionTypes();
}
public override ParserResultDto<TDto> Parse(Stream file, WellRelatedParserRequest options)
{
var result = base.Parse(file, options);
foreach (var item in result.Item)
item.Item.IdWell = options.IdWell;
return result;
}
protected static int? GetIdMode(string? modeName) =>
modeName?.Trim().ToLower() switch

35
AsbCloudInfrastructure/Services/ProcessMapPlan/Parser/ProcessMapPlanReamParser.cs
View File

@ -2,44 +2,21 @@ using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using AsbCloudApp.Data;
using AsbCloudApp.Data.ProcessMaps;
using AsbCloudApp.Repositories;
using AsbCloudInfrastructure.Services.Parser;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using AsbCloudInfrastructure.Services.ExcelServices.Templates.ProcessMapPlanTemplates;
namespace AsbCloudInfrastructure.Services.ProcessMapPlan.Parser;
public class ProcessMapPlanReamParser : ProcessMapPlanParser<ProcessMapPlanReamDto>
{
private readonly IEnumerable<WellSectionTypeDto> sections;
public ProcessMapPlanReamParser(IWellOperationRepository wellOperationRepository)
: base(wellOperationRepository)
{
sections = wellOperationRepository.GetSectionTypes();
}
protected override string SheetName => "План";
protected override string TemplateFileName => "ProcessMapPlanReamTemplate.xlsx";
private const int ColumnSection = 1;
private const int ColumnMode = 2;
protected override IDictionary<string, Cell> Cells => new Dictionary<string, Cell>
{
{ nameof(ProcessMapPlanReamDto.Section), new Cell(ColumnSection, typeof(string)) },
{ nameof(ProcessMapPlanReamDto.DepthStart), new Cell(2, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.DepthEnd), new Cell(3, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.Repeats), new Cell(4, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SpinUpward), new Cell(5, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SpinUpward), new Cell(6, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SpeedDownward), new Cell(7, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SpeedUpward), new Cell(8, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SetpointDrag), new Cell(9, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.SetpointTight), new Cell(10, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.Pressure), new Cell(11, typeof(double)) },
{ nameof(ProcessMapPlanReamDto.Torque), new Cell(12, typeof(double)) },
};
protected override ITemplateParameters TemplateParameters => new ProcessMapPlanReamTemplate();
protected override ProcessMapPlanReamDto BuildDto(IDictionary<string, object?> row, int rowNumber)
{
@ -50,7 +27,9 @@ public class ProcessMapPlanReamParser : ProcessMapPlanParser<ProcessMapPlanReamD
if (section is null)
{
var message = string.Format(XLExtentions.ProblemDetailsTemplate, SheetName, rowNumber, ColumnSection,
var message = string.Format(XLExtentions.ProblemDetailsTemplate,
TemplateParameters.SheetName, rowNumber,
TemplateParameters.Cells[nameof(ProcessMapPlanReamDto.Section)],
"Указана некорректная секция");
throw new FileFormatException(message);
}

92
AsbCloudInfrastructure/Services/Trajectory/Export/TrajectoryExportService.cs
View File

@ -1,83 +1,27 @@
using AsbCloudApp.Data.Trajectory;
using System.Collections.Generic;
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Repositories;
using AsbCloudApp.Services;
using ClosedXML.Excel;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Requests.ExportOptions;
using AsbCloudInfrastructure.Services.ExcelServices;
namespace AsbCloudInfrastructure.Services.Trajectory.Export
namespace AsbCloudInfrastructure.Services.Trajectory.Export;
public abstract class TrajectoryExportService<TDto> : ExportExcelService<TDto, WellRelatedExportRequest>
where TDto : TrajectoryGeoDto
{
public abstract class TrajectoryExportService<T> where T : TrajectoryGeoDto
{
private readonly IWellService wellService;
protected readonly IWellService wellService;
private readonly ITrajectoryRepository<T> trajectoryRepository;
public abstract string templateFileName { get; }
public abstract string usingTemplateFile { get; }
public abstract string sheetName { get; }
public abstract int headerRowsCount { get; }
private readonly ITrajectoryRepository<TDto> trajectoryRepository;
public TrajectoryExportService(IWellService wellService, ITrajectoryRepository<T> trajectoryRepository)
{
this.wellService = wellService;
this.trajectoryRepository = trajectoryRepository;
}
protected TrajectoryExportService(IWellService wellService, ITrajectoryRepository<TDto> trajectoryRepository)
{
this.wellService = wellService;
this.trajectoryRepository = trajectoryRepository;
}
protected abstract void AddCoordinatesToRow(IXLRow row, T trajectory);
public async Task<Stream> ExportAsync(int idWell, CancellationToken token)
{
var trajectorys = await trajectoryRepository.GetAsync(idWell, token);
return MakeExelFileStream(trajectorys);
}
public async Task<string> GetFileNameAsync(int idWell, CancellationToken token)
{
var caption = await wellService.GetWellCaptionByIdAsync(idWell, token);
return string.Format("{0}_{1}", caption, templateFileName);
}
public Stream GetTemplateFile()
{
var stream = System.Reflection.Assembly.GetExecutingAssembly()
.GetManifestResourceStream($"{usingTemplateFile}.{templateFileName}");
if (stream is null)
throw new Exception($"Область {usingTemplateFile} не содержит файла с названием {templateFileName}");
return stream;
}
private Stream MakeExelFileStream(IEnumerable<T> trajectories)
{
using Stream ecxelTemplateStream = GetTemplateFile();
using var workbook = new XLWorkbook(ecxelTemplateStream);
AddTrajecoryToWorkbook(workbook, trajectories);
MemoryStream memoryStream = new MemoryStream();
workbook.SaveAs(memoryStream, new SaveOptions { });
memoryStream.Seek(0, SeekOrigin.Begin);
return memoryStream;
}
private void AddTrajecoryToWorkbook(XLWorkbook workbook, IEnumerable<T> trajectories)
{
if (trajectories.Any())
{
var sheet = workbook.GetWorksheet(sheetName);
AddTrajecoryToSheet(sheet, trajectories);
}
}
private void AddTrajecoryToSheet(IXLWorksheet sheet, IEnumerable<T> trajectories)
{
var rowList = trajectories.ToList();
for (int i = 0; i < rowList.Count; i++)
{
var row = sheet.Row(1 + i + headerRowsCount);
AddCoordinatesToRow(row, rowList[i]);
}
}
}
}
protected override Task<IEnumerable<TDto>> GetDtosAsync(WellRelatedExportRequest options, CancellationToken token) =>
trajectoryRepository.GetAsync(options.IdWell, token);
}

51
AsbCloudInfrastructure/Services/Trajectory/Export/TrajectoryFactManualExportService.cs
View File

@ -1,35 +1,28 @@
using AsbCloudApp.Data.Trajectory;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests.ExportOptions;
using AsbCloudApp.Services;
using ClosedXML.Excel;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using AsbCloudInfrastructure.Services.ExcelServices.Templates.TrajectoryTemplates;
namespace AsbCloudInfrastructure.Services.Trajectory.Export
namespace AsbCloudInfrastructure.Services.Trajectory.Export;
public class TrajectoryFactManualExportService : TrajectoryExportService<TrajectoryGeoFactDto>
{
public TrajectoryFactManualExportService(IWellService wellService,
ITrajectoryEditableRepository<TrajectoryGeoFactDto> trajectoryRepository)
: base(wellService, trajectoryRepository)
{
}
public class TrajectoryFactManualExportService : TrajectoryExportService<TrajectoryGeoFactDto>
{
public override string templateFileName { get; } = "TrajectoryFactManualTemplate.xlsx";
public override string usingTemplateFile { get; } = "AsbCloudInfrastructure.Services.Trajectory.Templates";
public override string sheetName { get; } = "Фактическая траектория";
public override int headerRowsCount { get; } = 2;
public TrajectoryFactManualExportService(
IWellService wellService,
ITrajectoryEditableRepository<TrajectoryGeoFactDto> factTrajectoryService)
: base(wellService, factTrajectoryService)
{
}
protected override void AddCoordinatesToRow(IXLRow row, TrajectoryGeoFactDto trajectory)
{
row.Cell(1).SetCellValue(trajectory.WellboreDepth);
row.Cell(2).SetCellValue(trajectory.ZenithAngle);
row.Cell(3).SetCellValue(trajectory.AzimuthGeo);
row.Cell(4).SetCellValue(trajectory.AzimuthMagnetic);
row.Cell(5).SetCellValue(trajectory.VerticalDepth);
row.Cell(6).SetCellValue(trajectory.Comment);
}
}
}
protected override ITemplateParameters TemplateParameters => new TrajectoryFactManualTemplate();
protected override async Task<string> BuildFileNameAsync(WellRelatedExportRequest options, CancellationToken token)
{
var caption = await wellService.GetWellCaptionByIdAsync(options.IdWell, token);
return $"{caption}_Фактическая_траектория.xlsx";
}
}

49
AsbCloudInfrastructure/Services/Trajectory/Export/TrajectoryFactNnbExportService.cs
View File

@ -1,35 +1,28 @@
using AsbCloudApp.Data.Trajectory;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests.ExportOptions;
using AsbCloudApp.Services;
using ClosedXML.Excel;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using AsbCloudInfrastructure.Services.ExcelServices.Templates.TrajectoryTemplates;
namespace AsbCloudInfrastructure.Services.Trajectory.Export
namespace AsbCloudInfrastructure.Services.Trajectory.Export;
public class TrajectoryFactNnbExportService : TrajectoryExportService<TrajectoryGeoFactDto>
{
public TrajectoryFactNnbExportService(IWellService wellService,
ITrajectoryNnbRepository trajectoryRepository)
: base(wellService, trajectoryRepository)
{
}
public class TrajectoryFactNnbExportService : TrajectoryExportService<TrajectoryGeoFactDto>
{
public override string templateFileName { get; } = "TrajectoryFactNnbTemplate.xlsx";
public override string usingTemplateFile { get; } = "AsbCloudInfrastructure.Services.Trajectory.Templates";
public override string sheetName { get; } = "Фактическая ннб-траектория";
public override int headerRowsCount { get; } = 2;
protected override ITemplateParameters TemplateParameters => new TrajectoryFactNnbTemplate();
public TrajectoryFactNnbExportService(
IWellService wellService,
ITrajectoryNnbRepository nnbTrajectoryService)
: base(wellService, nnbTrajectoryService)
{
}
protected override void AddCoordinatesToRow(IXLRow row, TrajectoryGeoFactDto trajectory)
{
row.Cell(1).SetCellValue(trajectory.WellboreDepth);
row.Cell(2).SetCellValue(trajectory.ZenithAngle);
row.Cell(3).SetCellValue(trajectory.AzimuthGeo);
row.Cell(4).SetCellValue(trajectory.AzimuthMagnetic);
row.Cell(5).SetCellValue(trajectory.VerticalDepth);
row.Cell(6).SetCellValue(trajectory.Comment);
}
}
}
protected override async Task<string> BuildFileNameAsync(WellRelatedExportRequest options, CancellationToken token)
{
var caption = await wellService.GetWellCaptionByIdAsync(options.IdWell, token);
return $"{caption}_Траектория_ННБ.xlsx";
}
}

52
AsbCloudInfrastructure/Services/Trajectory/Export/TrajectoryPlanExportService.cs
View File

@ -1,38 +1,28 @@
using AsbCloudApp.Data.Trajectory;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests.ExportOptions;
using AsbCloudApp.Services;
using ClosedXML.Excel;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using AsbCloudInfrastructure.Services.ExcelServices.Templates.TrajectoryTemplates;
namespace AsbCloudInfrastructure.Services.Trajectory.Export
namespace AsbCloudInfrastructure.Services.Trajectory.Export;
public class TrajectoryPlanExportService : TrajectoryExportService<TrajectoryGeoPlanDto>
{
public class TrajectoryPlanExportService : TrajectoryExportService<TrajectoryGeoPlanDto>
{
/*
* password for PlannedTrajectoryTemplate.xlsx is Drill2022
*/
public override string templateFileName { get; } = "TrajectoryPlanTemplate.xlsx";
public override string usingTemplateFile { get; } = "AsbCloudInfrastructure.Services.Trajectory.Templates";
public override string sheetName { get; } = "Плановая траектория";
public override int headerRowsCount { get; } = 2;
public TrajectoryPlanExportService(IWellService wellService,
ITrajectoryEditableRepository<TrajectoryGeoPlanDto> trajectoryRepository)
: base(wellService, trajectoryRepository)
{
}
public TrajectoryPlanExportService(
IWellService wellService,
ITrajectoryEditableRepository<TrajectoryGeoPlanDto> trajectoryPlanService)
: base(wellService, trajectoryPlanService)
{
}
protected override ITemplateParameters TemplateParameters => new TrajectoryPlanTemplate();
protected override void AddCoordinatesToRow(IXLRow row, TrajectoryGeoPlanDto trajectory)
{
row.Cell(1).SetCellValue(trajectory.WellboreDepth);
row.Cell(2).SetCellValue(trajectory.ZenithAngle);
row.Cell(3).SetCellValue(trajectory.AzimuthGeo);
row.Cell(4).SetCellValue(trajectory.AzimuthMagnetic);
row.Cell(5).SetCellValue(trajectory.VerticalDepth);
row.Cell(6).SetCellValue(trajectory.Radius);
row.Cell(7).SetCellValue(trajectory.Comment);
}
}
}
protected override async Task<string> BuildFileNameAsync(WellRelatedExportRequest options, CancellationToken token)
{
var caption = await wellService.GetWellCaptionByIdAsync(options.IdWell, token);
return $"{caption}_Плановая_Траектория.xlsx";
}
}

24
AsbCloudInfrastructure/Services/Trajectory/Parser/TrajectoryFactManualParser.cs
View File

@ -1,24 +1,10 @@
using System.Collections.Generic;
using AsbCloudApp.Data.Trajectory;
using AsbCloudInfrastructure.Services.Parser;
using AsbCloudApp.Data.Trajectory;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using AsbCloudInfrastructure.Services.ExcelServices.Templates.TrajectoryTemplates;
namespace AsbCloudInfrastructure.Services.Trajectory.Parser;
public class TrajectoryFactManualParser : ParserExcelService<TrajectoryGeoFactDto>
public class TrajectoryFactManualParser : TrajectoryParser<TrajectoryGeoFactDto>
{
protected override string SheetName => "Фактическая траектория";
protected override int HeaderRowsCount => 2;
protected override string TemplateFileName => "TrajectoryFactManualTemplate.xlsx";
protected override IDictionary<string, Cell> Cells => new Dictionary<string, Cell>
{
{ nameof(TrajectoryGeoFactDto.WellboreDepth), new Cell(1, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.ZenithAngle), new Cell(2, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.AzimuthGeo), new Cell(3, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.AzimuthMagnetic), new Cell(4, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.VerticalDepth), new Cell(5, typeof(double)) },
{ nameof(TrajectoryGeoFactDto.Comment), new Cell(6, typeof(string)) }
};
protected override ITemplateParameters TemplateParameters => new TrajectoryFactManualTemplate();
}

21
AsbCloudInfrastructure/Services/Trajectory/Parser/TrajectoryParser.cs Normal file
View File

@ -0,0 +1,21 @@
using System.IO;
using AsbCloudApp.Data;
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Requests.ParserOptions;
using AsbCloudInfrastructure.Services.ExcelServices;
namespace AsbCloudInfrastructure.Services.Trajectory.Parser;
public abstract class TrajectoryParser<TDto> : ParserExcelService<TDto, WellRelatedParserRequest>
where TDto : TrajectoryGeoDto
{
public override ParserResultDto<TDto> Parse(Stream file, WellRelatedParserRequest options)
{
var result = base.Parse(file, options);
foreach (var item in result.Item)
item.Item.IdWell = options.IdWell;
return result;
}
}

25
AsbCloudInfrastructure/Services/Trajectory/Parser/TrajectoryPlanParser.cs
View File

@ -1,25 +1,10 @@
using System.Collections.Generic;
using AsbCloudApp.Data.Trajectory;
using AsbCloudInfrastructure.Services.Parser;
using AsbCloudApp.Data.Trajectory;
using AsbCloudInfrastructure.Services.ExcelServices.Templates;
using AsbCloudInfrastructure.Services.ExcelServices.Templates.TrajectoryTemplates;
namespace AsbCloudInfrastructure.Services.Trajectory.Parser;
public class TrajectoryPlanParser : ParserExcelService<TrajectoryGeoPlanDto>
public class TrajectoryPlanParser : TrajectoryParser<TrajectoryGeoPlanDto>
{
protected override string SheetName => "Плановая траектория";
protected override int HeaderRowsCount => 2;
protected override string TemplateFileName => "TrajectoryPlanTemplate.xlsx";
protected override IDictionary<string, Cell> Cells => new Dictionary<string, Cell>
{
{ nameof(TrajectoryGeoPlanDto.WellboreDepth), new Cell(1, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.ZenithAngle), new Cell(2, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.AzimuthGeo), new Cell(3, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.AzimuthMagnetic), new Cell(4, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.VerticalDepth), new Cell(5, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.Radius), new Cell(6, typeof(double)) },
{ nameof(TrajectoryGeoPlanDto.Comment), new Cell(7, typeof(string)) }
};
protected override ITemplateParameters TemplateParameters => new TrajectoryPlanTemplate();
}

220
AsbCloudInfrastructure/Services/WellCompositeOperationService.cs Normal file
View File

@ -0,0 +1,220 @@
using AsbCloudApp.Data;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace AsbCloudInfrastructure.Services
{
public class WellCompositeOperationService : IWellCompositeOperationService
{
private ICrudRepository<WellSectionTypeDto> wellSectionTypeRepository;
private IWellOperationCategoryRepository wellOperationCategoryRepository;
private IWellOperationRepository wellOperationRepository;
/// <summary>
/// Тип секции "Транспортный стол"
/// </summary>
private const int wellSectionTransportTable = 5;
/// <summary>
/// Тип секции "Эксплуатационная колонна"
/// </summary>
private const int wellSectionProductionString = 4;
/// <summary>
/// набор настроек для замены одной категории секции на другую
/// </summary>
private static Dictionary<(int, int), int> SettingsForSectionCategoryChange = new Dictionary<(int, int), int>() {
{ (2, 5096), 5013 },
{ (2, 5008), 5013 },
{ (3, 5096), 5084 },
{ (3, 5008), 5084 },
{ (3, 5085), 5015 },
{ (3, 5014), 5015 },
{ (31, 5014), 5015 },
{ (31, 5012), 5013 },
{ (31, 5083), 5013 },
{ (4, 5085), 5015 },
{ (4, 5087), 5015 },
{ (4, 5014), 5015 },
{ (4, 5053), 5037 },
{ (4, 5084), 5096 },
{ (4, 5086), 5013 },
{ (6, 5085), 5015 },
{ (6, 5036), 5034 },
{ (6, 5035), 5097 }
};
private HashSet<(int IdSectionType, int IdCategory)> WellSectionTypesWithCategories = new HashSet<(int IdSectionType, int IdCategory)>()
{
{ (2, 5001) },
{ (2, 5003) },
{ (2, 5013) },
{ (2, 5000) },
{ (2, 5022) },
{ (2, 5017) },
{ (2, 5023) },
{ (2, 4007) },
{ (2, 5090) },
{ (3, 5001) },
{ (3, 5015) },
{ (3, 5037) },
{ (3, 5057) },
{ (3, 5003) },
{ (3, 5036) },
{ (3, 5084) },
{ (3, 5013) },
{ (3, 5000) },
{ (3, 5022) },
{ (3, 5017) },
{ (3, 4007) },
{ (3, 5090) },
{ (3, 5045) },
{ (3, 5042) },
{ (3, 5046) },
{ (31, 5001) },
{ (31, 5015) },
{ (31, 5037) },
{ (31, 5057) },
{ (31, 5003) },
{ (31, 5036) },
{ (31, 5013) },
{ (31, 5022) },
{ (31, 5017) },
{ (31, 5023) },
{ (31, 4007) },
{ (31, 5045) },
{ (31, 5042) },
{ (31, 5046) },
{ (4, 5001) },
{ (4, 5015) },
{ (4, 5046) },
{ (4, 5037) },
{ (4, 5097) },
{ (4, 5057) },
{ (4, 5003) },
{ (4, 5036) },
{ (4, 5008) },
{ (4, 5003) },
{ (4, 5036) },
{ (4, 5013) },
{ (4, 5000) },
{ (4, 5029) },
{ (4, 5022) },
{ (4, 5017) },
{ (4, 5019) },
{ (4, 5042) },
{ (4, 5046) },
{ (6, 5001) },
{ (6, 5015) },
{ (6, 5034) },
{ (6, 5037) },
{ (6, 5097) },
{ (6, 5057) },
{ (6, 5003) }
};
public WellCompositeOperationService(
ICrudRepository<WellSectionTypeDto> wellSectionTypeRepository,
IWellOperationCategoryRepository wellOperationCategoryRepository,
IWellOperationRepository wellOperationRepository)
{
this.wellSectionTypeRepository = wellSectionTypeRepository;
this.wellOperationCategoryRepository = wellOperationCategoryRepository;
this.wellOperationRepository = wellOperationRepository;
}
public async Task<List<Dictionary<int, WellOperationDataDto>>> GetAsync(IEnumerable<int> idsWells, CancellationToken token)
{
var sections = await wellSectionTypeRepository.GetAllAsync(token);
var sectionsDict = sections.ToDictionary(s => s.Id, s => s.Caption);
var categories = wellOperationCategoryRepository.Get(true);
var categoriesDict = categories.ToDictionary(s => s.Id, s => s.Name);
var idsWellSectionTypes = WellSectionTypesWithCategories.Select(t => t.IdSectionType).Distinct();
var usedCategories = WellSectionTypesWithCategories.Select(c => c.IdCategory).Distinct();
var wellOperationRequest = new WellsOperationRequest()
{
IdsWell = idsWells,
OperationCategoryIds = usedCategories,
SectionTypeIds = idsWellSectionTypes,
OperationType = WellOperation.IdOperationTypeFact
};
var operations = await wellOperationRepository.GetAsync(wellOperationRequest, token);
var renamedOperations = operations.Select(o => UpdateIdWellSectionAndIdCategory(o, sectionsDict, categoriesDict));
var wellOperationsWithComposite = new List<Dictionary<int, WellOperationDataDto>>();
var compositeDepth = 0d;
foreach ((int IdSection, int IdCategory) in WellSectionTypesWithCategories)
{
var filteredByTemplate = renamedOperations
.Where(o => o.IdWellSectionType == IdSection)
.Where(o => o.IdCategory == IdCategory);
if (!filteredByTemplate.Any())
continue;
var groupedByWell = filteredByTemplate.GroupBy(o => o.IdWell);
var aggreagtedByWell = groupedByWell.Select(g => new WellOperationDataDto
{
IdCategory = IdCategory,
IdWell = g.Key,
IdWellSectionType = IdSection,
DepthStart = g.Min(o => o.DepthStart),
DurationHours = g.Sum(o => o.DurationHours),
OperationCategoryName = g.First().OperationCategoryName,
WellSectionTypeCaption = g.First().WellSectionTypeCaption,
});
var composite = aggreagtedByWell.OrderBy(o => o.DurationHours).
ThenByDescending(o => o.DepthStart)
.First();
composite.IdWell = 0;
if (compositeDepth > composite.DepthStart)
composite.DepthStart = compositeDepth;
compositeDepth = composite.DepthStart;
var resultItem = aggreagtedByWell.ToDictionary(o => o.IdWell);
resultItem.Add(0, composite);
wellOperationsWithComposite.Add(resultItem);
}
return wellOperationsWithComposite;
}
private static WellOperationDataDto UpdateIdWellSectionAndIdCategory(
WellOperationDataDto dto,
Dictionary<int, string> sectionTypes,
Dictionary<int, string> operationCategories)
{
if (dto.IdWellSectionType == wellSectionTransportTable)
{
dto.IdWellSectionType = wellSectionProductionString;
dto.WellSectionTypeCaption = sectionTypes[dto.IdWellSectionType] ?? string.Empty;
}
if ((SettingsForSectionCategoryChange.TryGetValue((dto.IdWellSectionType, dto.IdCategory), out int newIdCategory)))
{
dto.IdCategory = newIdCategory;
dto.OperationCategoryName = operationCategories[dto.IdCategory] ?? string.Empty;
}
return dto;
}
}
}

16
AsbCloudWebApi.IntegrationTests/BaseIntegrationTest.cs
View File

@ -4,15 +4,23 @@ using Xunit;
namespace AsbCloudWebApi.IntegrationTests;
public abstract class BaseIntegrationTest : IClassFixture<WebAppFactoryFixture>
public abstract class BaseIntegrationTest : IClassFixture<WebAppFactoryFixture>,
IDisposable
{
protected readonly IServiceScope scope;
protected readonly IAsbCloudDbContext dbContext;
protected readonly AsbCloudDbContext dbContext;
protected BaseIntegrationTest(WebAppFactoryFixture factory)
{
scope = factory.Services.CreateScope();
dbContext = scope.ServiceProvider.GetRequiredService<IAsbCloudDbContext>();
dbContext = scope.ServiceProvider.GetRequiredService<AsbCloudDbContext>();
}
public void Dispose()
{
scope.Dispose();
dbContext.Dispose();
}
}

2
AsbCloudWebApi.IntegrationTests/Clients/IProcessMapPlanDrillingClient.cs
View File

@ -35,5 +35,5 @@ public interface IProcessMapPlanDrillingClient
[Multipart]
[Post(BaseRoute + "/parse")]
Task<IApiResponse<ParserResultDto<ProcessMapPlanDrillingDto>>> Parse(int idWell, [AliasAs("files")] IEnumerable<StreamPart> streams);
Task<IApiResponse<ParserResultDto<ProcessMapPlanDrillingDto>>> Parse(int idWell, [AliasAs("file")] StreamPart stream);
}

20
AsbCloudWebApi.IntegrationTests/Controllers/AdminDepositControllerTest.cs
View File

@ -1,6 +1,5 @@
using System.Net;
using AsbCloudApp.Data;
using AsbCloudDb.Model;
using AsbCloudWebApi.IntegrationTests.Clients;
using Mapster;
using Microsoft.EntityFrameworkCore;
@ -27,8 +26,6 @@ public class AdminDepositControllerTest : BaseIntegrationTest
: base(factory)
{
client = factory.GetAuthorizedHttpClient<IAdminDepositClient>(string.Empty);
dbContext.CleanupDbSet<Deposit>();
}
[Fact]
@ -130,11 +127,8 @@ public class AdminDepositControllerTest : BaseIntegrationTest
[Fact]
public async Task GetOrDefault_returns_NoContent_for_IdDeposit()
{
//arrange
const int idInvalid = 0;
//act
var responce = await client.GetOrDefaultAsync(idInvalid);
var responce = await client.GetOrDefaultAsync(0);
//assert
Assert.Equal(HttpStatusCode.NoContent, responce.StatusCode);
@ -143,9 +137,6 @@ public class AdminDepositControllerTest : BaseIntegrationTest
[Fact]
public async Task GetAll_returns_success()
{
//arrange
await client.InsertAsync(dto);
//act
var response = await client.GetAllAsync();
@ -155,10 +146,6 @@ public class AdminDepositControllerTest : BaseIntegrationTest
var expectedCount = await dbContext.Deposits.CountAsync();
Assert.Equal(expectedCount, response.Content.Count());
var deposit = response.Content.First();
var excludeProps = new[] { nameof(DepositBaseDto.Id) };
MatchHelper.Match(dto, deposit, excludeProps);
}
[Fact]
@ -182,11 +169,8 @@ public class AdminDepositControllerTest : BaseIntegrationTest
[Fact]
public async Task Delete_returns_NoContent_IdDeposit()
{
//arrange
const int idInvalid = 0;
//act
var response = await client.DeleteAsync(idInvalid);
var response = await client.DeleteAsync(0);
//assert
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);

43
AsbCloudWebApi.IntegrationTests/Controllers/ProcessMapPlan/ProcessMapPlanDrillingControllerTest.cs
View File

@ -15,6 +15,8 @@ namespace AsbCloudWebApi.IntegrationTests.Controllers.ProcessMapPlan;
public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
{
private const int IdWell = 1;
private readonly ProcessMapPlanDrillingDto dto = new (){
Id = 0,
Creation = new(),
@ -22,14 +24,13 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
IdState = 0,
IdPrevious = null,
IdWell = 1,
IdWell = IdWell,
Section = "Кондуктор",
IdWellSectionType = 3,
DepthStart = 0.5,
DepthEnd = 1.5,
IdMode = 1,
Mode = "Ротор",
AxialLoadPlan = 2.718281,
AxialLoadLimitMax = 3.1415926,
DeltaPressurePlan = 4,
@ -55,7 +56,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
IdState = AsbCloudDb.Model.ChangeLogAbstract.IdStateActual,
IdPrevious = null,
IdWell = 1,
IdWell = IdWell,
IdWellSectionType = 1,
DepthStart = 0.5,
DepthEnd = 1.5,
@ -115,7 +116,6 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
nameof(ProcessMapPlanDrillingDto.IdState),
nameof(ProcessMapPlanDrillingDto.Author),
nameof(ProcessMapPlanDrillingDto.Creation),
nameof(ProcessMapPlanDrillingDto.Mode),
nameof(ProcessMapPlanDrillingDto.Section)
};
MatchHelper.Match(expected, actual, excludeProps);
@ -148,21 +148,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
//assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
[Fact]
public async Task InsertRange_returns_BadRequest_for_IdWell()
{
//arrange
var badDto = dto.Adapt<ProcessMapPlanDrillingDto>();
badDto.IdWell = int.MaxValue;
//act
var response = await client.InsertRange(dto.IdWell, new[] { badDto });
//assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
[Fact]
public async Task ClearAndInsertRange_returns_success()
{
@ -214,6 +200,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
entry.State = EntityState.Detached;
var dtoUpdate = dto.Adapt<ProcessMapPlanDrillingDto>();
dtoUpdate.IdWell = 0;
dtoUpdate.Id = entry.Entity.Id;
dtoUpdate.Comment = "nebuchadnezzar";
dtoUpdate.DeltaPressureLimitMax++;
@ -275,6 +262,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
var expected = dtoUpdate.Adapt<ProcessMapPlanDrilling>();
var excludeProps = new[] {
nameof(ProcessMapPlanDrilling.Id),
nameof(ProcessMapPlanDrilling.IdWell),
nameof(ProcessMapPlanDrilling.Author),
nameof(ProcessMapPlanDrilling.IdAuthor),
nameof(ProcessMapPlanDrilling.Editor),
@ -346,7 +334,6 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
Assert.InRange(actual.Obsolete.Value, startTime, doneTime);
}
[Fact]
public async Task GetDatesChange_returns_success()
{
@ -358,7 +345,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
dbset.Add(entity);
dbset.Add(entity2);
dbContext.SaveChanges();
var timezoneHours = Data.Defaults.Wells[0].Timezone.Hours;
var timezoneHours = Defaults.Timezone.Hours;
var offset = TimeSpan.FromHours(timezoneHours);
var dates = new[] { entity.Creation, entity2.Creation }
.Select(d => d.ToOffset(offset))
@ -537,7 +524,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
dbContext.SaveChanges();
var timezoneHours = Data.Defaults.Wells[0].Timezone.Hours;
var timezoneHours = Defaults.Timezone.Hours;
var offset = TimeSpan.FromHours(timezoneHours);
var updateFrom = entity.Creation.ToOffset(offset).AddHours(0.5);
@ -572,9 +559,10 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
const string fileName = "ProcessMapPlanDrillingValid.xlsx";
var stream = Assembly.GetExecutingAssembly().GetFileCopyStream(fileName);
//act
var streamPart = new StreamPart(stream, fileName, "application/octet-stream");
var response = await client.Parse(Defaults.Wells[0].Id, new[] { streamPart });
//act
var response = await client.Parse(IdWell, streamPart);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -601,9 +589,10 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
const string fileName = "ProcessMapPlanDrillingInvalid.xlsx";
var stream = Assembly.GetExecutingAssembly().GetFileCopyStream(fileName);
//act
var streamPart = new StreamPart(stream, fileName, "application/octet-stream");
var response = await client.Parse(Defaults.Wells[0].Id, new[] { streamPart });
//act
var response = await client.Parse(IdWell, streamPart);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -619,4 +608,4 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
Assert.False(row.IsValid);
Assert.Equal(2, row.Warnings.Count());
}
}
}

505
AsbCloudWebApi.IntegrationTests/Controllers/ProcessMapPlan/ProcessMapReportDrillingControllerTest.cs
View File

@ -2,314 +2,255 @@
using AsbCloudDb.Model;
using AsbCloudDb.Model.ProcessMaps;
using AsbCloudWebApi.IntegrationTests.Clients;
using Org.BouncyCastle.Asn1.Ocsp;
using System.Net;
using System.Net.Http.Headers;
using AsbCloudWebApi.IntegrationTests.Data;
using Xunit;
namespace AsbCloudWebApi.IntegrationTests.Controllers.ProcessMapPlan;
public class ProcessMapReportDrillingControllerTest : BaseIntegrationTest
{
private IProcessMapReportDrilling client;
private readonly WellSectionType wellSection = new WellSectionType()
{
Id = 1,
Caption = "Секция 1",
Order = 1
};
public ProcessMapReportDrillingControllerTest(WebAppFactoryFixture factory)
: base(factory)
{
dbContext.CleanupDbSet<DataSaubStat>();
dbContext.CleanupDbSet<ProcessMapPlanDrilling>();
client = factory.GetAuthorizedHttpClient<IProcessMapReportDrilling>(string.Empty);
}
private readonly WellOperationCategory wellOperationCategory = new WellOperationCategory()
{
Id = 1,
IdParent = null,
KeyValueName = "Name",
Name = "Name"
};
[Fact]
public async Task Get_rtk_report_by_default_request_returns_success()
{
//arrange
var well = dbContext.Wells.First();
private readonly WellOperation wellOperation = new WellOperation()
{
CategoryInfo = "CategoryInfo",
Id = 10,
Comment = "Comment",
DateStart = DateTimeOffset.UtcNow,
DepthEnd = 1,
DepthStart = 0.6,
DurationHours = 10,
IdCategory = 1,
IdPlan = null,
IdType = 1,
IdUser = 1,
IdWell = 1,
IdWellSectionType = 1,
LastUpdateDate = DateTimeOffset.UtcNow
};
var processMapPlanDrilling = CreateProcessMapPlanDrilling(well.Id);
dbContext.ProcessMapPlanDrilling.Add(processMapPlanDrilling);
private readonly List<DataSaubStat> dataSaubStats = new List<DataSaubStat>()
{
var wellOperation = CreateWellOperation(well.Id);
dbContext.WellOperations.Add(wellOperation);
new DataSaubStat()
{
AxialLoad = 0,
AxialLoadLimitMax = 10,
AxialLoadSp = 8,
BlockSpeedSp = 50.0,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(40),
DateStart = DateTimeOffset.UtcNow.AddMinutes(30),
DepthEnd = 85.99299621582031,
DepthStart = 85.9260025024414,
EnabledSubsystems = 0,
Flow = 10,
HasOscillation = true,
Id = 1,
IdCategory = 1,
IdFeedRegulator = 0,
IdTelemetry = 1,
Pressure = 24,
PressureIdle = 0,
PressureSp = 40,
RotorSpeed = 11.3,
RotorTorque = 1,
RotorTorqueLimitMax = 26.5,
RotorTorqueSp = 5,
Speed = 80.3924560546875
},
new DataSaubStat()
{
AxialLoad = 2,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 8,
BlockSpeedSp = 20,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(30),
DateStart = DateTimeOffset.UtcNow.AddMinutes(20),
DepthEnd = 86.28099822998047,
DepthStart = 86.21900177001953,
EnabledSubsystems = 1,
Flow = 20,
HasOscillation = true,
Id = 2,
IdCategory = 1,
IdFeedRegulator = 1,
IdTelemetry = 1,
Pressure = 30,
PressureIdle = 20,
PressureSp = 40,
RotorSpeed = 11.251153300212916,
RotorTorque = 7,
RotorTorqueLimitMax = 26.5,
RotorTorqueSp = 9,
Speed = 74.395751953125
},
new DataSaubStat()
{
AxialLoad = 4,
AxialLoadLimitMax = 15.0,
AxialLoadSp = 8,
BlockSpeedSp = 110.0,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(20),
DateStart = DateTimeOffset.UtcNow.AddMinutes(10),
DepthEnd = 106.7490005493164,
DepthStart = 106.47899627685547,
EnabledSubsystems = 1,
Flow = 30,
HasOscillation = true,
Id = 3,
IdCategory = 1,
IdFeedRegulator = 1,
IdTelemetry = 1,
Pressure = 36,
PressureIdle = 23.0,
PressureSp = 63.0,
RotorSpeed = 11.334207942999628,
RotorTorque = 14,
RotorTorqueLimitMax = 15.0,
RotorTorqueSp = 13,
Speed = 108.001708984375
}
};
var dataSaubStats = CreateDataSaubStats(well.IdTelemetry!.Value, wellOperation.IdCategory);
dbContext.DataSaubStat.AddRange(dataSaubStats);
await dbContext.SaveChangesAsync();
//act
var request = new DataSaubStatRequest();
var response = await client.GetReportAsync(well.Id, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
Assert.Equal(dataSaubStats.Count() - 1, response.Content.Count());
}
private readonly ProcessMapPlanDrilling entity = new()
{
Id = 0,
IdAuthor = 1,
IdEditor = null,
Creation = DateTimeOffset.UtcNow,
Obsolete = null,
IdState = AsbCloudDb.Model.ChangeLogAbstract.IdStateActual,
IdPrevious = null,
[Fact]
public async Task Get_rtk_report_by_parametrize_request_returns_success()
{
//arrange
var well = dbContext.Wells.First();
IdWell = 1,
IdWellSectionType = 1,
DepthStart = 0.5,
DepthEnd = 1.5,
var processMapPlanDrilling = CreateProcessMapPlanDrilling(well.Id);
dbContext.ProcessMapPlanDrilling.Add(processMapPlanDrilling);
IdMode = 1,
AxialLoadPlan = 2.718281,
AxialLoadLimitMax = 3.1415926,
DeltaPressurePlan = 4,
DeltaPressureLimitMax = 5,
TopDriveTorquePlan = 6,
TopDriveTorqueLimitMax = 7,
TopDriveSpeedPlan = 8,
TopDriveSpeedLimitMax = 9,
FlowPlan = 10,
FlowLimitMax = 11,
RopPlan = 12,
UsageSaub = 13,
UsageSpin = 14,
Comment = "это тестовая запись",
};
var wellOperation = CreateWellOperation(well.Id);
dbContext.WellOperations.Add(wellOperation);
private IProcessMapReportDrilling client;
var dataSaubStats = CreateDataSaubStats(well.IdTelemetry!.Value, wellOperation.IdCategory);
dbContext.DataSaubStat.AddRange(dataSaubStats);
public ProcessMapReportDrillingControllerTest(WebAppFactoryFixture factory) : base(factory)
{
client = factory.GetAuthorizedHttpClient<IProcessMapReportDrilling>(string.Empty);
}
await dbContext.SaveChangesAsync();
var request = new DataSaubStatRequest
{
DeltaAxialLoad = 5,
DeltaPressure = 15,
DeltaRotorTorque = 10
};
//act
var response = await client.GetReportAsync(well.Id, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
Assert.Equal(1, response.Content.Count());
}
[Fact]
public async Task Get_rtk_report_returns_BadRequest()
{
//act
var request = new DataSaubStatRequest()
{
DeltaAxialLoad = 15,
DeltaPressure = 25,
DeltaRotorTorque = 20
};
var response = await client.GetReportAsync(0, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
[Fact]
public async Task Export_rtk_report_returns_success()
{
//arrange
var well = dbContext.Wells.First();
var processMapPlanDrilling = CreateProcessMapPlanDrilling(well.Id);
dbContext.ProcessMapPlanDrilling.Add(processMapPlanDrilling);
[Fact]
public async Task Get_rtk_report_by_default_request_returns_success()
{
//arrange
dbContext.CleanupDbSet<ProcessMapPlanDrilling>();
var dbset = dbContext.Set<ProcessMapPlanDrilling>();
dbset.Add(entity);
entity.Id = 1;
dbset.Add(entity);
entity.Id = 2;
dbset.Add(entity);
var wellOperation = CreateWellOperation(well.Id);
dbContext.WellOperations.Add(wellOperation);
var dbSetWellOperationCategory = dbContext.Set<WellOperationCategory>();
dbSetWellOperationCategory.Add(wellOperationCategory);
var dataSaubStats = CreateDataSaubStats(well.IdTelemetry!.Value, wellOperation.IdCategory);
dbContext.DataSaubStat.AddRange(dataSaubStats);
var dbSetWellOperation = dbContext.Set<WellOperation>();
dbSetWellOperation.Add(wellOperation);
await dbContext.SaveChangesAsync();
//act
var request = new DataSaubStatRequest();
var response = await client.ExportReportAsync(1, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("application/octet-stream", response.ContentHeaders?.ContentType?.MediaType);
Assert.True(response.ContentHeaders?.ContentLength > 0);
}
var dbSetDataSaubStat = dbContext.Set<DataSaubStat>();
dbSetDataSaubStat.AddRange(dataSaubStats);
private static WellOperation CreateWellOperation(int idWell) =>
new()
{
CategoryInfo = "CategoryInfo",
Comment = "Comment",
DateStart = DateTimeOffset.UtcNow,
DepthEnd = 1,
DepthStart = 0.6,
DurationHours = 10,
IdCategory = WellOperationCategory.IdSlide,
IdPlan = null,
IdType = WellOperation.IdOperationTypeFact,
IdUser = 1,
IdWell = idWell,
IdWellSectionType = 1,
LastUpdateDate = DateTimeOffset.UtcNow
};
dbContext.SaveChanges();
private static ProcessMapPlanDrilling CreateProcessMapPlanDrilling(int idWell) =>
new()
{
IdAuthor = 1,
IdEditor = null,
Creation = DateTimeOffset.UtcNow,
Obsolete = null,
IdState = ChangeLogAbstract.IdStateActual,
IdPrevious = null,
//act
var request = new DataSaubStatRequest();
var response = await client.GetReportAsync(1, request, CancellationToken.None);
IdWell = idWell,
IdWellSectionType = 1,
DepthStart = 0.5,
DepthEnd = 1.5,
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
Assert.Equal(dataSaubStats.Count() - 1, response.Content.Count());
}
IdMode = 1,
AxialLoadPlan = 2.718281,
AxialLoadLimitMax = 3.1415926,
DeltaPressurePlan = 4,
DeltaPressureLimitMax = 5,
TopDriveTorquePlan = 6,
TopDriveTorqueLimitMax = 7,
TopDriveSpeedPlan = 8,
TopDriveSpeedLimitMax = 9,
FlowPlan = 10,
FlowLimitMax = 11,
RopPlan = 12,
UsageSaub = 13,
UsageSpin = 14,
Comment = "это тестовая запись",
};
[Fact]
public async Task Get_rtk_report_by_parametrize_request_returns_success()
{
//arrange
dbContext.CleanupDbSet<ProcessMapPlanDrilling>();
var dbset = dbContext.Set<ProcessMapPlanDrilling>();
dbset.Add(entity);
entity.Id = 1;
dbset.Add(entity);
entity.Id = 2;
dbset.Add(entity);
var dbSetWellOperationCategory = dbContext.Set<WellOperationCategory>();
dbSetWellOperationCategory.Add(wellOperationCategory);
var dbSetWellOperation = dbContext.Set<WellOperation>();
dbSetWellOperation.Add(wellOperation);
var dbSetDataSaubStat = dbContext.Set<DataSaubStat>();
dbSetDataSaubStat.AddRange(dataSaubStats);
dbContext.SaveChanges();
//act
var request = new DataSaubStatRequest()
{
DeltaAxialLoad = 5,
DeltaPressure = 15,
DeltaRotorTorque = 10
};
var response = await client.GetReportAsync(1, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
Assert.Equal(1, response.Content.Count());
}
[Fact]
public async Task Get_rtk_report_returns_BadRequest()
{
//arrange
dbContext.CleanupDbSet<ProcessMapPlanDrilling>();
var dbset = dbContext.Set<ProcessMapPlanDrilling>();
dbset.Add(entity);
entity.Id = 1;
dbset.Add(entity);
entity.Id = 2;
dbset.Add(entity);
var dbSetWellOperationCategory = dbContext.Set<WellOperationCategory>();
dbSetWellOperationCategory.Add(wellOperationCategory);
var dbSetWellOperation = dbContext.Set<WellOperation>();
dbSetWellOperation.Add(wellOperation);
var dbSetDataSaubStat = dbContext.Set<DataSaubStat>();
dbSetDataSaubStat.AddRange(dataSaubStats);
dbContext.SaveChanges();
//act
var request = new DataSaubStatRequest()
{
DeltaAxialLoad = 15,
DeltaPressure = 25,
DeltaRotorTorque = 20
};
var response = await client.GetReportAsync(1, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
[Fact]
public async Task Export_rtk_report_returns_success()
{
//clear
dbContext.CleanupDbSet<ProcessMapPlanDrilling>();
//arrange
var dbset = dbContext.Set<ProcessMapPlanDrilling>();
dbset.Add(entity);
entity.Id = 1;
dbset.Add(entity);
entity.Id = 2;
dbset.Add(entity);
var dbSetWellOperationCategory = dbContext.Set<WellOperationCategory>();
dbSetWellOperationCategory.Add(wellOperationCategory);
var dbSetWellOperation = dbContext.Set<WellOperation>();
dbSetWellOperation.Add(wellOperation);
var dbSetDataSaubStat = dbContext.Set<DataSaubStat>();
dbSetDataSaubStat.AddRange(dataSaubStats);
dbContext.SaveChanges();
//act
var request = new DataSaubStatRequest();
var response = await client.ExportReportAsync(1, request, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("application/octet-stream", response.ContentHeaders?.ContentType?.MediaType);
Assert.True(response.ContentHeaders?.ContentLength > 0);
}
}
private static IEnumerable<DataSaubStat> CreateDataSaubStats(int idTelemetry,
int idCategory) =>
new[]
{
new DataSaubStat
{
AxialLoad = 0,
AxialLoadLimitMax = 10,
AxialLoadSp = 8,
BlockSpeedSp = 50.0,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(40),
DateStart = DateTimeOffset.UtcNow.AddMinutes(30),
DepthEnd = 85.99299621582031,
DepthStart = 85.9260025024414,
EnabledSubsystems = 0,
Flow = 10,
IdCategory = idCategory,
HasOscillation = true,
IdFeedRegulator = 0,
IdTelemetry = idTelemetry,
Pressure = 24,
PressureIdle = 0,
PressureSp = 40,
RotorSpeed = 11.3,
RotorTorque = 1,
RotorTorqueLimitMax = 26.5,
RotorTorqueSp = 5,
Speed = 80.3924560546875
},
new DataSaubStat
{
AxialLoad = 2,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 8,
BlockSpeedSp = 20,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(30),
DateStart = DateTimeOffset.UtcNow.AddMinutes(20),
DepthEnd = 86.28099822998047,
DepthStart = 86.21900177001953,
EnabledSubsystems = 1,
Flow = 20,
HasOscillation = true,
IdCategory = idCategory,
IdFeedRegulator = 1,
IdTelemetry = idTelemetry,
Pressure = 30,
PressureIdle = 20,
PressureSp = 40,
RotorSpeed = 11.251153300212916,
RotorTorque = 7,
RotorTorqueLimitMax = 26.5,
RotorTorqueSp = 9,
Speed = 74.395751953125
},
new DataSaubStat
{
AxialLoad = 4,
AxialLoadLimitMax = 15.0,
AxialLoadSp = 8,
BlockSpeedSp = 110.0,
DateEnd = DateTimeOffset.UtcNow.AddMinutes(20),
DateStart = DateTimeOffset.UtcNow.AddMinutes(10),
DepthEnd = 106.7490005493164,
DepthStart = 106.47899627685547,
EnabledSubsystems = 1,
Flow = 30,
HasOscillation = true,
IdFeedRegulator = 1,
IdTelemetry = idTelemetry,
IdCategory = idCategory,
Pressure = 36,
PressureIdle = 23.0,
PressureSp = 63.0,
RotorSpeed = 11.334207942999628,
RotorTorque = 14,
RotorTorqueLimitMax = 15.0,
RotorTorqueSp = 13,
Speed = 108.001708984375
}
};
}

456
AsbCloudWebApi.IntegrationTests/Controllers/ScheduleControllerTest.cs
View File

@ -1,228 +1,228 @@
using AsbCloudApp.Data;
using AsbCloudDb.Model;
using AsbCloudInfrastructure;
using AsbCloudWebApi.IntegrationTests.Clients;
using Mapster;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using System.Net;
using Xunit;
namespace AsbCloudWebApi.IntegrationTests.Controllers
{
public abstract class CrudWellRelatedClient<TDto, TEntity> : BaseIntegrationTest
where TDto : AsbCloudApp.Data.IId, AsbCloudApp.Data.IWellRelated
where TEntity : class, AsbCloudDb.Model.IId, AsbCloudDb.Model.IWellRelated
{
public abstract IEnumerable<TDto> ValidDtos { get; }
public abstract IEnumerable<TDto> InvalidDtos { get; }
public abstract IEnumerable<TDto> ForbiddenDtos { get; }
protected List<string> ExcludeProps { get; set; } = new() { "Id" };
protected ICrudWellRelatedClient<TDto> client;
public CrudWellRelatedClient(WebAppFactoryFixture factory, string uriSuffix)
: base(factory)
{
client = factory.GetAuthorizedHttpClient<ICrudWellRelatedClient<TDto>>(uriSuffix);
}
protected async Task<DbSet<TEntity>> GetCleanDbSet()
{
var dbset = dbContext.Set<TEntity>();
dbset.RemoveRange(dbset);
await dbContext.SaveChangesAsync(CancellationToken.None);
return dbset;
}
[Fact]
public async Task Insert_returns_success_for_validDtos()
{
foreach (var validDto in ValidDtos)
await Insert_returns_success(validDto);
}
private async Task Insert_returns_success(TDto validDto)
{
var dbset = await GetCleanDbSet();
//act
var response = await client.InsertAsync(validDto);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(response.Content > 0);
var entity = dbset.First();
var fromDbDto = Convert(entity);
MatchHelper.Match(validDto, fromDbDto, ExcludeProps);
}
[Fact]
public async Task Insert_returns_badRequest_for_invalidDtos()
{
foreach (var inValidDto in InvalidDtos)
await Insert_returns_badRequest(inValidDto);
}
private async Task Insert_returns_badRequest(TDto invalidDto)
{
await GetCleanDbSet();
//act
var response = await client.InsertAsync(invalidDto);
//assert
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
[Fact]
public async Task Insert_returns_forbidden_for_forbiddenDtos()
{
foreach (var forbiddenDto in ForbiddenDtos)
await Insert_returns_forbidden(forbiddenDto);
}
private async Task Insert_returns_forbidden(TDto forbiddenDto)
{
await GetCleanDbSet();
//act
var response = await client.InsertAsync(forbiddenDto);
//assert
Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
}
[Fact]
public async Task GetAllAsync_returns_data()
{
//arrange
var dbset = await GetCleanDbSet();
var entries = new List<(EntityEntry<TEntity>, TDto)>();
foreach (var dto in ValidDtos)
{
var entity = Convert(dto);
entity.Id = 0;
var entry = dbset.Add(entity);
entries.Add((entry, dto));
}
dbContext.SaveChanges();
//act
var response = await client.GetAllAsync();
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
Assert.Equal(entries.Count, response.Content.Count());
foreach (var item in response.Content)
{
var entry = entries.First(e => e.Item1.Entity.Id == item.Id);
MatchHelper.Match(entry.Item2, item, ExcludeProps);
}
}
protected virtual TDto Convert(TEntity entity)
{
var dto = entity.Adapt<TDto>();
return dto;
}
protected virtual TEntity Convert(TDto dto)
{
var entity = dto.Adapt<TEntity>();
return entity;
}
}
public class ScheduleControllerTest : CrudWellRelatedClient<ScheduleDto, Schedule>
{
static Driller driller = Data.Defaults.Drillers.First();
static DrillerDto drillerDto = driller.Adapt<DrillerDto>();
static Well well = Data.Defaults.Wells.First();
public override IEnumerable<ScheduleDto> ValidDtos { get; } = new ScheduleDto[]
{
new() {
Id = 1,
IdWell = well.Id,
Driller = drillerDto,
IdDriller = driller.Id,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(8, 0, 0),
ShiftEnd = new TimeDto(20, 0, 0),
},
new() {
Id = 1,
IdWell = well.Id,
Driller = drillerDto,
IdDriller = driller.Id,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(20, 0, 0),
ShiftEnd = new TimeDto(8, 0, 0),
}
};
public override IEnumerable<ScheduleDto> InvalidDtos { get; } = new ScheduleDto[]
{
new() {
IdWell = well.Id,
Driller = drillerDto,
IdDriller = driller.Id,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2022, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(8, 0, 0),
ShiftEnd = new TimeDto(20, 0, 0),
},
new() {
IdWell = well.Id,
Driller = drillerDto,
IdDriller = int.MaxValue - 1,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(8, 0, 0),
ShiftEnd = new TimeDto(20, 0, 0),
}
};
public override IEnumerable<ScheduleDto> ForbiddenDtos { get; } = new ScheduleDto[] {
new() {
IdWell = int.MaxValue - 1,
Driller = drillerDto,
IdDriller = driller.Id,
DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
DrillEnd = new DateTime(2022, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
ShiftStart = new TimeDto(8, 0, 0),
ShiftEnd = new TimeDto(20, 0, 0),
}
};
public ScheduleControllerTest(WebAppFactoryFixture factory)
: base(factory, "api/schedule")
{
ExcludeProps.Add(nameof(ScheduleDto.Driller));
}
protected override ScheduleDto Convert(Schedule entity)
{
var dto = base.Convert(entity);
dto.DrillStart = entity.DrillStart.ToRemoteDateTime(well.Timezone.Hours);
dto.DrillEnd = entity.DrillEnd.ToRemoteDateTime(well.Timezone.Hours);
return dto;
}
protected override Schedule Convert(ScheduleDto dto)
{
var entity = base.Convert(dto);
entity.DrillStart = dto.DrillStart.FromTimeZoneOffsetHours(well.Timezone.Hours);
entity.DrillEnd = dto.DrillEnd.FromTimeZoneOffsetHours(well.Timezone.Hours);
return entity;
}
}
}
// using AsbCloudApp.Data;
// using AsbCloudDb.Model;
// using AsbCloudInfrastructure;
// using AsbCloudWebApi.IntegrationTests.Clients;
// using Mapster;
// using Microsoft.EntityFrameworkCore;
// using Microsoft.EntityFrameworkCore.ChangeTracking;
// using System.Net;
// using Xunit;
//
// namespace AsbCloudWebApi.IntegrationTests.Controllers
// {
// public abstract class CrudWellRelatedClient<TDto, TEntity> : BaseIntegrationTest
// where TDto : AsbCloudApp.Data.IId, AsbCloudApp.Data.IWellRelated
// where TEntity : class, AsbCloudDb.Model.IId, AsbCloudDb.Model.IWellRelated
// {
// public abstract IEnumerable<TDto> ValidDtos { get; }
// public abstract IEnumerable<TDto> InvalidDtos { get; }
// public abstract IEnumerable<TDto> ForbiddenDtos { get; }
// protected List<string> ExcludeProps { get; set; } = new() { "Id" };
//
// protected ICrudWellRelatedClient<TDto> client;
//
// public CrudWellRelatedClient(WebAppFactoryFixture factory, string uriSuffix)
// : base(factory)
// {
// client = factory.GetAuthorizedHttpClient<ICrudWellRelatedClient<TDto>>(uriSuffix);
// }
//
// protected async Task<DbSet<TEntity>> GetCleanDbSet()
// {
// var dbset = dbContext.Set<TEntity>();
// dbset.RemoveRange(dbset);
// await dbContext.SaveChangesAsync(CancellationToken.None);
// return dbset;
// }
//
// [Fact]
// public async Task Insert_returns_success_for_validDtos()
// {
// foreach (var validDto in ValidDtos)
// await Insert_returns_success(validDto);
// }
//
// private async Task Insert_returns_success(TDto validDto)
// {
// var dbset = await GetCleanDbSet();
//
// //act
// var response = await client.InsertAsync(validDto);
//
// //assert
// Assert.Equal(HttpStatusCode.OK, response.StatusCode);
// Assert.True(response.Content > 0);
//
// var entity = dbset.First();
// var fromDbDto = Convert(entity);
// MatchHelper.Match(validDto, fromDbDto, ExcludeProps);
// }
//
// [Fact]
// public async Task Insert_returns_badRequest_for_invalidDtos()
// {
// foreach (var inValidDto in InvalidDtos)
// await Insert_returns_badRequest(inValidDto);
// }
//
// private async Task Insert_returns_badRequest(TDto invalidDto)
// {
// await GetCleanDbSet();
//
// //act
// var response = await client.InsertAsync(invalidDto);
//
// //assert
// Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
// }
//
// [Fact]
// public async Task Insert_returns_forbidden_for_forbiddenDtos()
// {
// foreach (var forbiddenDto in ForbiddenDtos)
// await Insert_returns_forbidden(forbiddenDto);
// }
//
// private async Task Insert_returns_forbidden(TDto forbiddenDto)
// {
// await GetCleanDbSet();
//
// //act
// var response = await client.InsertAsync(forbiddenDto);
//
// //assert
// Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode);
// }
//
// [Fact]
// public async Task GetAllAsync_returns_data()
// {
// //arrange
// var dbset = await GetCleanDbSet();
// var entries = new List<(EntityEntry<TEntity>, TDto)>();
//
// foreach (var dto in ValidDtos)
// {
// var entity = Convert(dto);
// entity.Id = 0;
// var entry = dbset.Add(entity);
// entries.Add((entry, dto));
// }
// dbContext.SaveChanges();
//
// //act
// var response = await client.GetAllAsync();
//
// //assert
// Assert.Equal(HttpStatusCode.OK, response.StatusCode);
// Assert.NotNull(response.Content);
// Assert.Equal(entries.Count, response.Content.Count());
//
// foreach (var item in response.Content)
// {
// var entry = entries.First(e => e.Item1.Entity.Id == item.Id);
// MatchHelper.Match(entry.Item2, item, ExcludeProps);
// }
// }
//
// protected virtual TDto Convert(TEntity entity)
// {
// var dto = entity.Adapt<TDto>();
// return dto;
// }
//
// protected virtual TEntity Convert(TDto dto)
// {
// var entity = dto.Adapt<TEntity>();
// return entity;
// }
// }
//
// public class ScheduleControllerTest : CrudWellRelatedClient<ScheduleDto, Schedule>
// {
// static Driller driller = Data.Defaults.Drillers.First();
// static DrillerDto drillerDto = driller.Adapt<DrillerDto>();
//
// static Well well = Data.Defaults.Wells.First();
//
// public override IEnumerable<ScheduleDto> ValidDtos { get; } = new ScheduleDto[]
// {
// new() {
// Id = 1,
// IdWell = well.Id,
// Driller = drillerDto,
// IdDriller = driller.Id,
// DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
// DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
// ShiftStart = new TimeDto(8, 0, 0),
// ShiftEnd = new TimeDto(20, 0, 0),
// },
// new() {
// Id = 1,
// IdWell = well.Id,
// Driller = drillerDto,
// IdDriller = driller.Id,
// DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
// DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
// ShiftStart = new TimeDto(20, 0, 0),
// ShiftEnd = new TimeDto(8, 0, 0),
// }
// };
//
// public override IEnumerable<ScheduleDto> InvalidDtos { get; } = new ScheduleDto[]
// {
// new() {
// IdWell = well.Id,
// Driller = drillerDto,
// IdDriller = driller.Id,
// DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
// DrillEnd = new DateTime(2022, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
// ShiftStart = new TimeDto(8, 0, 0),
// ShiftEnd = new TimeDto(20, 0, 0),
// },
// new() {
// IdWell = well.Id,
// Driller = drillerDto,
// IdDriller = int.MaxValue - 1,
// DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
// DrillEnd = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
// ShiftStart = new TimeDto(8, 0, 0),
// ShiftEnd = new TimeDto(20, 0, 0),
// }
// };
//
// public override IEnumerable<ScheduleDto> ForbiddenDtos { get; } = new ScheduleDto[] {
// new() {
// IdWell = int.MaxValue - 1,
// Driller = drillerDto,
// IdDriller = driller.Id,
// DrillStart = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Unspecified),
// DrillEnd = new DateTime(2022, 1, 2, 0, 0, 0, DateTimeKind.Unspecified),
// ShiftStart = new TimeDto(8, 0, 0),
// ShiftEnd = new TimeDto(20, 0, 0),
// }
// };
//
// public ScheduleControllerTest(WebAppFactoryFixture factory)
// : base(factory, "api/schedule")
// {
// ExcludeProps.Add(nameof(ScheduleDto.Driller));
// }
//
// protected override ScheduleDto Convert(Schedule entity)
// {
// var dto = base.Convert(entity);
// dto.DrillStart = entity.DrillStart.ToRemoteDateTime(well.Timezone.Hours);
// dto.DrillEnd = entity.DrillEnd.ToRemoteDateTime(well.Timezone.Hours);
// return dto;
// }
//
// protected override Schedule Convert(ScheduleDto dto)
// {
// var entity = base.Convert(dto);
// entity.DrillStart = dto.DrillStart.FromTimeZoneOffsetHours(well.Timezone.Hours);
// entity.DrillEnd = dto.DrillEnd.FromTimeZoneOffsetHours(well.Timezone.Hours);
// return entity;
// }
// }
// }

111
AsbCloudWebApi.IntegrationTests/Controllers/SlipsStatControllerTest.cs
View File

@ -2,77 +2,38 @@ using AsbCloudApp.Data;
using AsbCloudApp.Requests;
using AsbCloudDb.Model;
using AsbCloudWebApi.IntegrationTests.Clients;
using Microsoft.EntityFrameworkCore;
using Xunit;
namespace AsbCloudWebApi.IntegrationTests.Controllers;
public class SlipsStatControllerTest : BaseIntegrationTest
{
private static readonly Schedule schedule = new()
{
Id = 0,
IdDriller = Data.Defaults.Drillers[0].Id,
IdWell = Data.Defaults.Wells[0].Id,
ShiftStart = new TimeOnly(8, 0, 0),
ShiftEnd = new TimeOnly(20, 0, 0),
DrillStart = new DateTimeOffset(new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc)),
DrillEnd = new DateTimeOffset(new DateTime(2024, 2, 1, 0, 0, 0, DateTimeKind.Utc))
};
private static readonly DetectedOperation detectedOperation = new()
{
Id = 0,
IdTelemetry = Data.Defaults.Telemetries[0].Id,
IdCategory = WellOperationCategory.IdSlipsTime,
DateStart = new DateTimeOffset(new DateTime(2024, 1, 23, 15, 0, 0, 0, DateTimeKind.Utc)),
DateEnd = new DateTimeOffset(new DateTime(2024, 1, 23, 15, 2, 0, 0, DateTimeKind.Utc)),
ExtraData = new Dictionary<string, object>
{
{ "test", 5 }
}
};
private static readonly WellOperation factWellOperation = new()
{
Id = 0,
IdWell = Data.Defaults.Wells[0].Id,
IdWellSectionType = 1,
IdCategory = WellOperationCategory.IdRotor,
IdType = WellOperation.IdOperationTypeFact,
DepthStart = 0,
DepthEnd = 100,
LastUpdateDate = DateTimeOffset.UtcNow,
DateStart = new DateTimeOffset(new DateTime(2024, 1, 15, 15, 0, 0, DateTimeKind.Utc)),
DurationHours = 1
};
private readonly ISlipsTimeClient client;
public SlipsStatControllerTest(WebAppFactoryFixture factory)
: base(factory)
{
var schedules = dbContext.Set<Schedule>();
var detectedOperations = dbContext.Set<DetectedOperation>();
var wellOperations = dbContext.Set<WellOperation>();
schedules.RemoveRange(schedules);
detectedOperations.RemoveRange(detectedOperations);
wellOperations.RemoveRange(wellOperations);
dbContext.SaveChanges();
schedules.Add(schedule);
detectedOperations.Add(detectedOperation);
wellOperations.Add(factWellOperation);
dbContext.SaveChanges();
client = factory.GetAuthorizedHttpClient<ISlipsTimeClient>(string.Empty);
dbContext.CleanupDbSet<Schedule>();
dbContext.CleanupDbSet<WellOperation>();
dbContext.CleanupDbSet<DetectedOperation>();
}
[Fact]
public async Task GetAll_returns_success()
{
//arrange
var well = dbContext.Wells.First();
var schedule = CreateScheduleAsync(well.Id);
var factWellOperation = CreateFactWellOperation(well.Id);
var detectedOperation = CreateDetectedOperation(well.IdTelemetry!.Value);
dbContext.Schedule.Add(schedule);
dbContext.WellOperations.Add(factWellOperation);
dbContext.DetectedOperations.Add(detectedOperation);
await dbContext.SaveChangesAsync();
var request = new OperationStatRequest
{
DateStartUTC = schedule.DrillStart.DateTime,
@ -83,7 +44,7 @@ public class SlipsStatControllerTest : BaseIntegrationTest
var dtoExpected = new SlipsStatDto
{
DrillerName = $"{Data.Defaults.Drillers[0].Surname} {Data.Defaults.Drillers[0].Name} {Data.Defaults.Drillers[0].Patronymic}",
DrillerName = $"{schedule.Driller.Surname} {schedule.Driller.Name} {schedule.Driller.Patronymic}",
WellCount = 1,
SectionCaption = "Пилотный ствол",
SlipsCount = 1,
@ -101,4 +62,46 @@ public class SlipsStatControllerTest : BaseIntegrationTest
var slipsStat = response.Content.First();
MatchHelper.Match(dtoExpected, slipsStat);
}
private static Schedule CreateScheduleAsync(int idWell) => new()
{
IdWell = idWell,
ShiftStart = new TimeOnly(8, 0, 0),
ShiftEnd = new TimeOnly(20, 0, 0),
DrillStart = new DateTimeOffset(new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc)),
DrillEnd = new DateTimeOffset(new DateTime(2024, 2, 1, 0, 0, 0, DateTimeKind.Utc)),
Driller = new Driller
{
Name = "TestName",
Surname = "TestSurname",
Patronymic = "TestPatronymic"
}
};
private static WellOperation CreateFactWellOperation(int idWell) =>
new()
{
IdWell = idWell,
IdWellSectionType = 1,
IdCategory = WellOperationCategory.IdRotor,
IdType = WellOperation.IdOperationTypeFact,
DepthStart = 0,
DepthEnd = 100,
LastUpdateDate = DateTimeOffset.UtcNow,
DateStart = new DateTimeOffset(new DateTime(2024, 1, 15, 15, 0, 0, DateTimeKind.Utc)),
DurationHours = 1
};
private static DetectedOperation CreateDetectedOperation(int idTelemetry) =>
new()
{
IdTelemetry = idTelemetry,
IdCategory = WellOperationCategory.IdSlipsTime,
DateStart = new DateTimeOffset(new DateTime(2024, 1, 23, 15, 0, 0, 0, DateTimeKind.Utc)),
DateEnd = new DateTimeOffset(new DateTime(2024, 1, 23, 15, 2, 0, 0, DateTimeKind.Utc)),
ExtraData = new Dictionary<string, object>
{
{ "test", 5 }
}
};
}

197
AsbCloudWebApi.IntegrationTests/Controllers/WellOperationControllerTest.cs
View File

@ -5,6 +5,8 @@ using System.Net;
using System.Reflection;
using AsbCloudApp.Requests;
using AsbCloudWebApi.IntegrationTests.Data;
using Mapster;
using Microsoft.EntityFrameworkCore;
using Refit;
using Xunit;
@ -12,85 +14,76 @@ namespace AsbCloudWebApi.IntegrationTests.Controllers;
public class WellOperationControllerTest : BaseIntegrationTest
{
private static int idWell = 1;
private readonly WellOperationDto[] dtos = new WellOperationDto[]
{
new()
{
IdWell = 1,
IdWellSectionType = 1,
WellSectionTypeName = "Пилотный ствол",
IdCategory = 5000,
IdPlan = null,
CategoryName = "Разборка КНБК",
IdParentCategory = 4000,
CategoryInfo = "1",
IdType = 0,
DepthStart = 10.0,
DepthEnd = 20.0,
Day = 0.0,
NptHours = 0.0,
DateStart = new DateTimeOffset(new DateTime(2023, 1, 10), TimeSpan.FromHours(Defaults.Wells[0].Timezone.Hours)),
DurationHours = 1.0,
Comment = "1",
IdUser = 1,
UserName = null,
}
};
private IWellOperationClient client;
public WellOperationControllerTest(WebAppFactoryFixture factory)
: base(factory)
{
client = factory.GetAuthorizedHttpClient<IWellOperationClient>(string.Empty);
}
public WellOperationControllerTest(WebAppFactoryFixture factory)
: base(factory)
{
client = factory.GetAuthorizedHttpClient<IWellOperationClient>(string.Empty);
/// <summary>
/// Успешное добавление операций (без предварительной очистки данных)
/// </summary>
/// <returns></returns>
[Fact]
public async Task InsertRange_returns_success()
{
dbContext.CleanupDbSet<WellOperation>();
//act
var response = await client.InsertRangeAsync(idWell, 1, false, dtos);
dbContext.CleanupDbSet<WellOperation>();
}
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
/// <summary>
/// Успешное добавление операций (без предварительной очистки данных)
/// </summary>
/// <returns></returns>
[Fact]
public async Task InsertRange_returns_success()
{
//arrange
var well = await dbContext.Wells.FirstAsync();
var entity = CreateWellOperation(well.Id);
var dtos = new[] { entity.Adapt<WellOperationDto>() };
/// <summary>
/// Успешное добавление операций (с предварительной очисткой данных)
/// </summary>
/// <returns></returns>
[Fact]
public async Task InsertRangeWithDeleteBefore_returns_success()
{
//act
var response = await client.InsertRangeAsync(idWell, 1, true, dtos);
//act
var response = await client.InsertRangeAsync(well.Id, 1, false, dtos);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
/// <summary>
/// Успешное обновление операции
/// </summary>
/// <returns></returns>
[Fact]
public async Task UpdateAsync_returns_success()
{
//act
var dto = dtos.FirstOrDefault()!;
var response = await client.UpdateAsync(idWell, 1, dto, CancellationToken.None);
/// <summary>
/// Успешное добавление операций (с предварительной очисткой данных)
/// </summary>
/// <returns></returns>
[Fact]
public async Task InsertRangeWithDeleteBefore_returns_success()
{
//arrange
var well = await dbContext.Wells.FirstAsync();
var entity = CreateWellOperation(well.Id);
var dtos = new[] { entity.Adapt<WellOperationDto>() };
//act
var response = await client.InsertRangeAsync(well.Id, 1, true, dtos);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
/// <summary>
/// Успешное обновление операции
/// </summary>
/// <returns></returns>
[Fact]
public async Task UpdateAsync_returns_success()
{
//arrange
var well = await dbContext.Wells.FirstAsync();
var entity = CreateWellOperation(well.Id);
dbContext.WellOperations.Add(entity);
await dbContext.SaveChangesAsync();
var dto = entity.Adapt<WellOperationDto>();
//act
var response = await client.UpdateAsync(well.Id, entity.Id, dto, CancellationToken.None);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
/// <summary>
/// Получение плановых операций
/// </summary>
@ -99,8 +92,14 @@ public class WellOperationControllerTest : BaseIntegrationTest
public async Task GetPageOperationsPlanAsync_returns_success()
{
//arrange
dbContext.CleanupDbSet<WellOperation>();
await client.InsertRangeAsync(idWell, WellOperation.IdOperationTypePlan, false, dtos);
var well = await dbContext.Wells.FirstAsync();
var entity = CreateWellOperation(well.Id);
dbContext.WellOperations.Add(entity);
await dbContext.SaveChangesAsync();
var dto = entity.Adapt<WellOperationDto>();
var timezoneOffset = TimeSpan.FromHours(well.Timezone.Hours);
dto.DateStart = dto.DateStart.ToOffset(timezoneOffset);
var request = new WellOperationRequestBase
{
@ -108,49 +107,59 @@ public class WellOperationControllerTest : BaseIntegrationTest
};
//act
var response = await client.GetPageOperationsPlanAsync(idWell, request, CancellationToken.None);
var response = await client.GetPageOperationsPlanAsync(well.Id, request, CancellationToken.None);
//assert
Assert.NotNull(response.Content);
Assert.Single(response.Content.Items);
var dto = dtos[0];
var wellOperation = response.Content.Items.First();
var actualDto = response.Content.Items.First();
var excludeProps = new[] { nameof(WellOperationDto.Id) };
MatchHelper.Match(dto, wellOperation, excludeProps);
var excludeProps = new[]
{
nameof(WellOperationDto.LastUpdateDate)
};
MatchHelper.Match(dto, actualDto, excludeProps);
}
[Fact]
public async Task ImportPlanDefaultExcelFileAsync_returns_success()
{
//arrange
//TODO: вынести в метод расширения. Сделать когда доберёмся до рефакторинга операций по скважине
var resourceName = Assembly.GetExecutingAssembly()
.GetManifestResourceNames()
.FirstOrDefault(n => n.EndsWith("WellOperationsPlan.xlsx"));
if (string.IsNullOrWhiteSpace(resourceName))
throw new ArgumentNullException(nameof(resourceName));
var stream = Assembly.GetExecutingAssembly()
.GetManifestResourceStream(resourceName);
if (stream is null)
throw new ArgumentNullException(nameof(stream));
var stream = Assembly.GetExecutingAssembly().GetFileCopyStream("WellOperationsPlan.xlsx");
var memoryStream = new MemoryStream();
stream.CopyTo(memoryStream);
await stream.CopyToAsync(memoryStream);
memoryStream.Position = 0;
var well = await dbContext.Wells.FirstAsync();
//act
var streamPart = new StreamPart(memoryStream, "WellOperations.xlsx", "application/octet-stream");
var response = await client.ImportPlanDefaultExcelFileAsync(idWell, new[] { streamPart }, CancellationToken.None);
var response = await client.ImportPlanDefaultExcelFileAsync(well.Id, new[] { streamPart }, CancellationToken.None);
//assert
Assert.NotNull(response.Content);
Assert.Equal(4, response.Content.Count());
Assert.True(response.Content.All(w => Math.Abs(w.DateStart.Offset.Hours - Defaults.Wells[0].Timezone.Hours) < 0.1));
Assert.True(response.Content.All(w => Math.Abs(w.DateStart.Offset.Hours - Defaults.Timezone.Hours) < 0.1));
}
private static WellOperation CreateWellOperation(int idWell) =>
new()
{
IdWell = idWell,
IdWellSectionType = 2,
LastUpdateDate = DateTimeOffset.UtcNow,
IdCategory = 5000,
IdPlan = null,
CategoryInfo = "1",
IdType = 0,
DepthStart = 10.0,
DepthEnd = 20.0,
DateStart = new DateTimeOffset(new DateTime(2023, 1, 10), TimeSpan.FromHours(Defaults.Timezone.Hours)).ToUniversalTime(),
DurationHours = 1.0,
Comment = "1",
IdUser = 1
};
}

157
AsbCloudWebApi.IntegrationTests/Data/Defaults.cs
View File

@ -2,110 +2,55 @@
namespace AsbCloudWebApi.IntegrationTests.Data
{
[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2211:Поля, не являющиеся константами, не должны быть видимыми", Justification = "<Ожидание>")]
public static class Defaults
{
public static Driller[] Drillers = new Driller[]
{
new()
{
Id = 1,
Name = "test1",
Surname = "test1",
Patronymic = "test1"
},
new()
{
Id = 2,
Name = "test2",
Surname = "test2",
Patronymic = "test2"
}
};
[System.Diagnostics.CodeAnalysis.SuppressMessage("Usage", "CA2211:Поля, не являющиеся константами, не должны быть видимыми",
Justification = "<Ожидание>")]
public static class Defaults
{
public static SimpleTimezone Timezone => new()
{
Hours = 1
};
public static WellOperation[] WellOperations = new WellOperation[]
{
new()
{
Id = 1,
IdWell = 1,
IdType = 1,
DateStart = DateTimeOffset.UtcNow.AddDays(-1),
CategoryInfo = "1",
Comment = "1",
DepthEnd = 20,
DepthStart = 10,
DurationHours = 1,
IdCategory = 5000,
IdPlan = null,
IdUser = 1,
IdWellSectionType = 1,
LastUpdateDate = DateTimeOffset.UtcNow
}
};
public static Deposit[] Deposits = new Deposit[] {
new()
{
Id = 1,
Caption = "Deposit1",
Latitude = 10,
Longitude = 20,
Timezone = GetTimezone()
}
};
public static Cluster[] Clusters = new Cluster[] {
new()
{
Id = 1,
IdDeposit = Deposits[0].Id,
Caption = "Cluster1",
Latitude = 10,
Longitude = 20,
Timezone = GetTimezone()
}
};
public static Telemetry[] Telemetries = new Telemetry[]
{
new()
{
Id = 1,
RemoteUid = "555-555-555",
TimeZone = GetTimezone()
}
};
public static Well[] Wells = new Well[] {
new()
{
Id = 1,
IdCluster = Clusters[0].Id,
IdWellType = 1,
IdState = 1,
Caption = "Well1",
Latitude = 10,
Longitude = 20,
IdTelemetry = Telemetries[0].Id,
Timezone = GetTimezone()
}
};
public static RelationCompanyWell[] RelationsCompanyWell = new RelationCompanyWell[]
{
new() { IdCompany = 1, IdWell = Wells[0].Id },
};
public static RelationUserUserRole[] RelationsUserUserRole = new RelationUserUserRole[]
{
new(){ IdUserRole= 1, IdUser = 1}
};
private static SimpleTimezone GetTimezone() =>
new ()
{
Hours = 1
};
}
}
public static Deposit[] Deposits => new Deposit[]
{
new()
{
Caption = "Deposit1",
Latitude = 10,
Longitude = 20,
Timezone = Timezone,
Clusters = new[]
{
new Cluster
{
Caption = "Cluster1",
Latitude = 10,
Longitude = 20,
Timezone = Timezone,
Wells = new[]
{
new Well
{
IdWellType = 1,
IdState = 1,
Caption = "Well1",
Latitude = 10,
Longitude = 20,
Timezone = Timezone,
Telemetry = new Telemetry
{
RemoteUid = "555-555-555",
TimeZone = Timezone
},
RelationCompaniesWells = new RelationCompanyWell[]
{
new() { IdCompany = 1 },
},
}
}
}
}
}
};
}
}

15
AsbCloudWebApi.IntegrationTests/DbConnection.cs Normal file
View File

@ -0,0 +1,15 @@
namespace AsbCloudWebApi.IntegrationTests;
public class DbConnection
{
public string Host { get; set; } = null!;
public int Port { get; set; }
public string Username { get; set; } = null!;
public string Password { get; set; } = null!;
public string GetConnectionString() =>
$"Host={Host};Database={Guid.NewGuid()};Port={Port};Username={Username};Password={Password};Persist Security Info=True;Include Error Detail=True";
}

254
AsbCloudWebApi.IntegrationTests/Repository/DataSaubStatRepositoryTest.cs
View File

@ -2,6 +2,7 @@
using AsbCloudApp.Repositories;
using AsbCloudDb.Model;
using Mapster;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Xunit;
@ -9,157 +10,128 @@ namespace AsbCloudWebApi.IntegrationTests.Repository;
public class DataSaubStatRepositoryTest : BaseIntegrationTest
{
private static readonly TimeSpan timeSpan = TimeSpan.FromHours(1);
private readonly IDataSaubStatRepository dataSaubStatRepository;
public DataSaubStatRepositoryTest(WebAppFactoryFixture factory)
: base(factory)
{
dataSaubStatRepository = scope.ServiceProvider.GetRequiredService<IDataSaubStatRepository>();
dbContext.CleanupDbSet<DataSaubStat>();
}
private static readonly DataSaubStatDto[] statDtos = new DataSaubStatDto[2]
{
new()
{
IdTelemetry = 1,
DateEnd = new DateTimeOffset(2024, 1, 1, 20, 25, 0, timeSpan),
DateStart = new DateTimeOffset(2024, 1, 1, 20, 15, 0, timeSpan),
AxialLoad = 10.0,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 10.0,
BlockSpeedSp = 1000,
DepthEnd = 10.0,
DepthStart = 5.0,
EnabledSubsystems = 1,
Flow = 10.0,
HasOscillation = true,
Id = default,
IdCategory = 2,
IdFeedRegulator = 1,
Pressure = 10.0,
PressureIdle = 10.0,
PressureSp = 10.0,
RotorSpeed = 9.0,
RotorTorque = 9.0,
RotorTorqueSp = 9.0,
RotorTorqueLimitMax = 9.0,
Speed = 10.0
},
new()
{
IdTelemetry = 1,
DateEnd = new DateTimeOffset(2024, 2, 2, 20, 25, 0, timeSpan),
DateStart = new DateTimeOffset(2024, 2, 2, 20, 15, 0, timeSpan),
AxialLoad = 10.0,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 10.0,
BlockSpeedSp = 1000,
DepthEnd = 10.0,
DepthStart = 5.0,
EnabledSubsystems = 1,
Flow = 10.0,
HasOscillation = true,
Id = default,
IdCategory = 2,
IdFeedRegulator = 1,
Pressure = 10.0,
PressureIdle = 10.0,
PressureSp = 10.0,
RotorSpeed = 10.0,
RotorTorque = 10.0,
RotorTorqueSp = 10.0,
RotorTorqueLimitMax = 10.0,
Speed = 10.0
}
};
private static readonly WellOperationCategory category = new()
{
Id = 2,
IdParent = null,
Name = "Категория 2"
};
[Fact]
public async Task GetLastDatesAsync_returns_success()
{
//arrange
var telemetry = await dbContext.Telemetries.FirstAsync();
var timeZoneOffset = TimeSpan.FromHours(telemetry.TimeZone.Hours);
var dataSaubStat = CreateDataSaubStat(telemetry.Id, timeZoneOffset);
dbContext.AddRange(dataSaubStat);
await dbContext.SaveChangesAsync();
private readonly IDataSaubStatRepository dataSaubStatRepository;
var telemetryIds = dataSaubStat.Select(stat => stat.IdTelemetry).ToArray();
public DataSaubStatRepositoryTest(WebAppFactoryFixture factory) : base(factory)
{
dataSaubStatRepository = scope.ServiceProvider.GetRequiredService<IDataSaubStatRepository>();
}
//act
var result = await dataSaubStatRepository.GetLastsAsync(telemetryIds, CancellationToken.None);
[Fact]
public async Task GetLastDatesAsync_returns_success()
{
//prepare
dbContext.CleanupDbSet<DataSaubStat>();
dbContext.CleanupDbSet<WellOperationCategory>();
//assert
var expected = dataSaubStat.Max(stat => stat.DateEnd).ToOffset(timeZoneOffset);
var actual = result.First().DateEnd;
Assert.True((expected - actual).Ticks == 0.0);
}
var dbSetSaubStat = dbContext.Set<DataSaubStat>();
var dbSetCategories = dbContext.Set<WellOperationCategory>();
[Fact]
public async Task InsertRangeAsync_returns_success()
{
//arrange
var telemetry = await dbContext.Telemetries.FirstAsync();
var timeZoneOffset = TimeSpan.FromHours(telemetry.TimeZone.Hours);
var dataSaubStat = CreateDataSaubStat(telemetry.Id, timeZoneOffset);
var expectedDtos = dataSaubStat.Select(entity => ConvertToDto(entity, timeZoneOffset));
var entities = statDtos.Select(stat => ConvertToEntity(stat));
//act
await dataSaubStatRepository.InsertRangeAsync(expectedDtos, CancellationToken.None);
dbSetCategories.Add(category);
dbContext.SaveChanges();
//assert
var entities = await dbContext.DataSaubStat.ToArrayAsync();
var actualDtos = entities.Select(entity => ConvertToDto(entity, timeZoneOffset));
dbSetSaubStat.AddRange(entities);
dbContext.SaveChanges();
var excludedProps = new[]
{
nameof(DataSaubStat.Telemetry),
nameof(DataSaubStat.Id),
nameof(DataSaubStat.OperationCategory)
};
//act
var telemetryIds = statDtos.Select(stat => stat.IdTelemetry).ToArray();
var result = await dataSaubStatRepository.GetLastsAsync(telemetryIds, CancellationToken.None);
foreach (var actualDto in actualDtos)
{
var statDto = expectedDtos.FirstOrDefault(stat => stat.DateEnd == actualDto.DateEnd &&
stat.DateStart == actualDto.DateStart);
var expected = statDtos.Max(stat => stat.DateEnd);
var actual = result.First().DateEnd;
MatchHelper.Match(actualDto, statDto, excludedProps);
}
}
//assert
Assert.True((expected - actual).Ticks == 0.0);
}
private static IEnumerable<DataSaubStat> CreateDataSaubStat(int idTelemetry, TimeSpan timeZoneOffset) => new DataSaubStat[]
{
new()
{
IdTelemetry = idTelemetry,
DateEnd = new DateTimeOffset(2024, 1, 1, 20, 25, 0, timeZoneOffset).ToUniversalTime(),
DateStart = new DateTimeOffset(2024, 1, 1, 20, 15, 0, timeZoneOffset).ToUniversalTime(),
AxialLoad = 10.0,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 10.0,
BlockSpeedSp = 1000,
DepthEnd = 10.0,
DepthStart = 5.0,
EnabledSubsystems = 1,
Flow = 10.0,
HasOscillation = true,
IdCategory = WellOperationCategory.IdSlide,
IdFeedRegulator = 1,
Pressure = 10.0,
PressureIdle = 10.0,
PressureSp = 10.0,
RotorSpeed = 9.0,
RotorTorque = 9.0,
RotorTorqueSp = 9.0,
RotorTorqueLimitMax = 9.0,
Speed = 10.0
},
new()
{
IdTelemetry = idTelemetry,
DateEnd = new DateTimeOffset(2024, 2, 2, 20, 25, 0, timeZoneOffset).ToUniversalTime(),
DateStart = new DateTimeOffset(2024, 2, 2, 20, 15, 0, timeZoneOffset).ToUniversalTime(),
AxialLoad = 10.0,
AxialLoadLimitMax = 10.0,
AxialLoadSp = 10.0,
BlockSpeedSp = 1000,
DepthEnd = 10.0,
DepthStart = 5.0,
EnabledSubsystems = 1,
Flow = 10.0,
HasOscillation = true,
IdCategory = WellOperationCategory.IdSlide,
IdFeedRegulator = 1,
Pressure = 10.0,
PressureIdle = 10.0,
PressureSp = 10.0,
RotorSpeed = 10.0,
RotorTorque = 10.0,
RotorTorqueSp = 10.0,
RotorTorqueLimitMax = 10.0,
Speed = 10.0
}
};
[Fact]
public async Task InsertRangeAsync_returns_success()
{
//prepare
dbContext.CleanupDbSet<DataSaubStat>();
var dbSet = dbContext.Set<DataSaubStat>();
var dbSetCategories = dbContext.Set<WellOperationCategory>();
dbSetCategories.Add(category);
private static DataSaubStatDto ConvertToDto(DataSaubStat entity, TimeSpan timeZoneOffset)
{
var dto = entity.Adapt<DataSaubStatDto>();
dto.DateStart = dto.DateStart.ToOffset(timeZoneOffset);
dto.DateEnd = dto.DateEnd.ToOffset(timeZoneOffset);
dbContext.SaveChanges();
//act
var result = await dataSaubStatRepository.InsertRangeAsync(statDtos, CancellationToken.None);
//assert
Assert.Equal(statDtos.Length, result);
var statDtosFromDb = dbSet.Select(stat => ConvertToDto(stat, timeSpan)).ToArray();
var excludedProps = new[] {
nameof(DataSaubStat.Telemetry),
nameof(DataSaubStat.Id),
nameof(DataSaubStat.OperationCategory)
};
foreach (var statDtoFromDb in statDtosFromDb)
{
var statDto = statDtos
.Where(stat => stat.DateStart == statDtoFromDb.DateStart)
.Where(stat => stat.DateEnd == statDtoFromDb.DateEnd)
.FirstOrDefault();
MatchHelper.Match(statDtoFromDb, statDto, excludedProps);
}
}
private static DataSaubStat ConvertToEntity(DataSaubStatDto stat)
{
var entity = stat.Adapt<DataSaubStat>();
entity.DateStart = entity.DateStart.ToUniversalTime();
entity.DateEnd = entity.DateEnd.ToUniversalTime();
return entity;
}
private static DataSaubStatDto ConvertToDto(DataSaubStat stat, TimeSpan timeSpan)
{
var dto = stat.Adapt<DataSaubStatDto>();
dto.DateStart = dto.DateStart.ToOffset(timeSpan);
dto.DateEnd = dto.DateEnd.ToOffset(timeSpan);
return dto;
}
}
return dto;
}
}

113
AsbCloudWebApi.IntegrationTests/WebAppFactoryFixture.cs
View File

@ -1,4 +1,3 @@
using AsbCloudDb;
using AsbCloudDb.Model;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc.Testing;
@ -8,87 +7,85 @@ using Microsoft.Extensions.DependencyInjection;
using Refit;
using System.Net.Http.Headers;
using System.Text.Json;
using AsbCloudDb;
using AsbCloudWebApi.IntegrationTests.Converters;
using Xunit;
namespace AsbCloudWebApi.IntegrationTests;
public class WebAppFactoryFixture : WebApplicationFactory<Startup>,
IAsyncLifetime
public class WebAppFactoryFixture : WebApplicationFactory<Startup>
{
private static readonly JsonSerializerOptions jsonSerializerOptions = new()
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
PropertyNameCaseInsensitive = true,
private static readonly JsonSerializerOptions JsonSerializerOptions = new()
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
PropertyNameCaseInsensitive = true,
Converters = { new ValidationResultConverter() }
};
};
private static readonly RefitSettings refitSettings = new RefitSettings(new SystemTextJsonContentSerializer(jsonSerializerOptions));
private static readonly RefitSettings RefitSettings = new(new SystemTextJsonContentSerializer(JsonSerializerOptions));
protected override void ConfigureWebHost(IWebHostBuilder builder)
private readonly string connectionString;
public WebAppFactoryFixture()
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.AddJsonFile("appsettings.Tests.json")
.Build();
var connectionString = configuration.GetConnectionString("TestConnection")!;
builder.ConfigureServices(services =>
var dbConnection = configuration.GetSection("DbConnection").Get<DbConnection>()!;
connectionString = dbConnection.GetConnectionString();
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
builder.ConfigureServices(services =>
{
var descriptor = services.FirstOrDefault(d => d.ServiceType == typeof(DbContextOptions<AsbCloudDbContext>));
var descriptor = services.SingleOrDefault(d => d.ServiceType == typeof(DbContextOptions<AsbCloudDbContext>));
if (descriptor is not null)
if (descriptor != null)
services.Remove(descriptor);
services.AddDbContext<AsbCloudDbContext>(options =>
options.UseNpgsql(connectionString));
var serviceProvider = services.BuildServiceProvider();
using var scope = serviceProvider.CreateScope();
var scopedServices = scope.ServiceProvider;
var dbContext = scopedServices.GetRequiredService<AsbCloudDbContext>();
dbContext.Database.EnsureCreatedAndMigrated();
dbContext.Deposits.AddRange(Data.Defaults.Deposits);
dbContext.SaveChanges();
});
}
public async Task InitializeAsync()
public override async ValueTask DisposeAsync()
{
using var scope = Services.CreateScope();
var scopedServices = scope.ServiceProvider;
var dbContext = scopedServices.GetRequiredService<AsbCloudDbContext>();
dbContext.Database.EnsureDeleted();
dbContext.Database.EnsureCreatedAndMigrated();
await FillBaseDatasets(dbContext);
var dbContext = new AsbCloudDbContext(
new DbContextOptionsBuilder<AsbCloudDbContext>()
.UseNpgsql(connectionString)
.Options);
await dbContext.Database.EnsureDeletedAsync();
}
private static async Task FillBaseDatasets(AsbCloudDbContext dbContext)
{
dbContext.AddRange(Data.Defaults.Deposits);
dbContext.AddRange(Data.Defaults.Clusters);
dbContext.AddRange(Data.Defaults.Wells);
dbContext.AddRange(Data.Defaults.RelationsCompanyWell);
dbContext.AddRange(Data.Defaults.Telemetries);
dbContext.AddRange(Data.Defaults.Drillers);
dbContext.AddRange(Data.Defaults.WellOperations);
await dbContext.SaveChangesAsync();
}
public new async Task DisposeAsync()
public T GetAuthorizedHttpClient<T>(string uriSuffix)
{
using var scope = Services.CreateScope();
var scopedServices = scope.ServiceProvider;
var dbContext = scopedServices.GetRequiredService<AsbCloudDbContext>();
await dbContext.Database.EnsureDeletedAsync();
}
var httpClient = GetAuthorizedHttpClient();
if (string.IsNullOrEmpty(uriSuffix))
return RestService.For<T>(httpClient, RefitSettings);
public HttpClient GetAuthorizedHttpClient()
{
var httpClient = CreateClient();
var jwtToken = ApiTokenHelper.GetAdminUserToken();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", jwtToken);
return httpClient;
}
if (httpClient.BaseAddress is not null)
httpClient.BaseAddress = new Uri(httpClient.BaseAddress, uriSuffix);
public T GetAuthorizedHttpClient<T>(string uriSuffix)
{
var httpClient = GetAuthorizedHttpClient();
if (!string.IsNullOrEmpty(uriSuffix))
if(httpClient.BaseAddress is not null)
httpClient.BaseAddress = new Uri(httpClient.BaseAddress, uriSuffix);
return RestService.For<T>(httpClient, refitSettings);
}
return RestService.For<T>(httpClient, RefitSettings);
}
private HttpClient GetAuthorizedHttpClient()
{
var httpClient = CreateClient();
var jwtToken = ApiTokenHelper.GetAdminUserToken();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", jwtToken);
return httpClient;
}
}

26
AsbCloudWebApi.Tests/Services/Trajectory/TrajectoryExportTest.cs
View File

@ -6,12 +6,15 @@ using NSubstitute;
using System;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Requests.ExportOptions;
using Xunit;
namespace AsbCloudWebApi.Tests.Services.Trajectory
{
public class TrajectoryExportTest
{
private const int idWell = 4;
private IWellService wellService;
private readonly ITrajectoryEditableRepository<TrajectoryGeoPlanDto> trajectoryPlanRepository;
private readonly TrajectoryPlanExportService trajectoryPlanExportService;
@ -22,8 +25,6 @@ namespace AsbCloudWebApi.Tests.Services.Trajectory
private readonly ITrajectoryNnbRepository trajectoryFactNnbRepository;
private readonly TrajectoryFactNnbExportService trajectoryFactNnbExportService;
private readonly int idWell = 4;
private readonly TrajectoryGeoPlanDto[] trajectoryPlanRows = new TrajectoryGeoPlanDto[2] {
new TrajectoryGeoPlanDto() {
Id = 1,
@ -80,6 +81,8 @@ namespace AsbCloudWebApi.Tests.Services.Trajectory
},
};
private readonly WellRelatedExportRequest exportOptions = new(idWell);
public TrajectoryExportTest()
{
wellService = Substitute.For<IWellService>();
@ -98,10 +101,9 @@ namespace AsbCloudWebApi.Tests.Services.Trajectory
{
trajectoryPlanRepository.GetAsync(idWell, CancellationToken.None)
.Returns(trajectoryPlanRows);
var stream = await trajectoryPlanExportService.ExportAsync(idWell, CancellationToken.None);
Assert.True(stream.Length > 0);
var stream = await trajectoryPlanExportService.ExportAsync(exportOptions, CancellationToken.None);
Assert.True(stream.File.Length > 0);
}
[Fact]
@ -109,9 +111,9 @@ namespace AsbCloudWebApi.Tests.Services.Trajectory
{
trajectoryFactManualReposirory.GetAsync(idWell, CancellationToken.None)
.Returns(trajectoryFactRows);
var stream = await trajectoryFactManualExportService.ExportAsync(idWell, CancellationToken.None);
Assert.True(stream.Length > 0);
var stream = await trajectoryFactManualExportService.ExportAsync(exportOptions, CancellationToken.None);
Assert.True(stream.File.Length > 0);
}
[Fact]
@ -119,9 +121,9 @@ namespace AsbCloudWebApi.Tests.Services.Trajectory
{
trajectoryFactNnbRepository.GetAsync(idWell, CancellationToken.None)
.Returns(trajectoryFactRows);
var stream = await trajectoryFactNnbExportService.ExportAsync(idWell, CancellationToken.None);
Assert.True(stream.Length > 0);
var stream = await trajectoryFactNnbExportService.ExportAsync(exportOptions, CancellationToken.None);
Assert.True(stream.File.Length > 0);
}
}
}

11
AsbCloudWebApi.Tests/Services/Trajectory/TrajectoryParserTest.cs
View File

@ -1,7 +1,6 @@
using System.Linq;
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Requests.ParserOptions;
using AsbCloudInfrastructure.Services.Parser;
using AsbCloudInfrastructure.Services.Trajectory.Parser;
using Xunit;
@ -11,9 +10,11 @@ public class TrajectoryParserTest
{
private const string UsingTemplateFile = "AsbCloudWebApi.Tests.Services.Trajectory.Templates";
private readonly WellRelatedParserRequest options = new(1);
private readonly TrajectoryPlanParser trajectoryPlanParser = new();
private readonly TrajectoryFactManualParser trajectoryFactManualParser = new();
[Fact]
public void Parse_trajectory_plan()
{
@ -22,8 +23,8 @@ public class TrajectoryParserTest
if (stream is null)
Assert.Fail("Файла для импорта не существует");
var trajectoryRows = trajectoryPlanParser.Parse(stream, IParserOptionsRequest.Empty());
var trajectoryRows = trajectoryPlanParser.Parse(stream, options);
Assert.Equal(3, trajectoryRows.Item.Count());
}
@ -37,7 +38,7 @@ public class TrajectoryParserTest
if (stream is null)
Assert.Fail("Файла для импорта не существует");
var trajectoryRows = trajectoryFactManualParser.Parse(stream, IParserOptionsRequest.Empty());
var trajectoryRows = trajectoryFactManualParser.Parse(stream, options);
Assert.Equal(4, trajectoryRows.Item.Count());
}

337
AsbCloudWebApi.Tests/Services/WellCompositeOperation/WellCompositeOperationServiceTest.cs Normal file
View File

@ -0,0 +1,337 @@
using AsbCloudApp.Requests;
using AsbCloudDb.Model;
using AsbCloudInfrastructure.Repository;
using AsbCloudInfrastructure.Services.ProcessMaps.Report;
using AsbCloudInfrastructure.Services;
using NSubstitute;
using ProtoBuf.Meta;
using SignalRSwaggerGen.Enums;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Xunit;
using AsbCloudApp.Repositories;
using AsbCloudApp.Data;
using AsbCloudApp.Services;
namespace AsbCloudWebApi.Tests.Services.WellCompositeOperation
{
public class WellCompositeOperationServiceTest
{
private WellCompositeOperationService service;
private ICrudRepository<WellSectionTypeDto> wellSectionTypeRepository
= Substitute.For<ICrudRepository<WellSectionTypeDto>>();
private IWellOperationCategoryRepository wellOperationCategoryRepository
= Substitute.For<IWellOperationCategoryRepository>();
private IWellOperationRepository wellOperationRepository
= Substitute.For<IWellOperationRepository>();
private readonly static IEnumerable<WellOperationCategoryDto> operationCategories = new List<WellOperationCategoryDto>()
{
new(){Id = 5096, Name = "Шаблонирование перед спуском"},
new(){Id = 5008, Name = "Шаблонировка во время бурения"},
new(){Id = 5013, Name = "Подъем КНБК"},
new(){Id = 5003, Name = "Бурение ротором"},
new(){Id = 5036, Name = "Промывка"},
new(){Id = 5012, Name = "Подъем инструмента"},
new(){Id = 5083, Name = "Проработка принудительная"},
};
private readonly static IEnumerable<WellSectionTypeDto> sectionTypes = new List<WellSectionTypeDto>()
{
new() {Id = 2, Caption = "Направление", Order = 0},
new() {Id = 3, Caption = "Кондуктор", Order = 1},
new() {Id = 31, Caption = "Техническая колонна", Order = 2}
};
private readonly static IEnumerable<WellOperationDataDto> wellOperations1 = new List<WellOperationDataDto>()
{
new WellOperationDataDto()
{
DepthStart = 50,
DurationHours = 1,
IdCategory = 5096,
IdWell = 55,
IdWellSectionType = 2,
OperationCategoryName = "Шаблонирование перед спуском",
WellSectionTypeCaption = "Направление"
},
new WellOperationDataDto()
{
DepthStart = 84,
DurationHours = 1,
IdCategory = 5008,
IdWell = 64,
IdWellSectionType = 2,
OperationCategoryName = "Шаблонировка во время бурения",
WellSectionTypeCaption = "Направление"
}
};
private readonly static IEnumerable<WellOperationDataDto> wellOperations2 = new List<WellOperationDataDto>()
{
new WellOperationDataDto()
{
DepthStart = 10,
DurationHours = 1.5,
IdCategory = 5003,
IdWell = 55,
IdWellSectionType = 2,
OperationCategoryName = "Бурение ротором",
WellSectionTypeCaption = "Направление"
},
new WellOperationDataDto()
{
DepthStart = 20,
DurationHours = 3.5,
IdCategory = 5003,
IdWell = 64,
IdWellSectionType = 2,
OperationCategoryName = "Бурение ротором",
WellSectionTypeCaption = "Направление"
}
};
private readonly static IEnumerable<WellOperationDataDto> wellOperations3 = new List<WellOperationDataDto>()
{
new WellOperationDataDto()
{
DepthStart = 1372,
DurationHours = 3,
IdCategory = 5036,
IdWell = 55,
IdWellSectionType = 3,
OperationCategoryName = "Промывка",
WellSectionTypeCaption = "Кондуктор"
},
new WellOperationDataDto()
{
DepthStart = 1435,
DurationHours = 4,
IdCategory = 5036,
IdWell = 64,
IdWellSectionType = 3,
OperationCategoryName = "Промывка",
WellSectionTypeCaption = "Кондуктор"
}
};
private readonly static IEnumerable<WellOperationDataDto> wellOperations4 = new List<WellOperationDataDto>()
{
new WellOperationDataDto()
{
DepthStart = 1000,
DurationHours = 10,
IdCategory = 5012,
IdWell = 55,
IdWellSectionType = 31,
OperationCategoryName = "Подъем инструмента",
WellSectionTypeCaption = "Техническая колонна"
},
new WellOperationDataDto()
{
DepthStart = 500,
DurationHours = 5,
IdCategory = 5083,
IdWell = 55,
IdWellSectionType = 31,
OperationCategoryName = "Проработка принудительная",
WellSectionTypeCaption = "Техническая колонна"
},
new WellOperationDataDto()
{
DepthStart = 600,
DurationHours = 5,
IdCategory = 5083,
IdWell = 64,
IdWellSectionType = 31,
OperationCategoryName = "Проработка принудительная",
WellSectionTypeCaption = "Техническая колонна"
}
};
public WellCompositeOperationServiceTest()
{
wellSectionTypeRepository.GetAllAsync(Arg.Any<CancellationToken>())
.Returns(sectionTypes);
wellOperationCategoryRepository.Get(Arg.Any<bool>())
.Returns(operationCategories);
service = new WellCompositeOperationService(
wellSectionTypeRepository,
wellOperationCategoryRepository,
wellOperationRepository);
}
/// <summary>
/// На вход подаются 2 операции с одинаковыми секциями (id = 2), но разными категориями (ids = 5096, 5008) и ключами скважин (ids = 55, 64)
/// Метод возвращает список из одной операции в разрезе 3-х скважин: 2 текущие скважины и одна композитная
/// Операция должна иметь категорию 5013 для всех трех скважин
/// </summary>
/// <returns></returns>
[Fact]
public async Task GetAsync_return_composite_and_others_with_category_5013()
{
// arrange
wellOperationRepository.GetAsync(Arg.Any<WellsOperationRequest>(), Arg.Any<CancellationToken>())
.Returns(wellOperations1);
var idsWell = new List<int>() { 55, 64 };
// act
var result = await service.GetAsync(idsWell, CancellationToken.None);
// assert
var compositeWellOperation = result.SelectMany(o => o.Values.Where(o => o.IdWell == 0)).FirstOrDefault();
Assert.NotNull(compositeWellOperation);
Assert.Equal(5013, compositeWellOperation.IdCategory);
Assert.Equal(1, compositeWellOperation.DurationHours);
Assert.Equal(84, compositeWellOperation.DepthStart);
var currentWellOperations = result.SelectMany(o => o.Values.Where(o => o.IdWell != 0));
var categories = currentWellOperations.Select(o => o.IdCategory).Distinct();
Assert.NotNull(categories);
Assert.Single(categories);
Assert.Equal(5013, categories.First());
var categoryName = currentWellOperations.Select(o => o.OperationCategoryName).First();
Assert.Equal("Подъем КНБК", categoryName);
}
/// <summary>
/// На вход подаются 2 операции с одинаковыми секциями (id = 2) и категориями (id = 5003), но разными ключами скважин (ids = 55, 64)
/// Метод возвращает список из одной операции в разрезе 3-х скважин: 2 текущие скважины и одна композитная
/// Операция композитной скважины должна содержать данные той операции, которая содержит минимальный duration_hours
/// </summary>
/// <returns></returns>
[Fact]
public async Task GetAsync_return_composite_with_minimum_depth_start()
{
// arrange
wellOperationRepository.GetAsync(Arg.Any<WellsOperationRequest>(), Arg.Any<CancellationToken>())
.Returns(wellOperations2);
var idsWell = new List<int>() { 55, 64 };
// act
var result = await service.GetAsync(idsWell, CancellationToken.None);
// assert
var compositeWellOperation = result.SelectMany(o => o.Values.Where(o => o.IdWell == 0)).FirstOrDefault();
Assert.NotNull(compositeWellOperation);
Assert.Equal(5003, compositeWellOperation.IdCategory);
Assert.Equal(1.5, compositeWellOperation.DurationHours);
Assert.Equal(10, compositeWellOperation.DepthStart);
}
/// <summary>
/// На вход подаются 2 операции с одинаковыми секциями (id = 3) и категориями (id = 5036), но разными ключами скважин (ids = 55, 64)
/// Метод возвращает список из одной операции в разрезе 3-х скважин: 2 текущие скважины и одна композитная
/// Операция композитной скважины должна содержать данные той операции, которая содержит минимальный duration_hours
/// </summary>
/// <returns></returns>
[Fact]
public async Task GetAsync_return_data3()
{
// arrange
wellOperationRepository.GetAsync(Arg.Any<WellsOperationRequest>(), Arg.Any<CancellationToken>())
.Returns(wellOperations3);
var idsWell = new List<int>() { 55, 64 };
// act
var result = await service.GetAsync(idsWell, CancellationToken.None);
// assert
var compositeWellOperation = result.SelectMany(o => o.Values.Where(o => o.IdWell == 0)).FirstOrDefault();
Assert.NotNull(compositeWellOperation);
Assert.Equal(5036, compositeWellOperation.IdCategory);
Assert.Equal(3, compositeWellOperation.DurationHours);
Assert.Equal(1372, compositeWellOperation.DepthStart);
}
/// <summary>
/// На вход подаются 3 операции с одинаковыми секциями (id = 31), но разными категориями (ids = 5012, 5083) и ключами скважин (ids = 55, 64)
/// Метод возвращает список из одной операции в разрезе 3-х скважин: 2 текущие скважины и одна композитная
/// Операция композитной скважины должна содержать:
/// данные той операции, которая содержит минимальный duration_hours
/// категорию с ключом 5013
/// Операции по скважине с ключом 55 должны объединиться в одну,
/// при этом их длительность складывается, а depth_start берется минимальный из двух
/// </summary>
/// <returns></returns>
[Fact]
public async Task GetAsync_return_data4()
{
// arrange
wellOperationRepository.GetAsync(Arg.Any<WellsOperationRequest>(), Arg.Any<CancellationToken>())
.Returns(wellOperations4);
var idsWell = new List<int>() { 55, 64 };
// act
var result = await service.GetAsync(idsWell, CancellationToken.None);
// assert
var currentWellOperations = result.SelectMany(o => o.Values.Where(o => o.IdWell != 0));
var categories = currentWellOperations.Select(o => o.IdCategory).Distinct();
Assert.NotNull(categories);
Assert.Single(categories);
Assert.Equal(5013, categories.First());
var currentOperationByWell55 = currentWellOperations.Where(o => o.IdWell == 55).FirstOrDefault();
Assert.NotNull(currentOperationByWell55);
Assert.Equal(15, currentOperationByWell55.DurationHours);
Assert.Equal(500, currentOperationByWell55.DepthStart);
var categoryName = currentWellOperations.Select(o => o.OperationCategoryName).First();
Assert.Equal("Подъем КНБК", categoryName);
var compositeWellOperation = result.SelectMany(o => o.Values.Where(o => o.IdWell == 0)).FirstOrDefault();
Assert.NotNull(compositeWellOperation);
Assert.Equal(5013, compositeWellOperation.IdCategory);
Assert.Equal(5, compositeWellOperation.DurationHours);
Assert.Equal(600, compositeWellOperation.DepthStart);
}
/// <summary>
/// На вход подаются список разных операций с разными ключами скважин (ids = 55, 64)
/// Метод возвращает список из 4-х операций в разрезе 3-х скважин: 2 текущие скважины и одна композитная
/// Операция композитной скважины должна содержать глубину забоя = 1372
/// </summary>
/// <returns></returns>
[Fact]
public async Task GetAsync_return_data5()
{
// arrange
var wellOperations = new List<WellOperationDataDto>();
wellOperations.AddRange(wellOperations1);
wellOperations.AddRange(wellOperations2);
wellOperations.AddRange(wellOperations3);
wellOperations.AddRange(wellOperations4);
wellOperationRepository.GetAsync(Arg.Any<WellsOperationRequest>(), Arg.Any<CancellationToken>())
.Returns(wellOperations);
var idsWell = new List<int>() { 55, 64 };
// act
var result = await service.GetAsync(idsWell, CancellationToken.None);
// assert
Assert.Equal(4, result.Count());
var lastOperation = result.Last();
var lastOperationComposite = lastOperation[0];
Assert.Equal(1372, lastOperationComposite.DepthStart);
}
}
}

32
AsbCloudWebApi/Controllers/ProcessMaps/ProcessMapPlanBaseController.cs
View File

@ -13,9 +13,9 @@ using AsbCloudApp.Services;
using System.Linq;
using AsbCloudApp.Data;
using AsbCloudApp.Requests.ParserOptions;
using AsbCloudInfrastructure.Services.Parser;
using AsbCloudApp.Data.ProcessMaps;
using System.ComponentModel.DataAnnotations;
using AsbCloudApp.Requests.ExportOptions;
namespace AsbCloudWebApi.Controllers.ProcessMaps;
@ -30,15 +30,18 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
{
private readonly IChangeLogRepository<TDto, ProcessMapPlanBaseRequestWithWell> repository;
private readonly IWellService wellService;
private readonly ParserExcelService<TDto> parserService;
private readonly IParserService<TDto, WellRelatedParserRequest> parserService;
private readonly IExportService<WellRelatedExportRequest> processMapPlanExportService;
protected ProcessMapPlanBaseController(IChangeLogRepository<TDto, ProcessMapPlanBaseRequestWithWell> repository,
IWellService wellService,
ParserExcelService<TDto> parserService)
IParserService<TDto, WellRelatedParserRequest> parserService,
IExportService<WellRelatedExportRequest> processMapPlanExportService)
{
this.repository = repository;
this.wellService = wellService;
this.parserService = parserService;
this.processMapPlanExportService = processMapPlanExportService;
}
protected abstract string TemplateFileName { get; }
@ -213,7 +216,7 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
[ProducesResponseType(StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
public async Task<ActionResult<ParserResultDto<TDto>>> Parse(int idWell,
[Required] IFormFile file,
[Required] IFormFile file,
CancellationToken token)
{
await AssertUserHasAccessToWell(idWell, token);
@ -222,9 +225,8 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
try
{
var dto = parserService.Parse(stream, IParserOptionsRequest.Empty());
foreach (var item in dto.Item)
item.Item.IdWell = idWell;
var options = new WellRelatedParserRequest(idWell);
var dto = parserService.Parse(stream, options);
return Ok(dto);
}
@ -267,6 +269,22 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
throw new ForbidException("Нет доступа к скважине");
return idUser;
}
/// <summary>
/// Формируем excel файл с текущими строками РТК
/// </summary>
/// <param name="idWell">id скважины</param>
/// <param name="token"></param>
/// <returns>Запрашиваемый файл</returns>
[HttpGet("export")]
[ProducesResponseType(typeof(PhysicalFileResult), (int)System.Net.HttpStatusCode.OK, "application/octet-stream")]
[ProducesResponseType(StatusCodes.Status204NoContent)]
public async Task<IActionResult> ExportAsync([FromRoute] int idWell, CancellationToken token)
{
var exportOptions = new WellRelatedExportRequest(idWell);
var (fileName, file) = await processMapPlanExportService.ExportAsync(exportOptions, token);
return File(file, "application/octet-stream", fileName);
}
/// <summary>
/// returns user id or throw

6
AsbCloudWebApi/Controllers/ProcessMaps/ProcessMapPlanDrillingController.cs
View File

@ -2,6 +2,7 @@
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services.ProcessMapPlan.Export;
using AsbCloudInfrastructure.Services.ProcessMapPlan.Parser;
namespace AsbCloudWebApi.Controllers.ProcessMaps;
@ -13,8 +14,9 @@ public class ProcessMapPlanDrillingController : ProcessMapPlanBaseController<Pro
{
public ProcessMapPlanDrillingController(IChangeLogRepository<ProcessMapPlanDrillingDto, ProcessMapPlanBaseRequestWithWell> repository,
IWellService wellService,
ProcessMapPlanDrillingParser parserService)
: base(repository, wellService, parserService)
ProcessMapPlanDrillingParser parserService,
ProcessMapPlanDrillingExportService processMapPlanExportService)
: base(repository, wellService, parserService, processMapPlanExportService)
{
}

6
AsbCloudWebApi/Controllers/ProcessMaps/ProcessMapPlanReamController.cs
View File

@ -2,6 +2,7 @@
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services.ProcessMapPlan.Export;
using AsbCloudInfrastructure.Services.ProcessMapPlan.Parser;
namespace AsbCloudWebApi.Controllers.ProcessMaps;
@ -13,8 +14,9 @@ public class ProcessMapPlanReamController : ProcessMapPlanBaseController<Process
{
public ProcessMapPlanReamController(IChangeLogRepository<ProcessMapPlanReamDto, ProcessMapPlanBaseRequestWithWell> repository,
IWellService wellService,
ProcessMapPlanReamParser parserService)
: base(repository, wellService, parserService)
ProcessMapPlanReamParser parserService,
ProcessMapPlanReamExportService processMapPlanExportService)
: base(repository, wellService, parserService, processMapPlanExportService)
{
}

15
AsbCloudWebApi/Controllers/Trajectory/TrajectoryController.cs
View File

@ -1,14 +1,14 @@
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services.Trajectory.Export;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Requests.ExportOptions;
using AsbCloudInfrastructure.Services.Trajectory.Export;
namespace AsbCloudWebApi.Controllers.Trajectory
{
@ -21,13 +21,13 @@ namespace AsbCloudWebApi.Controllers.Trajectory
public abstract class TrajectoryController<TDto> : ControllerBase
where TDto : TrajectoryGeoDto
{
protected abstract string fileName { get; }
protected abstract string TemplateFileName { get; }
private readonly IWellService wellService;
private readonly TrajectoryExportService<TDto> trajectoryExportService;
private readonly ITrajectoryRepository<TDto> trajectoryRepository;
public TrajectoryController(IWellService wellService,
protected TrajectoryController(IWellService wellService,
TrajectoryExportService<TDto> trajectoryExportService,
ITrajectoryRepository<TDto> trajectoryRepository)
{
@ -50,9 +50,10 @@ namespace AsbCloudWebApi.Controllers.Trajectory
if (!await CanUserAccessToWellAsync(idWell,
token).ConfigureAwait(false))
return Forbid();
var stream = await trajectoryExportService.ExportAsync(idWell, token);
var fileName = await trajectoryExportService.GetFileNameAsync(idWell, token);
return File(stream, "application/octet-stream", fileName);
var exportOptions = new WellRelatedExportRequest(idWell);
var (fileName, file) = await trajectoryExportService.ExportAsync(exportOptions, token);
return File(file, "application/octet-stream", fileName);
}
/// <summary>

16
AsbCloudWebApi/Controllers/Trajectory/TrajectoryEditableController.cs
View File

@ -1,8 +1,6 @@
using System;
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Data.Trajectory;
using AsbCloudApp.Repositories;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services.Trajectory.Export;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
@ -12,7 +10,7 @@ using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data;
using AsbCloudApp.Requests.ParserOptions;
using AsbCloudInfrastructure.Services.Parser;
using AsbCloudInfrastructure.Services.Trajectory.Export;
namespace AsbCloudWebApi.Controllers.Trajectory
{
@ -25,11 +23,11 @@ namespace AsbCloudWebApi.Controllers.Trajectory
public abstract class TrajectoryEditableController<TDto> : TrajectoryController<TDto>
where TDto : TrajectoryGeoDto
{
private readonly ParserExcelService<TDto> parserService;
private readonly IParserService<TDto, WellRelatedParserRequest> parserService;
private readonly ITrajectoryEditableRepository<TDto> trajectoryRepository;
protected TrajectoryEditableController(IWellService wellService,
ParserExcelService<TDto> parserService,
IParserService<TDto, WellRelatedParserRequest> parserService,
TrajectoryExportService<TDto> trajectoryExportService,
ITrajectoryEditableRepository<TDto> trajectoryRepository)
: base(wellService, trajectoryExportService, trajectoryRepository)
@ -49,7 +47,7 @@ namespace AsbCloudWebApi.Controllers.Trajectory
public IActionResult GetTemplate()
{
var stream = parserService.GetTemplateFile();
return File(stream, "application/octet-stream", fileName);
return File(stream, "application/octet-stream", TemplateFileName);
}
/// <summary>
@ -78,7 +76,9 @@ namespace AsbCloudWebApi.Controllers.Trajectory
try
{
var dto = parserService.Parse(stream, IParserOptionsRequest.Empty());
var options = new WellRelatedParserRequest(idWell);
var dto = parserService.Parse(stream, options);
return Ok(dto);
}
catch (FileFormatException ex)

2
AsbCloudWebApi/Controllers/Trajectory/TrajectoryFactManualController.cs
View File

@ -14,7 +14,7 @@ namespace AsbCloudWebApi.Controllers.Trajectory;
[Route("api/well/{idWell}/[controller]")]
public class TrajectoryFactManualController : TrajectoryEditableController<TrajectoryGeoFactDto>
{
protected override string fileName => "ЕЦП_шаблон_файла_фактическая_траектория.xlsx";
protected override string TemplateFileName => "ЕЦП_шаблон_файла_фактическая_траектория.xlsx";
public TrajectoryFactManualController(IWellService wellService,
TrajectoryFactManualExportService trajectoryExportService,

2
AsbCloudWebApi/Controllers/Trajectory/TrajectoryFactNnbController.cs
View File

@ -15,7 +15,7 @@ namespace AsbCloudWebApi.Controllers.Trajectory;
[Route("api/well/{idWell}/[controller]")]
public class TrajectoryFactNnbController : TrajectoryController<TrajectoryGeoFactDto>
{
protected override string fileName => "ЕЦП_шаблон_файла_фактическая_ннб_траектория.xlsx";
protected override string TemplateFileName => "ЕЦП_шаблон_файла_фактическая_ннб_траектория.xlsx";
public TrajectoryFactNnbController(
ITrajectoryNnbRepository trajectoryNnbRepository,
TrajectoryFactNnbExportService trajectoryExportService,

2
AsbCloudWebApi/Controllers/Trajectory/TrajectoryPlanController.cs
View File

@ -20,7 +20,7 @@ namespace AsbCloudWebApi.Controllers.Trajectory
{
private readonly TrajectoryService trajectoryVisualizationService;
protected override string fileName => "ЕЦП_шаблон_файла_плановая_траектория.xlsx";
protected override string TemplateFileName => "ЕЦП_шаблон_файла_плановая_траектория.xlsx";
public TrajectoryPlanController(IWellService wellService,
TrajectoryPlanParser parserService,

51
AsbCloudWebApi/Controllers/WellCompositeOperationController.cs Normal file
View File

@ -0,0 +1,51 @@
using AsbCloudApp.Data;
using AsbCloudApp.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
namespace AsbCloudWebApi.Controllers
{
[ApiController]
[Authorize]
[Route("api/[controller]")]
public class WellCompositeOperationController : ControllerBase
{
private readonly IWellCompositeOperationService wellCompositeOperationService;
private readonly IWellService wellService;
public WellCompositeOperationController(IWellCompositeOperationService wellCompositeOperationService, IWellService wellService)
{
this.wellCompositeOperationService = wellCompositeOperationService;
this.wellService = wellService;
}
[HttpGet]
[ProducesResponseType(typeof(IList<IDictionary<int, WellOperationDataDto>>), (int)System.Net.HttpStatusCode.OK)]
public async Task<IActionResult> GetAsync([FromQuery] IEnumerable<int> idsWells, CancellationToken token)
{
foreach (var idWell in idsWells)
if (!await UserHasAccessToWellAsync(idWell, token))
return Forbid();
var result = await wellCompositeOperationService.GetAsync(idsWells, token)
.ConfigureAwait(false);
return Ok(result);
}
protected async Task<bool> UserHasAccessToWellAsync(int idWell, CancellationToken token)
{
var idCompany = User.GetCompanyId();
if (idCompany is not null &&
await wellService.IsCompanyInvolvedInWellAsync((int)idCompany, idWell, token)
.ConfigureAwait(false))
return true;
return false;
}
}
}

3
AsbCloudWebApi/Extensions.cs
View File

@ -7,10 +7,7 @@ using System.IO;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Security.Claims;
using AsbCloudApp.Data;
using AsbCloudApp.Exceptions;
using AsbCloudApp.Requests.ParserOptions;
using AsbCloudInfrastructure.Services.Parser;
using Microsoft.AspNetCore.Http;
namespace Microsoft.AspNetCore.Mvc;

5
AsbCloudWebApi/PermissionAttribute.cs
View File

@ -1,13 +1,12 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Collections.Concurrent;
namespace AsbCloudWebApi
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
public class PermissionAttribute : Attribute
{
public static SortedSet<string> Registered { get; } = new SortedSet<string>();
public static ConcurrentBag<string> Registered { get; } = new();
public string Name { get; set; } = null!;

15
AsbCloudWebApi/ProtobufModel.cs
View File

@ -5,13 +5,18 @@ namespace AsbCloudWebApi
{
public static class ProtobufModel
{
private static readonly object SyncRoot = new();
public static void EnshureRegistered()
{
EnshureRegisteredDataSpin();
EnshureRegisteredDataSaub();
EnshureRegisteredWITS();
EnshureRegisteredWirelineRunOutBaseDto();
EnshureRegisteredWirelineRunOutDto();
lock (SyncRoot)
{
EnshureRegisteredDataSpin();
EnshureRegisteredDataSaub();
EnshureRegisteredWITS();
EnshureRegisteredWirelineRunOutBaseDto();
EnshureRegisteredWirelineRunOutDto();
}
}
private static void EnshureRegisteredWirelineRunOutBaseDto()

8
AsbCloudWebApi/appsettings.Tests.json Normal file
View File

@ -0,0 +1,8 @@
{
"DbConnection": {
"Host": "localhost",
"Port": 5432,
"Username": "postgres",
"Password": "q"
}
}