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

Merge branch 'dev'

Browse Source
This commit is contained in:
ngfrolov 2024-08-12 08:45:29 +05:00
commit 22c8cf176a
Signed by untrusted user who does not match committer: ng.frolov
GPG Key ID: E99907A0357B29A7
17 changed files with 780 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AsbCloudApp/Data/User/ContactDto.cs
View File

@ -35,7 +35,7 @@ public class ContactDto : IId
/// <summary>
/// Email
/// </summary>
[RegularExpression(@"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$", ErrorMessage = "Некорректный email")]
[RegularExpression(@"^[a-zA-Z0-9_\-\.]{3,128}@[a-zA-Z0-9_\-\.]{2,128}\.[a-zA-Z]{1,32}$", ErrorMessage = "Некорректный email")]
public string? Email { get; set; }
/// <summary>

17
AsbCloudApp/Repositories/IWellOperationRepository.cs
View File

@ -34,6 +34,23 @@ namespace AsbCloudApp.Repositories
/// <returns></returns>
Task<PaginationContainer<WellOperationDto>> GetPageAsync(WellOperationRequest request, CancellationToken token);
/// <summary>
/// Получить страницу с операцией
/// </summary>
/// <param name="idWell"></param>
/// <param name="id"></param>
/// <param name="operationType"></param>
/// <param name="take"></param>
/// <param name="sortFields"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<PaginationContainer<WellOperationDto>?> GetPageAsync(int idWell,
int id,
int operationType,
int? take,
IEnumerable<string>? sortFields,
CancellationToken token);
/// <summary>
/// Получить статистику операции по скважине с группировкой по категориям
/// </summary>

20
AsbCloudApp/Requests/WellContactRequest.cs Normal file
View File

@ -0,0 +1,20 @@
using System.Collections.Generic;
namespace AsbCloudApp.Requests
{
/// <summary>
/// Запрос на получение контактов
/// </summary>
public class WellContactRequest
{
/// <summary>
/// Идентификаторы скважин
/// </summary>
public IEnumerable<int> IdsWells { get; set; } = null!;
/// <summary>
/// Ключ типа контактов
/// </summary>
public int? ContactTypeId { get; set; }
}
}

24
AsbCloudApp/Services/IDataSaubStatService.cs Normal file
View File

@ -0,0 +1,24 @@
using System;
using System.Threading;
using System.Threading.Tasks;
namespace AsbCloudApp.Services
{
/// <summary>
/// Сервис записи данных в таблицу DataSaubStat, которая используется для построения РТК-отчета
/// </summary>
public interface IDataSaubStatService
{
/// <summary>
/// Расчет статистики DataSaubStat
/// </summary>
/// <param name="lastDaysFilter">
/// Количество дней за которые должны были приходить данные, чтобы телеметрия попала в обработку.
/// </param>
/// <param name="onProgressCallback"></param>
/// <param name="token"></param>
/// <returns></returns>
Task CreateStatAsync(int lastDaysFilter, Action<string, double?> onProgressCallback, CancellationToken token);
}
}

8
AsbCloudApp/Services/IWellContactService.cs
View File

@ -1,5 +1,6 @@
using AsbCloudApp.Data;
using AsbCloudApp.Data.User;
using AsbCloudApp.Requests;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
@ -12,13 +13,12 @@ namespace AsbCloudApp.Services
public interface IWellContactService
{
/// <summary>
/// Получение контактов по ключу скважины и типу контакта
/// Получение контактов по параметрам запроса
/// </summary>
/// <param name="idWell">ключ скважины</param>
/// <param name="contactTypeId">тип контакта</param>
/// <param name="request">ключ скважины</param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<ContactDto>> GetAllAsync(int idWell, int contactTypeId, CancellationToken token);
Task<IEnumerable<ContactDto>> GetAllAsync(WellContactRequest request, CancellationToken token);
/// <summary>
/// Получение контакта по ключу

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

@ -16,7 +16,7 @@ using System.Threading.Tasks;
namespace AsbCloudInfrastructure.Background.PeriodicWorks
{
/// <summary>
/// задача по добавлению данных в таблицу DataSaubStat, которая используется дл построения РТК-отчета
/// задача по добавлению данных в таблицу DataSaubStat, которая используется для построения РТК-отчета
/// </summary>
internal class WorkDataSaubStat : Work
{
@ -29,209 +29,11 @@ namespace AsbCloudInfrastructure.Background.PeriodicWorks
protected override async Task Action(string id, IServiceProvider services, Action<string, double?> onProgressCallback, CancellationToken token)
{
var dataSaubStatService = services.GetRequiredService<IDataSaubStatService>();
var telemetryDataCache = services.GetRequiredService<ITelemetryDataCache<TelemetryDataSaubDto>>();
if (dataSaubStatService != null )
await dataSaubStatService.CreateStatAsync(Gap, onProgressCallback, token);
var cacheRequest = new TelemetryDataRequest()
{
GeDate = DateTime.UtcNow.AddDays(-Gap)
};
var idTelemetries = telemetryDataCache.GetIds(cacheRequest).ToArray();
if (!idTelemetries.Any())
return;
var dataSaubStatRepo = services.GetRequiredService<IDataSaubStatRepository>();
var dataSaubService = services.GetRequiredService<ITelemetryDataSaubService>();
var detectedOperationRepository = services.GetRequiredService<IDetectedOperationRepository>();
var stats = await dataSaubStatRepo.GetLastsAsync(idTelemetries, token);
for( var i =0; i < idTelemetries.Length; i++)
{
var idTelemetry = idTelemetries[i];
var lastDate = stats.FirstOrDefault(s => s.IdTelemetry == idTelemetry)?.DateEnd.ToUniversalTime() ?? DateTimeOffset.UnixEpoch;
var statsCount = await CreateStatForTelemetryFromDate(idTelemetry, lastDate, dataSaubService, dataSaubStatRepo, detectedOperationRepository, token);
onProgressCallback($"Calculate stat for telemetry: {idTelemetry}; from {lastDate}; results count: {statsCount};", 100*i / idTelemetries.Length);
}
}
private static async Task<int> CreateStatForTelemetryFromDate(
int idTelemetry,
DateTimeOffset begin,
ITelemetryDataSaubService dataSaubService,
IDataSaubStatRepository dataSaubStatRepo,
IDetectedOperationRepository detectedOperationRepository,
CancellationToken token)
{
var detectedOperationRequest = new DetectedOperationByTelemetryRequest {
GeDateStart = begin,
IdTelemetry = idTelemetry,
IdsCategories = WellOperationCategory.MechanicalDrillingSubIds,
SortFields = new[] {nameof(DetectedOperation.DateStart) },
Take = 250,
};
var detectedOperations = await detectedOperationRepository.Get(detectedOperationRequest, token);
if (!detectedOperations.Any())
return 0;
var geDate = detectedOperations.First().DateStart;
var leDate = detectedOperations.OrderByDescending(d => d.DateEnd).First().DateEnd;
var dataSaub = await dataSaubService.Get(idTelemetry, true, geDate, leDate, 100_000, token);
if (!dataSaub.Any())
return 0;
if(dataSaub is not TelemetryDataSaubDto[] dataSaubArray)
dataSaubArray = dataSaub.ToArray();
var dataSaubStats = CreateDataSaubStat(detectedOperations, dataSaubArray);
return await dataSaubStatRepo.InsertRangeAsync(dataSaubStats, token);
}
private static IEnumerable<DataSaubStatDto> CreateDataSaubStat(IEnumerable<DetectedOperationDto> detectedOperations, TelemetryDataSaubDto[] dataSaub)
{
var indexStart = 0;
var indexEnd = 0;
var result = new List<DataSaubStatDto>();
if (!dataSaub.Any())
return result;
foreach (var operation in detectedOperations)
{
indexStart = Array.FindIndex(dataSaub, indexEnd, t => t.DateTime >= operation.DateStart);
if (indexStart < 0)
break;
indexEnd = Array.FindIndex(dataSaub, indexStart, t => t.DateTime > operation.DateEnd);
if (indexEnd < 0)
indexEnd = dataSaub.Length - 1;
if (indexEnd == indexStart)
continue;
var length = indexEnd - indexStart;
var subset = dataSaub.AsSpan(indexStart, length);
var stats = CalcStats(operation, subset);
result.AddRange(stats);
}
return result;
}
private static IEnumerable<DataSaubStatDto> CalcStats(DetectedOperationDto operation, Span<TelemetryDataSaubDto> dataSaub)
{
var result = new List<DataSaubStatDto>();
var indexStart = 0;
for (var i = 1; i < dataSaub.Length; i++)
{
var previous = dataSaub[i - 1];
var current = dataSaub[i];
if (IsNewCacheItem(previous, current) || i == dataSaub.Length - 1)
{
var length = i - indexStart;
var span = dataSaub.Slice(indexStart, length);
indexStart = i;
if (length <= 2 || (span[^1].WellDepth - span[0].WellDepth) < 0.001)
continue; // мелкие выборки не учитываем.
var stat = CalcStat(operation, span);
result.Add(stat);
}
}
return result;
}
private static DataSaubStatDto CalcStat(DetectedOperationDto operation, Span<TelemetryDataSaubDto> span)
{
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 = dateStart,
DateEnd = dateEnd,
DepthStart = depthStart,
DepthEnd = depthEnd,
Speed = speed,
BlockSpeedSp = span[0].BlockSpeedSp,
Pressure = aggregatedValues.Pressure,
PressureIdle = span[0].PressureIdle,
PressureSp = span[0].PressureSp,
AxialLoad = aggregatedValues.AxialLoad,
AxialLoadSp = span[0].AxialLoadSp,
AxialLoadLimitMax = span[0].AxialLoadLimitMax,
RotorTorque = aggregatedValues.RotorTorque,
RotorTorqueSp = span[0].RotorTorqueSp,
RotorTorqueLimitMax = span[0].RotorTorqueLimitMax,
IdFeedRegulator = span[0].IdFeedRegulator,
RotorSpeed = aggregatedValues.RotorSpeed,
IdCategory = operation.IdCategory,
EnabledSubsystems = operation.EnabledSubsystems,
HasOscillation = operation.EnabledSubsystems.IsAutoOscillation,
IdTelemetry = operation.IdTelemetry,
Flow = aggregatedValues.Flow
};
return processMapDrillingCacheItem;
}
private static (
double Pressure,
double AxialLoad,
double RotorTorque,
double RotorSpeed,
double Flow
) CalcAggregate(Span<TelemetryDataSaubDto> span)
{
var sumPressure = 0.0;
var sumAxialLoad = 0.0;
var sumRotorTorque = 0.0;
var sumRotorSpeed = 0.0;
var flow = span[0].Flow ?? 0.0;
var diffDepthTotal = span[^1].WellDepth - span[0].WellDepth;
for (var i = 0; i < span.Length - 1; i++)
{
var diffDepth = span[i + 1].WellDepth - span[i].WellDepth;
sumPressure += diffDepth * span[i].Pressure;
sumAxialLoad += diffDepth * span[i].AxialLoad;
sumRotorTorque += diffDepth * span[i].RotorTorque;
sumRotorSpeed += diffDepth * span[i].RotorSpeed;
flow = span[i + 1].Flow > flow ? span[i + 1].Flow ?? 0.0 : flow;
}
return (
Pressure: sumPressure / diffDepthTotal,
AxialLoad: sumAxialLoad / diffDepthTotal,
RotorTorque: sumRotorTorque / diffDepthTotal,
RotorSpeed: sumRotorSpeed / diffDepthTotal,
Flow: flow
);
}
private static bool IsNewCacheItem(TelemetryDataSaubDto previous, TelemetryDataSaubDto current)
{
return !(current.Mode == previous.Mode)
|| !(current.WellDepth >= previous.WellDepth)
|| !(current.BlockSpeedSp == previous.BlockSpeedSp)
|| !(current.PressureIdle == previous.PressureIdle)
|| !(current.PressureSp == previous.PressureSp)
|| !(current.AxialLoadSp == previous.AxialLoadSp)
|| !(current.AxialLoadLimitMax == previous.AxialLoadLimitMax)
|| !(current.HookWeightIdle == previous.HookWeightIdle)
|| !(current.RotorTorqueIdle == previous.RotorTorqueIdle)
|| !(current.RotorTorqueSp == previous.RotorTorqueSp)
|| !(current.RotorTorqueLimitMax == previous.RotorTorqueLimitMax)
|| !(current.IdFeedRegulator == previous.IdFeedRegulator);
}
}
}

1
AsbCloudInfrastructure/DependencyInjection.cs
View File

@ -316,6 +316,7 @@ namespace AsbCloudInfrastructure
services.AddTransient<IHelpPageService, HelpPageService>();
services.AddTransient<IScheduleReportService, ScheduleReportService>();
services.AddTransient<IDataSaubStatRepository, DataSaubStatRepository>();
services.AddTransient<IDataSaubStatService, DataSaubStatService>();
services.AddTransient<
IChangeLogRepository<ProcessMapPlanRotorDto, ProcessMapPlanBaseRequestWithWell>,

19
AsbCloudInfrastructure/Repository/ChangeLogRepositoryAbstract.cs
View File

@ -117,6 +117,22 @@ public abstract class ChangeLogRepositoryAbstract<TEntity, TDto, TRequest> : ICh
}
public async Task<int> InsertRange(int idUser, IEnumerable<TDto> dtos, CancellationToken token)
{
using var transaction = db.Database.BeginTransaction();
try
{
var result = await InsertRangeWithoutTransaction(idUser, dtos, token);
await transaction.CommitAsync(token);
return result;
}
catch
{
await transaction.RollbackAsync(token);
throw;
}
}
private async Task<int> InsertRangeWithoutTransaction(int idUser, IEnumerable<TDto> dtos, CancellationToken token)
{
var result = 0;
if (dtos.Any())
@ -138,6 +154,7 @@ public abstract class ChangeLogRepositoryAbstract<TEntity, TDto, TRequest> : ICh
result += await SaveChangesWithExceptionHandling(token);
}
return result;
}
@ -248,7 +265,7 @@ public abstract class ChangeLogRepositoryAbstract<TEntity, TDto, TRequest> : ICh
try
{
result += await Clear(idUser, request, token);
result += await InsertRange(idUser, dtos, token);
result += await InsertRangeWithoutTransaction(idUser, dtos, token);
await transaction.CommitAsync(token);
return result;

60
AsbCloudInfrastructure/Repository/WellOperationRepository.cs
View File

@ -71,6 +71,48 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
return paginationContainer;
}
public async Task<PaginationContainer<WellOperationDto>?> GetPageAsync(int idWell,
int id,
int operationType,
int? take,
IEnumerable<string>? sortFields,
CancellationToken token)
{
var request = new WellOperationRequest(new[] { idWell })
{
OperationType = operationType,
SortFields = sortFields,
};
var (wellOperations, count) = await GetWithDaysAndNpvAsync(request, token);
var skip = 0;
take ??= 32;
while (skip < count)
{
var page = wellOperations.Skip(skip)
.Take(take.Value);
if (page.Any(x => x.Id == id))
{
var paginationContainer = new PaginationContainer<WellOperationDto>
{
Skip = skip,
Take = take.Value,
Items = page,
Count = count
};
return paginationContainer;
}
skip += take.Value;
}
return null;
}
public async Task<IEnumerable<WellGroupOpertionDto>> GetGroupOperationsStatAsync(WellOperationRequest request, CancellationToken token)
{
var query = BuildQuery(request);
@ -209,9 +251,7 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
var count = 0;
foreach (var wellOperationsWithType in groupedByWellAndType)
{
var firstWellOperation = wellOperationsWithType
.OrderBy(e => e.DateStart)
.FirstOrDefault()!;
var firstWellOperation = wellOperationsWithType.MinBy(e => e.DateStart);
var operationsWithNpt = wellOperationsWithType
.Where(o => WellOperationCategory.NonProductiveTimeSubIds.Contains(o.IdCategory));
@ -225,10 +265,12 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
if (request.Take != null)
filteredWellOperations = filteredWellOperations.Take((int)request.Take);
var timezoneOffset = wellService.GetTimezone(wellOperationsWithType.Key.IdWell).Offset;
var dtos = filteredWellOperations
.Select(entity =>
{
var dto = Convert(entity);
var dto = Convert(entity, timezoneOffset);
dto.Day = (entity.DateStart - firstWellOperation.DateStart).TotalDays;
dto.NptHours = operationsWithNpt
.Where(o => o.DateStart <= entity.DateStart)
@ -427,15 +469,11 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
return entity;
}
protected override WellOperationDto Convert(WellOperation src)
private WellOperationDto Convert(WellOperation src, TimeSpan timezoneOffset)
{
//TODO: пока такое получение TimeZone скважины, нужно исправить на Lazy
//Хоть мы и тянем данные из кэша, но от получения TimeZone в этом методе нужно избавиться, пока так
var timeZoneOffset = wellService.GetTimezone(src.IdWell).Offset;
var dto = src.Adapt<WellOperationDto>();
dto.DateStart = src.DateStart.ToOffset(timeZoneOffset);
dto.LastUpdateDate = src.LastUpdateDate.ToOffset(timeZoneOffset);
dto.DateStart = src.DateStart.ToOffset(timezoneOffset);
dto.LastUpdateDate = src.LastUpdateDate.ToOffset(timezoneOffset);
dto.OperationCategoryName = LazyWellCategories.Value.TryGetValue(src.IdCategory, out WellOperationCategoryDto? category) ? category.Name : string.Empty;
dto.WellSectionTypeCaption = LazyWellSectionTypes.Value.TryGetValue(src.IdWellSectionType, out WellSectionTypeDto? sectionType) ? sectionType.Caption : string.Empty;

237
AsbCloudInfrastructure/Services/DataSaubStatService.cs Normal file
View File

@ -0,0 +1,237 @@
using AsbCloudApp.Data;
using AsbCloudApp.Data.DetectedOperation;
using AsbCloudApp.Data.SAUB;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace AsbCloudInfrastructure.Services
{
public class DataSaubStatService : IDataSaubStatService
{
private IDataSaubStatRepository dataSaubStatRepository;
private ITelemetryDataCache<TelemetryDataSaubDto> telemetryDataCache;
private ITelemetryDataSaubService dataSaubService;
private IDetectedOperationRepository detectedOperationRepository;
public DataSaubStatService(
IDataSaubStatRepository dataSaubStatRepository,
ITelemetryDataCache<TelemetryDataSaubDto> telemetryDataCache,
ITelemetryDataSaubService dataSaubService,
IDetectedOperationRepository detectedOperationRepository)
{
this.dataSaubStatRepository = dataSaubStatRepository;
this.telemetryDataCache = telemetryDataCache;
this.dataSaubService = dataSaubService;
this.detectedOperationRepository = detectedOperationRepository;
}
public async Task CreateStatAsync(int lastDaysFilter, Action<string, double?> onProgressCallback, CancellationToken token)
{
var cacheRequest = new TelemetryDataRequest()
{
GeDate = DateTime.UtcNow.AddDays(-lastDaysFilter)
};
var idTelemetries = telemetryDataCache.GetIds(cacheRequest).ToArray();
if (!idTelemetries.Any())
return;
var stats = await dataSaubStatRepository.GetLastsAsync(idTelemetries, token);
for (var i = 0; i < idTelemetries.Length; i++)
{
var idTelemetry = idTelemetries[i];
var lastDate = stats.FirstOrDefault(s => s.IdTelemetry == idTelemetry)?.DateEnd.ToUniversalTime() ?? DateTimeOffset.UnixEpoch;
var statsCount = await CreateStatForTelemetryFromDate(idTelemetry, lastDate, token);
if(onProgressCallback != null)
onProgressCallback($"Calculate stat for telemetry: {idTelemetry}; from {lastDate}; results count: {statsCount};", 1d * i / idTelemetries.Length);
}
}
private async Task<int> CreateStatForTelemetryFromDate(
int idTelemetry,
DateTimeOffset begin,
CancellationToken token)
{
var detectedOperationRequest = new DetectedOperationByTelemetryRequest
{
GeDateStart = begin,
IdTelemetry = idTelemetry,
IdsCategories = WellOperationCategory.MechanicalDrillingSubIds,
SortFields = new[] { nameof(DetectedOperation.DateStart) },
Take = 250,
};
var detectedOperations = await detectedOperationRepository.Get(detectedOperationRequest, token);
if (!detectedOperations.Any())
return 0;
var geDate = detectedOperations.First().DateStart;
var leDate = detectedOperations.OrderByDescending(d => d.DateEnd).First().DateEnd;
var dataSaub = await dataSaubService.Get(idTelemetry, true, geDate, leDate, 100_000, token);
if (!dataSaub.Any())
return 0;
if (dataSaub is not TelemetryDataSaubDto[] dataSaubArray)
dataSaubArray = dataSaub.ToArray();
var dataSaubStats = CreateDataSaubStat(detectedOperations, dataSaubArray);
return await dataSaubStatRepository.InsertRangeAsync(dataSaubStats, token);
}
private static IEnumerable<DataSaubStatDto> CreateDataSaubStat(IEnumerable<DetectedOperationDto> detectedOperations, TelemetryDataSaubDto[] dataSaub)
{
var indexStart = 0;
var indexEnd = 0;
var result = new List<DataSaubStatDto>();
if (!dataSaub.Any())
return result;
foreach (var operation in detectedOperations)
{
indexStart = Array.FindIndex(dataSaub, indexEnd, t => t.DateTime >= operation.DateStart);
if (indexStart < 0)
break;
indexEnd = Array.FindIndex(dataSaub, indexStart, t => t.DateTime > operation.DateEnd);
if (indexEnd < 0)
indexEnd = dataSaub.Length - 1;
if (indexEnd == indexStart)
continue;
var length = indexEnd - indexStart + 1;
var subset = dataSaub.AsSpan(indexStart, length);
var stats = CalcStats(operation, subset);
result.AddRange(stats);
}
return result;
}
private static IEnumerable<DataSaubStatDto> CalcStats(DetectedOperationDto operation, Span<TelemetryDataSaubDto> dataSaub)
{
var result = new List<DataSaubStatDto>();
var indexStart = 0;
for (var i = 1; i < dataSaub.Length; i++)
{
var previous = dataSaub[i - 1];
var current = dataSaub[i];
if (IsNewCacheItem(previous, current) || i == dataSaub.Length - 1)
{
var length = i - indexStart + 1;
var span = dataSaub.Slice(indexStart, length);
indexStart = i;
if (length <= 2 || (span[^1].WellDepth - span[0].WellDepth) < 0.001)
continue; // мелкие выборки не учитываем.
var stat = CalcStat(operation, span);
result.Add(stat);
}
}
return result;
}
private static DataSaubStatDto CalcStat(DetectedOperationDto operation, Span<TelemetryDataSaubDto> span)
{
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 = dateStart,
DateEnd = dateEnd,
DepthStart = depthStart,
DepthEnd = depthEnd,
Speed = speed,
BlockSpeedSp = span[0].BlockSpeedSp,
Pressure = aggregatedValues.Pressure,
PressureIdle = span[0].PressureIdle,
PressureSp = span[0].PressureSp,
AxialLoad = aggregatedValues.AxialLoad,
AxialLoadSp = span[0].AxialLoadSp,
AxialLoadLimitMax = span[0].AxialLoadLimitMax,
RotorTorque = aggregatedValues.RotorTorque,
RotorTorqueSp = span[0].RotorTorqueSp,
RotorTorqueLimitMax = span[0].RotorTorqueLimitMax,
IdFeedRegulator = span[0].IdFeedRegulator,
RotorSpeed = aggregatedValues.RotorSpeed,
IdCategory = operation.IdCategory,
EnabledSubsystems = operation.EnabledSubsystems,
HasOscillation = operation.EnabledSubsystems.IsAutoOscillation,
IdTelemetry = operation.IdTelemetry,
Flow = aggregatedValues.Flow
};
return processMapDrillingCacheItem;
}
private static (
double Pressure,
double AxialLoad,
double RotorTorque,
double RotorSpeed,
double Flow
) CalcAggregate(Span<TelemetryDataSaubDto> span)
{
var sumPressure = 0.0;
var sumAxialLoad = 0.0;
var sumRotorTorque = 0.0;
var sumRotorSpeed = 0.0;
var flow = span[0].Flow ?? 0.0;
var diffDepthTotal = span[^1].WellDepth - span[0].WellDepth;
for (var i = 0; i < span.Length - 1; i++)
{
var diffDepth = span[i + 1].WellDepth - span[i].WellDepth;
sumPressure += diffDepth * span[i].Pressure;
sumAxialLoad += diffDepth * span[i].AxialLoad;
sumRotorTorque += diffDepth * span[i].RotorTorque;
sumRotorSpeed += diffDepth * span[i].RotorSpeed;
flow = span[i + 1].Flow > flow ? span[i + 1].Flow ?? 0.0 : flow;
}
return (
Pressure: sumPressure / diffDepthTotal,
AxialLoad: sumAxialLoad / diffDepthTotal,
RotorTorque: sumRotorTorque / diffDepthTotal,
RotorSpeed: sumRotorSpeed / diffDepthTotal,
Flow: flow
);
}
private static bool IsNewCacheItem(TelemetryDataSaubDto previous, TelemetryDataSaubDto current)
{
return !(current.Mode == previous.Mode)
|| !(current.WellDepth >= previous.WellDepth)
|| !(current.BlockSpeedSp == previous.BlockSpeedSp)
|| !(current.PressureIdle == previous.PressureIdle)
|| !(current.PressureSp == previous.PressureSp)
|| !(current.AxialLoadSp == previous.AxialLoadSp)
|| !(current.AxialLoadLimitMax == previous.AxialLoadLimitMax)
|| !(current.HookWeightIdle == previous.HookWeightIdle)
|| !(current.RotorTorqueIdle == previous.RotorTorqueIdle)
|| !(current.RotorTorqueSp == previous.RotorTorqueSp)
|| !(current.RotorTorqueLimitMax == previous.RotorTorqueLimitMax)
|| !(current.IdFeedRegulator == previous.IdFeedRegulator);
}
}
}

4
AsbCloudInfrastructure/Services/Subsystems/SubsystemService.cs
View File

@ -157,8 +157,8 @@ internal class SubsystemService : ISubsystemService
SumDepthInterval = sumDepthInterval,
OperationCount = operationCount,
};
oscillationStat.KUsage = oscillationStat.SumDepthInterval / oscillationStat.SumOperationDepthInterval;
if(oscillationStat.SumOperationDepthInterval != 0d)
oscillationStat.KUsage = oscillationStat.SumDepthInterval / oscillationStat.SumOperationDepthInterval;
return oscillationStat;
}

16
AsbCloudInfrastructure/Services/WellContactService.cs
View File

@ -1,6 +1,7 @@
using AsbCloudApp.Data;
using AsbCloudApp.Data.User;
using AsbCloudApp.Exceptions;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using Mapster;
@ -21,17 +22,22 @@ namespace AsbCloudInfrastructure.Services
this.db = db;
}
public async Task<IEnumerable<ContactDto>> GetAllAsync(int wellId, int contactTypeId, CancellationToken token)
public async Task<IEnumerable<ContactDto>> GetAllAsync(WellContactRequest request, CancellationToken token)
{
var query = db.Contacts
.Where(c => c.IdCompanyType == contactTypeId)
.Where(c => c.IdWell == wellId)
.Select(c => c.Adapt<ContactDto>());
.Where(c => request.IdsWells.Contains(c.IdWell));
if (request.ContactTypeId.HasValue)
{
query = query.Where(c => c.IdCompanyType == request.ContactTypeId);
};
var entities = await query.AsNoTracking()
.ToArrayAsync(token);
return entities;
var dtos = entities.Select(c => c.Adapt<ContactDto>());
return dtos;
}
public async Task<ContactDto?> GetAsync(int idWell, int id, CancellationToken token)

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

Binary file not shown.

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

Binary file not shown.

323
AsbCloudWebApi.Tests/Services/DataSaubStatServiceTest.cs Normal file
View File

@ -0,0 +1,323 @@
using AsbCloudApp.Data;
using AsbCloudApp.Data.DetectedOperation;
using AsbCloudApp.Data.SAUB;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudInfrastructure.Services;
using Mapster;
using NSubstitute;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Xunit;
namespace AsbCloudWebApi.Tests.Services;
public class DataSaubStatServiceTest
{
private readonly int Gap = 5;
private readonly IDataSaubStatRepository dataSaubStatRepositoryMock = Substitute.For<IDataSaubStatRepository>();
private readonly ITelemetryDataCache<TelemetryDataSaubDto> telemetryDataCacheMock = Substitute.For<ITelemetryDataCache<TelemetryDataSaubDto>>();
private readonly IDetectedOperationRepository detectedOperationRepositoryMock = Substitute.For<IDetectedOperationRepository>();
private readonly ITelemetryDataSaubService dataSaubServiceMock = Substitute.For<ITelemetryDataSaubService>();
private DataSaubStatService dataSaubStatService;
private int[] idTelemetries = [1];
private IEnumerable<DataSaubStatDto> dataSaubStatDtos = new List<DataSaubStatDto>()
{
new DataSaubStatDto {
Id = 1,
AxialLoad = 1,
AxialLoadLimitMax = 1,
AxialLoadSp = 1,
BlockSpeedSp = 1,
DateEnd = DateTime.UtcNow,
DateStart = DateTime.UtcNow.AddHours(-1),
DepthEnd = 2,
DepthStart = 1,
EnabledSubsystems = 1,
Flow = 1,
HasOscillation = true,
IdCategory = 1,
IdFeedRegulator = 1,
IdTelemetry = 1,
Pressure = 1,
PressureIdle = 1,
PressureSp = 1,
RotorSpeed = 1,
RotorTorque = 1,
RotorTorqueLimitMax = 1,
RotorTorqueSp = 1,
Speed = 1
},
new DataSaubStatDto {
Id = 2,
AxialLoad = 2,
AxialLoadLimitMax = 2,
AxialLoadSp = 2,
BlockSpeedSp = 2,
DateEnd = DateTime.UtcNow,
DateStart = DateTime.UtcNow.AddHours(-1),
DepthEnd = 3,
DepthStart = 2,
EnabledSubsystems = 2,
Flow = 2,
HasOscillation = true,
IdCategory = 2,
IdFeedRegulator = 2,
IdTelemetry = 2,
Pressure = 2,
PressureIdle = 2,
PressureSp = 2,
RotorSpeed = 2,
RotorTorque = 2,
RotorTorqueLimitMax = 2,
RotorTorqueSp = 2,
Speed = 2
},
new DataSaubStatDto {
Id = 3,
AxialLoad = 3,
AxialLoadLimitMax = 3,
AxialLoadSp = 3,
BlockSpeedSp = 3,
DateEnd = DateTime.UtcNow,
DateStart = DateTime.UtcNow.AddHours(-1),
DepthEnd = 4,
DepthStart = 3,
EnabledSubsystems = 3,
Flow = 3,
HasOscillation = true,
IdCategory = 3,
IdFeedRegulator = 3,
IdTelemetry = 3,
Pressure = 3,
PressureIdle = 3,
PressureSp = 3,
RotorSpeed = 3,
RotorTorque = 3,
RotorTorqueLimitMax = 3,
RotorTorqueSp = 3,
Speed = 3
},
};
private List<DetectedOperationDto> detectedOperationDtos = new List<DetectedOperationDto>() {
new DetectedOperationDto {
Id = 1,
DateEnd = DateTimeOffset.UtcNow,
DateStart = DateTimeOffset.UtcNow.AddHours(-1),
DepthStart = 1,
DepthEnd = 2,
IdCategory = 5002,
IdTelemetry = 1,
Value = 1,
IdEditor = 1,
IdUserAtStart = 1
}
};
private List<TelemetryDataSaubDto> telemetryDataSaubDtos = new List<TelemetryDataSaubDto> {
new TelemetryDataSaubDto()
{
IdTelemetry = 1,
DateTime = DateTime.UtcNow.AddMinutes(-30),
AxialLoad = 1,
AxialLoadLimitMax = 1,
AxialLoadSp = 1,
BitDepth = 1,
BlockPosition = 1,
BlockPositionMax = 1,
BlockPositionMin = 1,
BlockSpeed = 1,
BlockSpeedSp = 1,
BlockSpeedSpDevelop = 1,
BlockSpeedSpRotor = 1,
BlockSpeedSpSlide = 1,
Flow = 1,
FlowDeltaLimitMax = 1,
FlowIdle = 1,
HookWeight = 1,
HookWeightIdle = 1,
HookWeightLimitMax = 1,
HookWeightLimitMin = 1,
IdFeedRegulator = 1,
IdUser = 1,
Mode = 1,
Mse = 1,
MseState = 1,
Pressure = 1,
PressureDeltaLimitMax = 1,
PressureIdle = 1,
PressureSp = 1,
PressureSpDevelop = 1,
PressureSpRotor = 1,
PressureSpSlide = 1,
Pump0Flow = 1,
Pump1Flow = 1,
Pump2Flow = 1,
RotorSpeed = 1,
RotorTorque = 1,
RotorTorqueIdle = 1,
RotorTorqueSp = 1,
RotorTorqueLimitMax = 1,
WellDepth = 10,
}
};
public DataSaubStatServiceTest()
{
telemetryDataCacheMock
.GetIds(Arg.Any<TelemetryDataRequest>())
.Returns(idTelemetries);
dataSaubStatRepositoryMock
.GetLastsAsync(Arg.Any<int[]>(), Arg.Any<CancellationToken>())
.Returns(dataSaubStatDtos);
var telemetrySaubDto = telemetryDataSaubDtos.FirstOrDefault();
if (telemetrySaubDto != null)
{
//заполнение списка телеметрий следующим образом:
// - всего в списке 6 элементов:
// - все они попадают в диапазон, определенный датами DateStart и DateEnd соответствующей записи detectedOperation
// - из этих 6-х записей у 2-х записей меняется параметр,
// являющийся признаком начала нового интервала (новой записи dataSaubStat)
// таким образом, в базе данных должно создаться 1 новая запись dataSaubStat (insertedDataSaubStatCount = 1)
var telemetrySaubDto1 = telemetrySaubDto.Adapt<TelemetryDataSaubDto>();
telemetrySaubDto1.DateTime = DateTime.UtcNow.AddMinutes(-20);
telemetryDataSaubDtos.Add(telemetrySaubDto1);
var telemetrySaubDto2 = telemetrySaubDto.Adapt<TelemetryDataSaubDto>();
telemetrySaubDto2.DateTime = DateTime.UtcNow.AddMinutes(-10);
telemetrySaubDto2.RotorTorqueLimitMax = 2;
telemetryDataSaubDtos.Add(telemetrySaubDto2);
var telemetrySaubDto3 = telemetrySaubDto.Adapt<TelemetryDataSaubDto>();
telemetrySaubDto3.DateTime = DateTime.UtcNow.AddMinutes(-8);
telemetrySaubDto3.RotorTorqueLimitMax = 2;
telemetryDataSaubDtos.Add(telemetrySaubDto3);
var telemetrySaubDto4 = telemetrySaubDto.Adapt<TelemetryDataSaubDto>();
telemetrySaubDto4.DateTime = DateTime.UtcNow.AddMinutes(-6);
telemetrySaubDto4.RotorTorqueLimitMax = 2;
telemetryDataSaubDtos.Add(telemetrySaubDto4);
var telemetrySaubDto5 = telemetrySaubDto.Adapt<TelemetryDataSaubDto>();
telemetrySaubDto5.DateTime = DateTime.UtcNow.AddMinutes(-4);
telemetrySaubDto5.RotorTorqueLimitMax = 2;
telemetryDataSaubDtos.Add(telemetrySaubDto5);
var telemetrySaubDto6 = telemetrySaubDto.Adapt<TelemetryDataSaubDto>();
telemetrySaubDto6.DateTime = DateTime.UtcNow.AddMinutes(-2);
telemetrySaubDto6.RotorTorqueLimitMax = 3;
telemetrySaubDto6.WellDepth = 11;
telemetryDataSaubDtos.Add(telemetrySaubDto6);
}
dataSaubServiceMock
.Get(Arg.Any<int>(), Arg.Any<bool>(), Arg.Any<DateTimeOffset>(), Arg.Any<DateTimeOffset>(), Arg.Any<int>(), Arg.Any<CancellationToken>())
.Returns(telemetryDataSaubDtos);
dataSaubStatService = new DataSaubStatService(
dataSaubStatRepositoryMock,
telemetryDataCacheMock,
dataSaubServiceMock,
detectedOperationRepositoryMock);
}
[Fact]
public async Task Create_1DataSaubStatItems_ShouldReturn__Success()
{
var insertedDataSaubStatCount = 1;
detectedOperationRepositoryMock
.Get(Arg.Any<DetectedOperationByTelemetryRequest>(), Arg.Any<CancellationToken>())
.Returns(detectedOperationDtos);
dataSaubStatRepositoryMock
.InsertRangeAsync(Arg.Any<IEnumerable<DataSaubStatDto>>(), Arg.Any<CancellationToken>())
.Returns(insertedDataSaubStatCount);
Action<string, double?> action = (message, percent) =>
{
//assert
Assert.NotNull(percent);
Assert.InRange(percent.Value, 0.0, 1.0);
};
//act
await dataSaubStatService.CreateStatAsync(Gap, action, CancellationToken.None);
//assert
await dataSaubStatRepositoryMock.Received().InsertRangeAsync(
Arg.Is<IEnumerable<DataSaubStatDto>>(l => l.Count() == insertedDataSaubStatCount),
Arg.Any<CancellationToken>());
}
[Fact]
public async Task Create_2DataSaubStatItems_ShouldReturn__Success()
{
var insertedDataSaubStatCount = 2;
var detectedOperationDto = detectedOperationDtos.FirstOrDefault();
if (detectedOperationDto != null)
{
var detectedOperationDto1 = detectedOperationDto.Adapt<DetectedOperationDto>();
detectedOperationDto1.DateStart = DateTimeOffset.UtcNow.AddMinutes(1);
detectedOperationDto1.DateEnd = DateTimeOffset.UtcNow.AddHours(1);
detectedOperationDtos.Add(detectedOperationDto1);
}
var telemetryDataSaubDto = telemetryDataSaubDtos.LastOrDefault();
if (telemetryDataSaubDto != null)
{
var telemetryDataSaubDto1 = telemetryDataSaubDto.Adapt<TelemetryDataSaubDto>();
telemetryDataSaubDto1.DateTime = DateTime.UtcNow.AddMinutes(10);
telemetryDataSaubDto1.WellDepth = telemetryDataSaubDto.WellDepth + 1;
var telemetryDataSaubDto2 = telemetryDataSaubDto.Adapt<TelemetryDataSaubDto>();
telemetryDataSaubDto2.DateTime = DateTime.UtcNow.AddMinutes(20);
telemetryDataSaubDto2.WellDepth = telemetryDataSaubDto1.WellDepth + 1;
var telemetryDataSaubDto3 = telemetryDataSaubDto.Adapt<TelemetryDataSaubDto>();
telemetryDataSaubDto3.DateTime = DateTime.UtcNow.AddMinutes(30);
telemetryDataSaubDto3.WellDepth = telemetryDataSaubDto2.WellDepth + 1;
telemetryDataSaubDtos.Add(telemetryDataSaubDto1);
telemetryDataSaubDtos.Add(telemetryDataSaubDto2);
telemetryDataSaubDtos.Add(telemetryDataSaubDto3);
}
detectedOperationRepositoryMock
.Get(Arg.Any<DetectedOperationByTelemetryRequest>(), Arg.Any<CancellationToken>())
.Returns(detectedOperationDtos);
dataSaubStatRepositoryMock
.InsertRangeAsync(Arg.Any<IEnumerable<DataSaubStatDto>>(), Arg.Any<CancellationToken>())
.Returns(insertedDataSaubStatCount);
Action<string, double?> action = (message, percent) =>
{
//assert
Assert.NotNull(percent);
Assert.InRange(percent.Value, 0.0, 1.0);
};
//act
await dataSaubStatService.CreateStatAsync(Gap, action, CancellationToken.None);
//assert
await dataSaubStatRepositoryMock.Received().InsertRangeAsync(
Arg.Is<IEnumerable<DataSaubStatDto>>(l => l.Count() == insertedDataSaubStatCount),
Arg.Any<CancellationToken>());
}
}

36
AsbCloudWebApi/Controllers/WellContactController.cs
View File

@ -1,5 +1,6 @@
using AsbCloudApp.Data;
using AsbCloudApp.Data.User;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using Microsoft.AspNetCore.Authorization;
@ -49,12 +50,43 @@ namespace AsbCloudWebApi.Controllers
/// <returns></returns>
[HttpGet("type/{contactTypeId}")]
[ProducesResponseType(typeof(IEnumerable<ContactDto>), (int)System.Net.HttpStatusCode.OK)]
public async Task<IActionResult> GetAllAsync(int idWell, int contactTypeId, CancellationToken token)
public async Task<IActionResult> GetByTypeAsync(int idWell, int contactTypeId, CancellationToken token)
{
if (!await CanUserAccessToWellAsync(idWell, token).ConfigureAwait(false))
return Forbid();
var result = await wellContactsRepository.GetAllAsync(idWell, contactTypeId, token);
var request = new WellContactRequest()
{
IdsWells = new int[] { idWell },
ContactTypeId = contactTypeId
};
var result = await wellContactsRepository.GetAllAsync(request, token);
return Ok(result);
}
/// <summary>
/// Получение контактов по массиву ключей скважины
/// </summary>
/// <param name="idsWells">ключи скважин</param>
/// <param name="token"></param>
/// <returns></returns>
[HttpGet("/api/well/[controller]")]
[ProducesResponseType(typeof(IEnumerable<ContactDto>), (int)System.Net.HttpStatusCode.OK)]
public async Task<IActionResult> GetAllAsync([FromQuery] IEnumerable<int> idsWells, CancellationToken token)
{
foreach(var idWell in idsWells)
{
if (!await CanUserAccessToWellAsync(idWell, token).ConfigureAwait(false))
return Forbid();
}
var request = new WellContactRequest()
{
IdsWells = idsWells
};
var result = await wellContactsRepository.GetAllAsync(request, token);
return Ok(result);
}

33
AsbCloudWebApi/Controllers/WellOperationController.cs
View File

@ -187,7 +187,7 @@ public class WellOperationController : ControllerBase
[HttpGet]
[Permission]
[ProducesResponseType(typeof(PaginationContainer<WellOperationDto>), StatusCodes.Status200OK)]
public async Task<IActionResult> GetPageOperationsAsync(
public async Task<IActionResult> GetPageAsync(
[FromRoute] int idWell,
[FromQuery] WellOperationRequestBase request,
CancellationToken token)
@ -201,6 +201,37 @@ public class WellOperationController : ControllerBase
return Ok(result);
}
/// <summary>
/// Получение страницу с нужной операцией
/// </summary>
/// <param name="idWell">id скважины</param>
/// <param name="id">id операции</param>
/// <param name="operationType">тип получаемых операций</param>
/// <param name="take">кол-во записей на странице</param>
/// <param name="sortFields">параметры сортировки страниц</param>
/// <param name="token"></param>
/// <returns></returns>
[HttpGet("getPageWithOperation")]
[Permission]
[ProducesResponseType(typeof(PaginationContainer<WellOperationDto>), StatusCodes.Status200OK)]
public async Task<IActionResult> GetPageWithOperationAsync([FromRoute] int idWell,
int id,
int operationType,
int? take,
[FromQuery] IEnumerable<string>? sortFields,
CancellationToken token)
{
if (!await CanUserAccessToWellAsync(idWell, token))
return Forbid();
var paginationContainer = await wellOperationRepository.GetPageAsync(idWell, id, operationType, take, sortFields, token);
if (paginationContainer == null)
return NoContent();
return Ok(paginationContainer);
}
/// <summary>
/// Создает excel файл с "сетевым графиком"
/// </summary>