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

#28835068 Сводная таблица по наработке по -бурильщикам

Browse Source
This commit is contained in:
Егор Тиунов 2024-02-20 16:58:40 +05:00
parent 32b95c80ac
commit ea8352f4de
8 changed files with 320 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
AsbCloudApp/Data/CompanyDto.cs
View File

@ -1,7 +1,4 @@
using System.Collections.Generic; using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using AsbCloudApp.Data.User;
namespace AsbCloudApp.Data namespace AsbCloudApp.Data
{ {

12
AsbCloudApp/Data/DrillerDetectedOperationStatDto.cs Normal file
View File

@ -0,0 +1,12 @@
using System.Collections.Generic;
using AsbCloudApp.Data.Subsystems;
namespace AsbCloudApp.Data;
public record DrillerDetectedOperationStatDto
{
public DrillerDto driller;
public IEnumerable<SubsystemStatDto> statistic;
public ScheduleDto schedule;
public IEnumerable<WellDto> well;
}

9
AsbCloudApp/Requests/GetStatRequest.cs Normal file
View File

@ -0,0 +1,9 @@
using System.Collections.Generic;
namespace AsbCloudApp.Requests;
public class GetStatRequest: RequestBase
{
public IEnumerable<int> idWell;
public int? idDriller;
}

9
AsbCloudApp/Services/IScheduleService.cs
View File

@ -3,6 +3,7 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using AsbCloudApp.Requests;
namespace AsbCloudApp.Services namespace AsbCloudApp.Services
{ {
@ -28,5 +29,13 @@ namespace AsbCloudApp.Services
/// <param name="token"></param> /// <param name="token"></param>
/// <returns></returns> /// <returns></returns>
Task<DrillerDto?> GetOrDefaultDrillerAsync(int idWell, DateTime workTime, CancellationToken token); Task<DrillerDto?> GetOrDefaultDrillerAsync(int idWell, DateTime workTime, CancellationToken token);
/// <summary>
/// Получить расписание смен
/// </summary>
/// <param name="request"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<ScheduleDto>> GetPageAsync(GetStatRequest request, CancellationToken token);
} }
} }

4
AsbCloudApp/Services/ISubsystemService.cs
View File

@ -4,6 +4,7 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using AsbCloudApp.Data;
namespace AsbCloudApp.Services; namespace AsbCloudApp.Services;
@ -27,4 +28,7 @@ public interface ISubsystemService
/// <param name="token"></param> /// <param name="token"></param>
/// <returns></returns> /// <returns></returns>
Task<IEnumerable<SubsystemActiveWellStatDto>> GetStatByActiveWells(IEnumerable<int> wellIds, CancellationToken token); Task<IEnumerable<SubsystemActiveWellStatDto>> GetStatByActiveWells(IEnumerable<int> wellIds, CancellationToken token);
Task<IEnumerable<DrillerDetectedOperationStatDto>> GetByWellsAsync(GetStatRequest request,
CancellationToken token);
} }

16
AsbCloudInfrastructure/Repository/ScheduleRepository.cs
View File

@ -7,6 +7,7 @@ using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using AsbCloudApp.Requests;
using Mapster; using Mapster;
namespace AsbCloudInfrastructure.Repository namespace AsbCloudInfrastructure.Repository
@ -53,6 +54,21 @@ namespace AsbCloudInfrastructure.Repository
return entity?.Driller.Adapt<DrillerDto>(); return entity?.Driller.Adapt<DrillerDto>();
} }
public async Task<IEnumerable<ScheduleDto>> GetPageAsync(GetStatRequest request, CancellationToken token)
{
var idWell = request.idWell;
var idDriller = request.idDriller;
var query = GetQuery().Where(s => request.idWell.Contains(s.IdWell));
if (idDriller is not null)
{
query.Where(s => s.IdDriller == idDriller);
}
var result = await query.ToArrayAsync(token);
return result.Select(Convert);
}
private IQueryable<Schedule> BuildQuery(int idWell, DateTime workTime) private IQueryable<Schedule> BuildQuery(int idWell, DateTime workTime)
{ {
var hoursOffset = wellService.GetTimezone(idWell).Hours; var hoursOffset = wellService.GetTimezone(idWell).Hours;

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

@ -1,245 +1,309 @@
using AsbCloudApp.Data; using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data;
using AsbCloudApp.Data.DetectedOperation; using AsbCloudApp.Data.DetectedOperation;
using AsbCloudApp.Data.Subsystems; using AsbCloudApp.Data.Subsystems;
using AsbCloudApp.Exceptions; using AsbCloudApp.Exceptions;
using AsbCloudApp.Requests; using AsbCloudApp.Requests;
using AsbCloudApp.Services; using AsbCloudApp.Services;
using AsbCloudDb.Model; using AsbCloudDb.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudInfrastructure.Services.DetectOperations; using AsbCloudInfrastructure.Services.DetectOperations;
namespace AsbCloudInfrastructure.Services.Subsystems; namespace AsbCloudInfrastructure.Services.Subsystems;
internal class SubsystemService : ISubsystemService internal class SubsystemService : ISubsystemService
{ {
private const int IdSubsystemAPD = 1; private const int IdSubsystemAPD = 1;
private const int IdSubsystemAPDRotor = 11; private const int IdSubsystemAPDRotor = 11;
private const int IdSubsystemAPDSlide = 12; private const int IdSubsystemAPDSlide = 12;
private const int IdSubsystemOscillation = 65536; private const int IdSubsystemOscillation = 65536;
private readonly ICrudRepository<SubsystemDto> subsystemRepository; private readonly ICrudRepository<SubsystemDto> subsystemRepository;
private readonly IWellService wellService; private readonly IWellService wellService;
private readonly IDetectedOperationService detectedOperationService; private readonly IDetectedOperationService detectedOperationService;
private readonly IScheduleRepository scheduleRepository;
private IDictionary<int, SubsystemDto> subsystems = new Dictionary<int, SubsystemDto>(); private IDictionary<int, SubsystemDto> subsystems = new Dictionary<int, SubsystemDto>();
public SubsystemService(ICrudRepository<SubsystemDto> subsystemRepository, public SubsystemService(ICrudRepository<SubsystemDto> subsystemRepository,
IWellService wellService, IWellService wellService,
IDetectedOperationService detectedOperationService) IDetectedOperationService detectedOperationService,
{ IScheduleRepository scheduleRepository)
this.wellService = wellService; {
this.subsystemRepository = subsystemRepository; this.wellService = wellService;
this.detectedOperationService = detectedOperationService; this.subsystemRepository = subsystemRepository;
} this.detectedOperationService = detectedOperationService;
this.scheduleRepository = scheduleRepository;
}
public async Task<IEnumerable<SubsystemStatDto>> GetStatAsync(SubsystemRequest request, CancellationToken token) // получить расписания бурильщиков по скважинам // ScheduleRepository добавить новый метод
{ // [
var well = await wellService.GetOrDefaultAsync(request.IdWell, token) // get telemetryId by idWell // IWellService.GetOrDefaultStatAsync
?? throw new ArgumentInvalidException(nameof(request.IdWell), $"Well Id: {request.IdWell} does not exist"); // получить detectedOperation by telemetry //detectedOperationService.GetOperationsAsync
// сгруппировать по бурильщикам
// [
// рассчитать статистику // CalcStatAsync
// join driller from group
// ]
// join well (cluster, deposit)
// ]
public async Task<IEnumerable<DrillerDetectedOperationStatDto>> GetByWellsAsync(GetStatRequest request,
CancellationToken token)
{
var result = new List<DrillerDetectedOperationStatDto>();
var schedulePage = await scheduleRepository.GetPageAsync(request, token);
var wellTree = await wellService.GetAsync(new WellRequest { Ids = request.idWell }, token);
var wellGroup = wellTree.GroupBy(w => w.Id);
if(!well.IdTelemetry.HasValue) foreach (var schedule in schedulePage)
return Enumerable.Empty<SubsystemStatDto>();
var detectedOperationSummaryRequest = new DetectedOperationByWellRequest
{ {
IdWell = request.IdWell, var idWell = schedule.IdWell;
IdsCategories = WellOperationCategory.MechanicalDrillingSubIds, var well = wellGroup?.FirstOrDefault(w=> w.Key == idWell);
GeDateStart = request.GeDate, var byWellRequest = new DetectedOperationByWellRequest(idWell, new DetectedOperationRequest());
LeDateEnd = request.LeDate,
GeDepthStart = request.GeDepth, var detectedOperations = await detectedOperationService
LeDepthEnd = request.LeDepth, .GetOperationsAsync(byWellRequest, token);
};
var operations = await detectedOperationService.GetOperationsAsync(detectedOperationSummaryRequest, var groupByDriller = detectedOperations
token); .Where(operation => operation.Driller is not null)
.GroupBy(operation => operation.Driller);
if (request.IdDriller.HasValue) foreach (var entry in groupByDriller)
operations = operations.Where(o => o.Driller is not null && o.Driller.Id == request.IdDriller.Value); {
var drillerOperationsStat = await CalcStatAsync(entry, token);
var dto = new DrillerDetectedOperationStatDto
{
driller = entry.Key!,
statistic = drillerOperationsStat,
schedule = schedule,
well = well!
};
result.Add(dto);
}
}
if (!operations.Any()) return await Task.FromResult(result);
return Enumerable.Empty<SubsystemStatDto>(); }
var stat = await CalcStatAsync(operations, token); public async Task<IEnumerable<SubsystemStatDto>> GetStatAsync(SubsystemRequest request, CancellationToken token)
return stat; {
} var well = await wellService.GetOrDefaultAsync(request.IdWell, token)
?? throw new ArgumentInvalidException(nameof(request.IdWell),
$"Well Id: {request.IdWell} does not exist");
public async Task<IEnumerable<SubsystemActiveWellStatDto>> GetStatByActiveWells(IEnumerable<int> wellIds, CancellationToken token) if (!well.IdTelemetry.HasValue)
{ return Enumerable.Empty<SubsystemStatDto>();
var activeWells = await wellService.GetAsync(new() { Ids = wellIds, IdState = 1 }, token);
var result = await GetStatAsync(activeWells, null, null, token);
return result;
}
private async Task<IEnumerable<SubsystemStatDto>> CalcStatAsync(IEnumerable<DetectedOperationWithDrillerDto> operations, CancellationToken token) var detectedOperationSummaryRequest = new DetectedOperationByWellRequest
{ {
if (!subsystems.Any()) IdWell = request.IdWell,
subsystems = (await subsystemRepository.GetAllAsync(token)).ToDictionary(s => s.Id, s => s); IdsCategories = WellOperationCategory.MechanicalDrillingSubIds,
var oscillationStat = CalcOscillationStat(operations); GeDateStart = request.GeDate,
var apdStat = CalcApdStat(operations); LeDateEnd = request.LeDate,
var stat = new List<SubsystemStatDto> { oscillationStat }; GeDepthStart = request.GeDepth,
stat.AddRange(apdStat); LeDepthEnd = request.LeDepth,
};
return stat; var operations = await detectedOperationService.GetOperationsAsync(detectedOperationSummaryRequest,
} token);
private SubsystemStatDto CalcOscillationStat(IEnumerable<DetectedOperationWithDrillerDto> operations) if (request.IdDriller.HasValue)
{ operations = operations.Where(o => o.Driller is not null && o.Driller.Id == request.IdDriller.Value);
operations = operations.Where(o => o.IdCategory == WellOperationCategory.IdSlide);
var (sumDepthInterval, usedTimeHours, operationCount) = AggregateOperations(IdSubsystemOscillation, operations); if (!operations.Any())
return Enumerable.Empty<SubsystemStatDto>();
var oscillationStat = new SubsystemStatDto var stat = await CalcStatAsync(operations, token);
{ return stat;
IdSubsystem = IdSubsystemOscillation, }
SubsystemName = subsystems.TryGetValue(IdSubsystemOscillation, out var subsystemDto) ? subsystemDto.Name : "unknown",
UsedTimeHours = usedTimeHours,
SumOperationDepthInterval = operations.Sum(o => o.DepthEnd - o.DepthStart),
SumOperationDurationHours = operations.Sum(o => o.DurationMinutes / 60),
SumDepthInterval = sumDepthInterval,
OperationCount = operationCount,
};
oscillationStat.KUsage = oscillationStat.SumDepthInterval / oscillationStat.SumOperationDepthInterval; public async Task<IEnumerable<SubsystemActiveWellStatDto>> GetStatByActiveWells(IEnumerable<int> wellIds,
CancellationToken token)
{
var activeWells = await wellService.GetAsync(new() { Ids = wellIds, IdState = 1 }, token);
var result = await GetStatAsync(activeWells, null, null, token);
return result;
}
return oscillationStat; private async Task<IEnumerable<SubsystemStatDto>> CalcStatAsync(
} IEnumerable<DetectedOperationWithDrillerDto> operations, CancellationToken token)
{
if (!subsystems.Any())
subsystems = (await subsystemRepository.GetAllAsync(token)).ToDictionary(s => s.Id, s => s);
private IEnumerable<SubsystemStatDto> CalcApdStat(IEnumerable<DetectedOperationWithDrillerDto> operations) var oscillationStat = CalcOscillationStat(operations);
{ var apdStat = CalcApdStat(operations);
var apdRotorAndSlide = operations
.Where(o => WellOperationCategory.MechanicalDrillingSubIds.Contains(o.IdCategory))
.GroupBy(o => o.IdCategory)
.Select(group =>
{
var idSubsystem = group.Key switch
{
WellOperationCategory.IdRotor => IdSubsystemAPDRotor,
WellOperationCategory.IdSlide => IdSubsystemAPDSlide,
_ => throw new ArgumentException($"IdCategory: {group.Key} does not supported in this method", nameof(group.Key))
};
var (sumDepthInterval, usedTimeHours, operationCount) = AggregateOperations(idSubsystem, group); var stat = new List<SubsystemStatDto> { oscillationStat };
stat.AddRange(apdStat);
var subsystemStat = new SubsystemStatDto return stat;
{ }
IdSubsystem = idSubsystem,
SubsystemName = subsystems.TryGetValue(idSubsystem, out var subsystemDto) ? subsystemDto.Name : "unknown",
UsedTimeHours = usedTimeHours,
SumOperationDepthInterval = group.Sum(o => o.DepthEnd - o.DepthStart),
SumOperationDurationHours = group.Sum(o => o.DurationMinutes / 60),
SumDepthInterval = sumDepthInterval,
OperationCount = operationCount,
};
subsystemStat.KUsage = subsystemStat.SumDepthInterval / subsystemStat.SumOperationDepthInterval; private SubsystemStatDto CalcOscillationStat(IEnumerable<DetectedOperationWithDrillerDto> operations)
{
operations = operations.Where(o => o.IdCategory == WellOperationCategory.IdSlide);
return subsystemStat; var (sumDepthInterval, usedTimeHours, operationCount) = AggregateOperations(IdSubsystemOscillation, operations);
});
if (!apdRotorAndSlide.Any()) var oscillationStat = new SubsystemStatDto
return Enumerable.Empty<SubsystemStatDto>(); {
IdSubsystem = IdSubsystemOscillation,
SubsystemName = subsystems.TryGetValue(IdSubsystemOscillation, out var subsystemDto)
? subsystemDto.Name
: "unknown",
UsedTimeHours = usedTimeHours,
SumOperationDepthInterval = operations.Sum(o => o.DepthEnd - o.DepthStart),
SumOperationDurationHours = operations.Sum(o => o.DurationMinutes / 60),
SumDepthInterval = sumDepthInterval,
OperationCount = operationCount,
};
var apdSum = new SubsystemStatDto oscillationStat.KUsage = oscillationStat.SumDepthInterval / oscillationStat.SumOperationDepthInterval;
{
IdSubsystem = IdSubsystemAPD,
SubsystemName = subsystems.TryGetValue(IdSubsystemAPD, out var subsystemDto) ? subsystemDto.Name : "unknown",
UsedTimeHours = apdRotorAndSlide.Sum(part => part.UsedTimeHours),
SumOperationDepthInterval = apdRotorAndSlide.Sum(part => part.SumOperationDepthInterval),
SumOperationDurationHours = apdRotorAndSlide.Sum(part => part.SumOperationDurationHours),
SumDepthInterval = apdRotorAndSlide.Sum(part => part.SumDepthInterval),
OperationCount = apdRotorAndSlide.Sum(part => part.OperationCount),
};
apdSum.KUsage = apdSum.SumDepthInterval / apdSum.SumOperationDepthInterval; return oscillationStat;
}
var apdStat = new List<SubsystemStatDto> { apdSum }; private IEnumerable<SubsystemStatDto> CalcApdStat(IEnumerable<DetectedOperationWithDrillerDto> operations)
apdStat.AddRange(apdRotorAndSlide); {
var apdRotorAndSlide = operations
.Where(o => WellOperationCategory.MechanicalDrillingSubIds.Contains(o.IdCategory))
.GroupBy(o => o.IdCategory)
.Select(group =>
{
var idSubsystem = group.Key switch
{
WellOperationCategory.IdRotor => IdSubsystemAPDRotor,
WellOperationCategory.IdSlide => IdSubsystemAPDSlide,
_ => throw new ArgumentException($"IdCategory: {group.Key} does not supported in this method",
nameof(group.Key))
};
return apdStat; var (sumDepthInterval, usedTimeHours, operationCount) = AggregateOperations(idSubsystem, group);
}
private static (double SumDepthInterval, double UsedTimeHours, int Count) AggregateOperations(int idSubsystem, var subsystemStat = new SubsystemStatDto
IEnumerable<DetectedOperationWithDrillerDto> operations) => {
idSubsystem switch IdSubsystem = idSubsystem,
{ SubsystemName = subsystems.TryGetValue(idSubsystem, out var subsystemDto)
IdSubsystemAPDRotor => CalcOperationsByEnableSubsystems(operations, EnabledSubsystemsFlags.AutoRotor), ? subsystemDto.Name
IdSubsystemAPDSlide => CalcOperationsByEnableSubsystems(operations, : "unknown",
EnabledSubsystemsFlags.AutoSlide | EnabledSubsystemsFlags.AutoOscillation), UsedTimeHours = usedTimeHours,
IdSubsystemOscillation => CalcOperationsByEnableSubsystems(operations, EnabledSubsystemsFlags.AutoOscillation), SumOperationDepthInterval = group.Sum(o => o.DepthEnd - o.DepthStart),
_ => throw new ArgumentException($"IdSubsystem: {idSubsystem} does not supported in this method", nameof(idSubsystem)) SumOperationDurationHours = group.Sum(o => o.DurationMinutes / 60),
}; SumDepthInterval = sumDepthInterval,
OperationCount = operationCount,
};
private static (double SumDepthInterval, double UsedTimeHours, int OperationCount) CalcOperationsByEnableSubsystems( subsystemStat.KUsage = subsystemStat.SumDepthInterval / subsystemStat.SumOperationDepthInterval;
IEnumerable<DetectedOperationWithDrillerDto> operations,
EnabledSubsystemsFlags enabledSubsystems)
{
var filtered = operations.Where(o => enabledSubsystems.HasEnabledSubsystems(o.EnabledSubsystems));
var sumDepthInterval = filtered.Sum(o => o.DepthEnd - o.DepthStart); return subsystemStat;
var usedTimeHours = filtered.Sum(o => o.DurationMinutes / 60); });
var operationCount = filtered.Count();
return (sumDepthInterval, usedTimeHours, operationCount); if (!apdRotorAndSlide.Any())
} return Enumerable.Empty<SubsystemStatDto>();
private async Task<IEnumerable<SubsystemActiveWellStatDto>> GetStatAsync(IEnumerable<WellDto> wells, var apdSum = new SubsystemStatDto
DateTime? geDate, {
DateTime? leDate, IdSubsystem = IdSubsystemAPD,
CancellationToken token) SubsystemName =
{ subsystems.TryGetValue(IdSubsystemAPD, out var subsystemDto) ? subsystemDto.Name : "unknown",
if (!wells.Any()) UsedTimeHours = apdRotorAndSlide.Sum(part => part.UsedTimeHours),
return Enumerable.Empty<SubsystemActiveWellStatDto>(); SumOperationDepthInterval = apdRotorAndSlide.Sum(part => part.SumOperationDepthInterval),
SumOperationDurationHours = apdRotorAndSlide.Sum(part => part.SumOperationDurationHours),
SumDepthInterval = apdRotorAndSlide.Sum(part => part.SumDepthInterval),
OperationCount = apdRotorAndSlide.Sum(part => part.OperationCount),
};
var idsTelemetries = wells apdSum.KUsage = apdSum.SumDepthInterval / apdSum.SumOperationDepthInterval;
.Where(w => w.IdTelemetry is not null)
.Select(w => w.IdTelemetry!.Value)
.Distinct();
var wellsStat = new List<SubsystemActiveWellStatDto>(); var apdStat = new List<SubsystemStatDto> { apdSum };
apdStat.AddRange(apdRotorAndSlide);
foreach (var well in wells) return apdStat;
{ }
var hoursOffset = well.Timezone.Hours;
var geDateStartUtc = geDate?.ToUtcDateTimeOffset(hoursOffset); private static (double SumDepthInterval, double UsedTimeHours, int Count) AggregateOperations(int idSubsystem,
IEnumerable<DetectedOperationWithDrillerDto> operations) =>
idSubsystem switch
{
IdSubsystemAPDRotor => CalcOperationsByEnableSubsystems(operations, EnabledSubsystemsFlags.AutoRotor),
IdSubsystemAPDSlide => CalcOperationsByEnableSubsystems(operations,
EnabledSubsystemsFlags.AutoSlide | EnabledSubsystemsFlags.AutoOscillation),
IdSubsystemOscillation => CalcOperationsByEnableSubsystems(operations,
EnabledSubsystemsFlags.AutoOscillation),
_ => throw new ArgumentException($"IdSubsystem: {idSubsystem} does not supported in this method",
nameof(idSubsystem))
};
var leDateUtc = leDate?.ToUtcDateTimeOffset(hoursOffset); private static (double SumDepthInterval, double UsedTimeHours, int OperationCount) CalcOperationsByEnableSubsystems(
IEnumerable<DetectedOperationWithDrillerDto> operations,
EnabledSubsystemsFlags enabledSubsystems)
{
var filtered = operations.Where(o => enabledSubsystems.HasEnabledSubsystems(o.EnabledSubsystems));
var request = new DetectedOperationByWellRequest var sumDepthInterval = filtered.Sum(o => o.DepthEnd - o.DepthStart);
{ var usedTimeHours = filtered.Sum(o => o.DurationMinutes / 60);
IdWell = well.Id, var operationCount = filtered.Count();
IdsCategories = WellOperationCategory.MechanicalDrillingSubIds,
GeDateStart = geDateStartUtc,
LeDateEnd = leDateUtc,
};
var telemetryOperations = await detectedOperationService return (sumDepthInterval, usedTimeHours, operationCount);
.GetOperationsAsync(request, token); }
var wellStat = new SubsystemActiveWellStatDto { Well = well }; private async Task<IEnumerable<SubsystemActiveWellStatDto>> GetStatAsync(IEnumerable<WellDto> wells,
DateTime? geDate,
DateTime? leDate,
CancellationToken token)
{
if (!wells.Any())
return Enumerable.Empty<SubsystemActiveWellStatDto>();
if (!telemetryOperations.Any()) var idsTelemetries = wells
continue; .Where(w => w.IdTelemetry is not null)
.Select(w => w.IdTelemetry!.Value)
.Distinct();
var subsystemStat = await CalcStatAsync(telemetryOperations, token); var wellsStat = new List<SubsystemActiveWellStatDto>();
if (!subsystemStat.Any()) foreach (var well in wells)
continue; {
var hoursOffset = well.Timezone.Hours;
wellStat.SubsystemAPD = subsystemStat.FirstOrDefault(s => s.IdSubsystem == IdSubsystemAPD); var geDateStartUtc = geDate?.ToUtcDateTimeOffset(hoursOffset);
wellStat.SubsystemOscillation = subsystemStat.FirstOrDefault(s => s.IdSubsystem == IdSubsystemOscillation);
wellsStat.Add(wellStat);
}
return wellsStat; var leDateUtc = leDate?.ToUtcDateTimeOffset(hoursOffset);
}
var request = new DetectedOperationByWellRequest
{
IdWell = well.Id,
IdsCategories = WellOperationCategory.MechanicalDrillingSubIds,
GeDateStart = geDateStartUtc,
LeDateEnd = leDateUtc,
};
var telemetryOperations = await detectedOperationService
.GetOperationsAsync(request, token);
var wellStat = new SubsystemActiveWellStatDto { Well = well };
if (!telemetryOperations.Any())
continue;
var subsystemStat = await CalcStatAsync(telemetryOperations, token);
if (!subsystemStat.Any())
continue;
wellStat.SubsystemAPD = subsystemStat.FirstOrDefault(s => s.IdSubsystem == IdSubsystemAPD);
wellStat.SubsystemOscillation = subsystemStat.FirstOrDefault(s => s.IdSubsystem == IdSubsystemOscillation);
wellsStat.Add(wellStat);
}
return wellsStat;
}
} }

14
AsbCloudWebApi/Controllers/Subsystems/SubsystemController.cs
View File

@ -32,6 +32,7 @@ namespace AsbCloudWebApi.Controllers.Subsystems
this.wellService = wellService; this.wellService = wellService;
this.telemetryDataSaubService = telemetryDataSaubService; this.telemetryDataSaubService = telemetryDataSaubService;
} }
/// <summary> /// <summary>
/// получить статистику /// получить статистику
/// </summary> /// </summary>
@ -61,6 +62,19 @@ namespace AsbCloudWebApi.Controllers.Subsystems
return Ok(dateRange); return Ok(dateRange);
} }
[HttpGet("operationsReport/{idWell}")]
[ProducesResponseType(typeof(DrillerDetectedOperationStatDto), (int)System.Net.HttpStatusCode.OK)]
public async Task<IActionResult> GetStatDateRangeAsync([FromRoute] int idWell, GetStatRequest request,
CancellationToken token)
{
if (!await UserHasAccessToWellAsync(idWell, token))
return Forbid();
var result = await subsystemService.GetByWellsAsync(request, token);
return Ok(result);
}
private async Task<bool> UserHasAccessToWellAsync(int idWell, CancellationToken token) private async Task<bool> UserHasAccessToWellAsync(int idWell, CancellationToken token)
{ {
var idCompany = User.GetCompanyId(); var idCompany = User.GetCompanyId();