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

Merge branch 'dev' into feature/27526736-cache-table

Browse Source
This commit is contained in:
on.nemtina 2024-01-31 16:16:21 +05:00
commit 24f3b7c11c
16 changed files with 559 additions and 354 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
AsbCloudApp/Repositories/IChangeLogRepository.cs
View File

@ -1,15 +1,18 @@
using System.Collections.Generic;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data;
using AsbCloudApp.Requests;
namespace AsbCloudApp.Repositories;
/// <summary>
/// Репозиторий для записей с историей
/// </summary>
public interface IChangeLogRepository<T>
where T : ChangeLogAbstract
public interface IChangeLogRepository<TDto, TRequest>
where TDto : ChangeLogAbstract
where TRequest : ChangeLogBaseRequest
{
/// <summary>
/// Добавление записей
@ -18,7 +21,7 @@ public interface IChangeLogRepository<T>
/// <param name="dtos"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<int> InsertRange(int idUser, IEnumerable<T> dtos, CancellationToken token);
Task<int> InsertRange(int idUser, IEnumerable<TDto> dtos, CancellationToken token);
/// <summary>
/// Редактирование записей
@ -27,7 +30,35 @@ public interface IChangeLogRepository<T>
/// <param name="dtos"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<int> UpdateRange(int idUser, IEnumerable<T> dtos, CancellationToken token);
Task<int> UpdateRange(int idUser, IEnumerable<TDto> dtos, CancellationToken token);
/// <summary>
/// Добавляет Dto у которых id == 0, изменяет dto у которых id != 0
/// </summary>
/// <param name="idUser"></param>
/// <param name="dtos"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<int> UpdateOrInsertRange(int idUser, IEnumerable<TDto> dtos, CancellationToken token);
/// <summary>
/// Добавление записей с удалением старых (для импорта)
/// </summary>
/// <param name="idUser"></param>
/// <param name="request"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<int> Clear(int idUser, TRequest request, CancellationToken token);
/// <summary>
/// Очистить и добавить новые
/// </summary>
/// <param name="idUser"></param>
/// <param name="request"></param>
/// <param name="dtos"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<int> ClearAndInsertRange(int idUser, TRequest request, IEnumerable<TDto> dtos, CancellationToken token);
/// <summary>
/// Удаление записей
@ -38,4 +69,30 @@ public interface IChangeLogRepository<T>
/// <returns></returns>
Task<int> DeleteRange(int idUser, IEnumerable<int> ids, CancellationToken token);
/// <summary>
/// Получение дат изменений записей
/// </summary>
/// <param name="request"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<DateOnly>> GetDatesChange(TRequest request, CancellationToken token);
/// <summary>
/// Получение журнала изменений
/// </summary>
/// <param name="request"></param>
/// <param name="date">Фильтр по дате. Если null - вернет все</param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<TDto>> GetChangeLog(TRequest request, DateOnly? date, CancellationToken token);
/// <summary>
/// Получение записей по параметрам
/// </summary>
/// <param name="request"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<TDto>> Get(TRequest request, CancellationToken token);
}

52
AsbCloudApp/Repositories/IProcessMapPlanBaseRepository.cs
View File

@ -1,52 +0,0 @@
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data.ProcessMapPlan;
using AsbCloudApp.Requests;
namespace AsbCloudApp.Repositories;
/// <summary>
/// Общий интерфейс для РТК план с учетом истории изменений
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IProcessMapPlanBaseRepository<T>: IChangeLogRepository<T>
where T: ProcessMapPlanBaseDto
{
/// <summary>
/// Добавление записей с удалением старых (для импорта)
/// </summary>
/// <param name="idUser"></param>
/// <param name="idWell"></param>
/// <param name="dtos"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<int> ClearAndInsertRange(int idUser, int idWell, IEnumerable<T> dtos, CancellationToken token);
/// <summary>
/// Получение дат изменений записей
/// </summary>
/// <param name="idWell"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<DateOnly>> GetDatesChange(int idWell, CancellationToken token);
/// <summary>
/// Получение журнала изменений
/// </summary>
/// <param name="idWell"></param>
/// <param name="date"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<T>> GetChangeLog(int idWell, DateOnly? date, CancellationToken token);
/// <summary>
/// Получение записей по параметрам
/// </summary>
/// <param name="idWell"></param>
/// <param name="request"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<T>> Get(int idWell, ProcessMapPlanBaseRequest request, CancellationToken token);
}

2
AsbCloudApp/Repositories/IProcessMapPlanRepository.cs
View File

@ -4,12 +4,14 @@ using System.Threading;
using AsbCloudApp.Data.ProcessMaps;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using System;
namespace AsbCloudApp.Repositories;
/// <summary>
/// РТК план
/// </summary>
[Obsolete]
public interface IProcessMapPlanRepository<TDto> : IRepositoryWellRelated<TDto>
where TDto : ProcessMapPlanBaseDto
{

33
AsbCloudApp/Requests/ProcessMapPlanBaseRequest.cs
View File

@ -19,3 +19,36 @@ public class ProcessMapPlanBaseRequest: ChangeLogBaseRequest
/// </summary>
public DateTimeOffset? UpdateFrom { get; set; }
}
/// <summary>
/// Запрос для получения РТК план по скважине
/// </summary>
public class ProcessMapPlanBaseRequestWithWell: ProcessMapPlanBaseRequest
{
/// <summary>
/// Запрос для получения РТК план по скважине
/// </summary>
/// <param name="idWell"></param>
public ProcessMapPlanBaseRequestWithWell(int idWell)
{
IdWell = idWell;
}
/// <summary>
/// Запрос для получения РТК план по скважине
/// </summary>
/// <param name="request"></param>
/// <param name="idWell"></param>
public ProcessMapPlanBaseRequestWithWell(ProcessMapPlanBaseRequest request, int idWell)
{
IdWell=idWell;
IdWellSectionType=request.IdWellSectionType;
UpdateFrom = request.UpdateFrom;
Moment = request.Moment;
}
/// <summary>
/// Id скважины
/// </summary>
public int IdWell { get; set; }
}

2
AsbCloudDb/Model/ChangeLogAbstract.cs
View File

@ -28,7 +28,7 @@ public abstract class ChangeLogAbstract
/// <summary>
/// Очищено при импорте
/// </summary>
public const int IdClearedOnImport = 3;
public const int IdCleared = 3;
/// <summary>
/// Ид записи

1
AsbCloudInfrastructure/AsbCloudInfrastructure.csproj
View File

@ -55,6 +55,7 @@
<PackageReference Include="CliWrap" Version="3.6.6" />
<PackageReference Include="ClosedXML" Version="0.97.0" />
<PackageReference Include="itext7" Version="8.0.2" />
<PackageReference Include="itext7.bouncy-castle-adapter" Version="8.0.2" />
<PackageReference Include="Mapster" Version="7.4.0" />
<PackageReference Include="Microsoft.AspNetCore.Http.Extensions" Version="2.1.21" />
<PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />

9
AsbCloudInfrastructure/DependencyInjection.cs
View File

@ -45,6 +45,7 @@ using AsbCloudDb.Model.DailyReports.Blocks.TimeBalance;
using AsbCloudDb.Model.WellSections;
using AsbCloudInfrastructure.Services.ProcessMaps;
using AsbCloudApp.Data.ProcessMapPlan;
using AsbCloudApp.Requests;
namespace AsbCloudInfrastructure
{
@ -195,10 +196,10 @@ namespace AsbCloudInfrastructure
services.AddTransient<IOperationsStatService, OperationsStatService>();
services.AddTransient<IReportService, ReportService>();
services.AddTransient<ISetpointsService, SetpointsService>();
services.AddTransient<ITelemetryService, TelemetryService>();
services.AddScoped<ITelemetryService, TelemetryService>();
services.AddTransient<ITelemetryUserService, TelemetryUserService>();
services.AddTransient<ITimezoneService, TimezoneService>();
services.AddTransient<IWellService, WellService>();
services.AddScoped<IWellService, WellService>();
services.AddTransient<IWellOperationImportService, WellOperationImportService>();
services.AddTransient<IProcessMapReportWellDrillingExportService, ProcessMapReportWellDrillingExportService>();
services.AddTransient<TrajectoryPlanExportService>();
@ -222,7 +223,9 @@ namespace AsbCloudInfrastructure
services.AddTransient<IHelpPageService, HelpPageService>();
services.AddTransient<IScheduleReportService, ScheduleReportService>();
services.AddTransient<IProcessMapPlanBaseRepository<ProcessMapPlanDrillingDto>, ProcessMapPlanBaseRepository<ProcessMapPlanDrillingDto, ProcessMapPlanDrilling>>();
services.AddTransient<
IChangeLogRepository<ProcessMapPlanDrillingDto, ProcessMapPlanBaseRequestWithWell>,
ProcessMapPlanBaseRepository<ProcessMapPlanDrillingDto, ProcessMapPlanDrilling>>();
services.AddTransient<TrajectoryService>();

288
AsbCloudInfrastructure/Repository/ChangeLogRepositoryAbstract.cs Normal file
View File

@ -0,0 +1,288 @@
using AsbCloudApp.Exceptions;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudDb.Model;
using Mapster;
using Microsoft.EntityFrameworkCore;
using Npgsql;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace AsbCloudInfrastructure.Repository;
public abstract class ChangeLogRepositoryAbstract<TDto, TEntity, TRequest> : IChangeLogRepository<TDto, TRequest>
where TDto : AsbCloudApp.Data.ChangeLogAbstract
where TEntity : ChangeLogAbstract
where TRequest : ChangeLogBaseRequest
{
protected readonly IAsbCloudDbContext context;
public ChangeLogRepositoryAbstract(IAsbCloudDbContext context)
{
this.context = context;
}
public async Task<int> InsertRange(int idUser, IEnumerable<TDto> dtos, CancellationToken token)
{
var result = 0;
if (dtos.Any())
{
var entities = dtos.Select(Convert);
var creation = DateTimeOffset.UtcNow;
var dbSet = context.Set<TEntity>();
foreach (var entity in entities)
{
entity.Id = default;
entity.IdAuthor = idUser;
entity.Creation = creation;
entity.IdState = ChangeLogAbstract.IdStateActual;
entity.IdEditor = null;
entity.IdPrevious = null;
entity.Obsolete = null;
dbSet.Add(entity);
}
result += await SaveChangesWithExceptionHandling(token);
}
return result;
}
public async Task<int> UpdateRange(int idUser, IEnumerable<TDto> dtos, CancellationToken token)
{
if (dtos.Any(d => d.Id == 0))
throw new ArgumentInvalidException(nameof(dtos), "Отредактированные значения должны иметь id не 0");
if (!dtos.Any())
return 0;
var updateTime = DateTimeOffset.UtcNow;
var ids = dtos.Select(d => d.Id);
using var transaction = context.Database.BeginTransaction();
var result = 0;
var dbSet = context
.Set<TEntity>();
var entitiesToDelete = await dbSet
.Where(e => e.Obsolete == null)
.Where(e => ids.Contains(e.Id))
.ToArrayAsync(token);
var entitiesNotFound = dtos.Where(d => !entitiesToDelete.Any(e => e.Id == d.Id));
if (entitiesNotFound.Any())
{
var notFoundIds = entitiesNotFound.Select(e => e.Id);
var stringnotFoundIds = string.Join(", ", notFoundIds);
throw new ArgumentInvalidException(nameof(dtos), $"записи с id:[{stringnotFoundIds}] не найдены, или не актуальны.");
}
foreach (var entity in entitiesToDelete)
{
entity.IdState = ChangeLogAbstract.IdStateReplaced;
entity.Obsolete = updateTime;
entity.IdEditor = idUser;
}
result += await context.SaveChangesAsync(token);
var entitiesNew = dtos.Select(Convert);
foreach (var entity in entitiesNew)
{
entity.IdPrevious = entity.Id;
entity.Id = default;
entity.Creation = updateTime;
entity.IdAuthor = idUser;
entity.Obsolete = null;
entity.IdEditor = null;
entity.IdState = ChangeLogAbstract.IdStateActual;
dbSet.Add(entity);
}
result += await SaveChangesWithExceptionHandling(token);
await transaction.CommitAsync(token);
return result;
}
public async Task<int> UpdateOrInsertRange(int idUser, IEnumerable<TDto> dtos, CancellationToken token)
{
var itemsToInsert = dtos.Where(e => e.Id == 0);
var itemsToUpdate = dtos.Where(e => e.Id != 0);
var result = 0;
if (itemsToInsert.Any())
result += await InsertRange(idUser, itemsToInsert, token);
if (itemsToUpdate.Any())
result += await UpdateRange(idUser, itemsToUpdate, token);
return result;
}
public async Task<int> Clear(int idUser, TRequest request, CancellationToken token)
{
var updateTime = DateTimeOffset.UtcNow;
var query = BuildQuery(request);
query = query.Where(e => e.Obsolete == null);
var entitiesToDelete = await query.ToArrayAsync(token);
foreach (var entity in entitiesToDelete)
{
entity.IdState = ChangeLogAbstract.IdCleared;
entity.Obsolete = updateTime;
entity.IdEditor = idUser;
}
var result = await SaveChangesWithExceptionHandling(token);
return result;
}
public async Task<int> ClearAndInsertRange(int idUser, TRequest request, IEnumerable<TDto> dtos, CancellationToken token)
{
var result = 0;
var transaction = await context.Database.BeginTransactionAsync(token);
result += await Clear(idUser, request, token);
result += await InsertRange(idUser, dtos, token);
await transaction.CommitAsync(token);
return result;
}
public async Task<int> DeleteRange(int idUser, IEnumerable<int> ids, CancellationToken token)
{
var updateTime = DateTimeOffset.UtcNow;
var query = context.Set<TEntity>()
.Where(e => ids.Contains(e.Id))
.Where(e => e.Obsolete == null);
var entitiesToDelete = await query.ToArrayAsync(token);
foreach (var entity in entitiesToDelete)
{
entity.IdState = ChangeLogAbstract.IdStateDeleted;
entity.Obsolete = updateTime;
entity.IdEditor = idUser;
}
var result = await SaveChangesWithExceptionHandling(token);
return result;
}
public async Task<IEnumerable<DateOnly>> GetDatesChange(TRequest request, CancellationToken token)
{
var query = BuildQuery(request);
var datesCreateQuery = query
.Select(e => e.Creation)
.Distinct();
var datesCreate = await datesCreateQuery.ToArrayAsync(token);
var datesUpdateQuery = query
.Where(e => e.Obsolete != null)
.Select(e => e.Obsolete!.Value)
.Distinct();
var datesUpdate = await datesUpdateQuery.ToArrayAsync(token);
TimeSpan offset = GetTimezoneOffset(request);
var dates = Enumerable.Concat(datesCreate, datesUpdate);
dates = dates.Select(date => date.ToOffset(offset));
var datesOnly = dates
.Select(d => new DateOnly(d.Year, d.Month, d.Day))
.Distinct()
.OrderBy(d => d);
return datesOnly;
}
public async Task<IEnumerable<TDto>> GetChangeLog(TRequest request, DateOnly? date, CancellationToken token)
{
var query = BuildQuery(request);
TimeSpan offset = GetTimezoneOffset(request);
if (date.HasValue)
{
var min = new DateTimeOffset(date.Value.Year, date.Value.Month, date.Value.Day, 0, 0, 0, offset).ToUniversalTime();
var max = min.AddDays(1);
var createdQuery = query.Where(e => e.Creation >= min && e.Creation <= max);
var editedQuery = query.Where(e => e.Obsolete != null && e.Obsolete >= min && e.Obsolete <= max);
query = createdQuery.Union(editedQuery);
}
var entities = await query
.OrderBy(e => e.Creation)
.ThenBy(e => e.Obsolete)
.ThenBy(e => e.Id)
.ToListAsync(token);
var dtos = entities.Select(e => Convert(e, offset));
return dtos;
}
public async Task<IEnumerable<TDto>> Get(TRequest request, CancellationToken token)
{
var query = BuildQuery(request);
var entities = await query
.OrderBy(e => e.Creation)
.ThenBy(e => e.Obsolete)
.ThenBy(e => e.Id)
.ToArrayAsync(token);
TimeSpan offset = GetTimezoneOffset(request);
var dtos = entities.Select(e => Convert(e, offset));
return dtos;
}
protected abstract TimeSpan GetTimezoneOffset(TRequest request);
protected abstract IQueryable<TEntity> BuildQuery(TRequest request);
protected virtual TEntity Convert(TDto dto)
{
var entity = dto.Adapt<TEntity>();
entity.Creation = entity.Creation.ToUniversalTime();
if(entity.Obsolete.HasValue)
entity.Obsolete = entity.Obsolete.Value.ToUniversalTime();
return entity;
}
protected virtual TDto Convert(TEntity entity, TimeSpan offset)
{
var dto = entity.Adapt<TDto>();
dto.Creation = entity.Creation.ToOffset(offset);
if (entity.Obsolete.HasValue)
dto.Obsolete = entity.Obsolete.Value.ToOffset(offset);
return dto;
}
private async Task<int> SaveChangesWithExceptionHandling(CancellationToken token)
{
try
{
var result = await context.SaveChangesAsync(token);
return result;
}
catch (DbUpdateException ex)
{
if (ex.InnerException is PostgresException pgException)
TryConvertPostgresExceptionToValidateException(pgException);
throw;
}
}
private static void TryConvertPostgresExceptionToValidateException(PostgresException pgException)
{
if (pgException.SqlState == PostgresErrorCodes.ForeignKeyViolation)
throw new ArgumentInvalidException("dtos", pgException.Message + "\r\n" + pgException.Detail);
}
}

242
AsbCloudInfrastructure/Repository/ProcessMapPlanBaseRepository.cs
View File

@ -1,115 +1,36 @@
using AsbCloudApp.Data.ProcessMapPlan;
using AsbCloudApp.Exceptions;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using AsbCloudDb.Model.ProcessMapPlan;
using AsbCloudDb.Model.WellSections;
using Mapster;
using Microsoft.EntityFrameworkCore;
using Npgsql;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace AsbCloudInfrastructure.Repository;
public class ProcessMapPlanBaseRepository<TDto, TEntity> : IProcessMapPlanBaseRepository<TDto>
public class ProcessMapPlanBaseRepository<TDto, TEntity> : ChangeLogRepositoryAbstract<TDto, TEntity, ProcessMapPlanBaseRequestWithWell>
where TDto : ProcessMapPlanBaseDto
where TEntity : ProcessMapPlanBase
{
private readonly IAsbCloudDbContext context;
private readonly IWellService wellService;
public ProcessMapPlanBaseRepository(IAsbCloudDbContext context, IWellService wellService)
: base(context)
{
this.context = context;
this.wellService = wellService;
}
public async Task<int> InsertRange(int idUser, IEnumerable<TDto> dtos, CancellationToken token)
protected override IQueryable<TEntity> BuildQuery(ProcessMapPlanBaseRequestWithWell request)
{
var result = 0;
if (dtos.Any())
{
var entities = dtos.Select(Convert);
var creation = DateTimeOffset.UtcNow;
var dbSet = context.Set<TEntity>();
foreach (var entity in entities) {
entity.Id = default;
entity.IdAuthor = idUser;
entity.Creation = creation;
entity.IdState = ChangeLogAbstract.IdStateActual;
entity.IdEditor = null;
entity.Editor = null;
entity.IdPrevious = null;
entity.Obsolete = null;
dbSet.Add(entity);
}
result += await SaveChangesWithExceptionHandling(token);
}
return result;
}
public async Task<int> ClearAndInsertRange(int idUser, int idWell, IEnumerable<TDto> dtos, CancellationToken token)
{
if (dtos.Any(d => d.IdWell != idWell))
throw new ArgumentInvalidException(nameof(dtos), $"Все записи должны относиться к скважине idWell = {idWell}");
using var transaction = context.Database.BeginTransaction();
var result = 0;
var dbSet = context.Set<TEntity>();
var entitiesToMarkDeleted = dbSet
.Where(e => e.IdWell == idWell)
.Where(e => e.Obsolete == null);
var obsolete = DateTimeOffset.UtcNow;
foreach (var entity in entitiesToMarkDeleted)
{
entity.IdState = ChangeLogAbstract.IdClearedOnImport;
entity.Obsolete = obsolete;
entity.IdEditor = idUser;
}
result += await SaveChangesWithExceptionHandling(token);
result += await InsertRange(idUser, dtos, token);
await transaction.CommitAsync(token);
return result;
}
public async Task<int> DeleteRange(int idUser, IEnumerable<int> ids, CancellationToken token)
{
var dbSet = context.Set<TEntity>();
var entitiesToMarkDeleted = dbSet
.Where(e => ids.Contains(e.Id))
.Where(e => e.Obsolete == null);
var obsolete = DateTimeOffset.UtcNow;
foreach (var entity in entitiesToMarkDeleted)
{
entity.IdState = ChangeLogAbstract.IdStateDeleted;
entity.Obsolete = obsolete;
entity.IdEditor = idUser;
}
var result = await SaveChangesWithExceptionHandling(token);
return result;
}
public async Task<IEnumerable<TDto>> Get(int idWell, ProcessMapPlanBaseRequest request, CancellationToken token)
{
var timezone = wellService.GetTimezone(idWell);
var offset = TimeSpan.FromHours(timezone.Hours);
var query = context
.Set<TEntity>()
.Include(e => e.Author)
.Include(e => e.Editor)
.Where(e => e.IdWell == idWell);
.Include(e => e.Well)
.Where(e => e.IdWell == request.IdWell);
if(request.IdWellSectionType.HasValue)
if (request.IdWellSectionType.HasValue)
query = query.Where(e => e.IdWellSectionType == request.IdWellSectionType);
if (request.UpdateFrom.HasValue)
@ -126,156 +47,13 @@ public class ProcessMapPlanBaseRepository<TDto, TEntity> : IProcessMapPlanBaseRe
.Where(e => e.Obsolete == null || e.Obsolete >= moment);
}
var entities = await query.ToArrayAsync(token);
var dtos = entities.Select(e => Convert(e, offset));
return dtos;
return query;
}
public async Task<IEnumerable<TDto>> GetChangeLog(int idWell, DateOnly? date, CancellationToken token)
protected override TimeSpan GetTimezoneOffset(ProcessMapPlanBaseRequestWithWell request)
{
var query = context
.Set<TEntity>()
.Include(e => e.Author)
.Include(e => e.Editor)
.Where(e => e.IdWell == idWell);
var timezone = wellService.GetTimezone(idWell);
var timezone = wellService.GetTimezone(request.IdWell);
var offset = TimeSpan.FromHours(timezone.Hours);
if (date.HasValue)
{
var min = new DateTimeOffset(date.Value.Year, date.Value.Month, date.Value.Day, 0, 0, 0, offset).ToUniversalTime();
var max = min.AddDays(1);
var createdQuery = query.Where(e => e.Creation >= min && e.Creation <= max);
var editedQuery = query.Where(e => e.Obsolete != null && e.Obsolete >= min && e.Obsolete <= max);
query = createdQuery.Union(editedQuery);
}
var entities = await query.ToListAsync(token);
var dtos = entities.Select(e => Convert(e, offset));
return dtos;
}
public async Task<IEnumerable<DateOnly>> GetDatesChange(int idWell, CancellationToken token)
{
var wellEntitiesQuery = context
.Set<TEntity>()
.Where(e => e.IdWell == idWell);
var datesCreateQuery = wellEntitiesQuery
.Select(e => e.Creation)
.Distinct();
var datesCreate = await datesCreateQuery.ToArrayAsync(token);
var datesUpdateQuery = wellEntitiesQuery
.Where(e => e.Obsolete != null)
.Select(e => e.Obsolete!.Value)
.Distinct();
var datesUpdate = await datesUpdateQuery.ToArrayAsync(token);
var timezone = wellService.GetTimezone(idWell);
var offset = TimeSpan.FromHours(timezone.Hours);
var dates = Enumerable.Concat( datesCreate, datesUpdate);
dates = dates.Select(date => date.ToOffset(offset));
var datesOnly = dates
.Select(d => new DateOnly(d.Year, d.Month, d.Day))
.Distinct();
return datesOnly;
}
public async Task<int> UpdateRange(int idUser, IEnumerable<TDto> dtos, CancellationToken token)
{
if (dtos.Any(d => d.Id == 0))
throw new ArgumentInvalidException(nameof(dtos), "Отредактированные значения должны иметь id больше 0");
if (!dtos.Any())
return 0;
using var transaction = context.Database.BeginTransaction();
var result = 0;
var ids = dtos.Select(d => d.Id);
var dbSet = context.Set<TEntity>();
var entitiesToDelete = dbSet
.Where(e => ids.Contains(e.Id));
var updateTime = DateTimeOffset.UtcNow;
foreach (var entity in entitiesToDelete)
{
if(entity.Obsolete is not null)
throw new ArgumentInvalidException(nameof(dtos), "Недопустимо редактировать устаревшие записи");
entity.IdState = ChangeLogAbstract.IdStateReplaced;
entity.Obsolete = updateTime;
entity.IdEditor = idUser;
}
result += await context.SaveChangesAsync(token);
var entitiesNew = dtos.Select(Convert);
foreach (var entity in entitiesNew)
{
entity.IdPrevious = entity.Id;
entity.Id = default;
entity.Creation = updateTime;
entity.IdAuthor = idUser;
entity.Obsolete = null;
entity.IdEditor = null;
entity.IdState = ChangeLogAbstract.IdStateActual;
dbSet.Add(entity);
}
result += await SaveChangesWithExceptionHandling(token);
await transaction.CommitAsync(token);
return result;
}
protected virtual TEntity Convert(TDto dto)
{
var entity = dto.Adapt<TEntity>();
entity.Creation = entity.Creation.ToUniversalTime();
if(entity.Obsolete.HasValue)
entity.Obsolete = entity.Obsolete.Value.ToUniversalTime();
return entity;
}
protected virtual TDto Convert(TEntity entity, TimeSpan offset)
{
var dto = entity.Adapt<TDto>();
dto.Creation = entity.Creation.ToOffset(offset);
if (entity.Obsolete.HasValue)
dto.Obsolete = entity.Obsolete.Value.ToOffset(offset);
return dto;
}
private async Task<int> SaveChangesWithExceptionHandling(CancellationToken token)
{
try
{
var result = await context.SaveChangesAsync(token);
return result;
}
catch (DbUpdateException ex)
{
if (ex.InnerException is PostgresException pgException)
TryConvertPostgresExceptionToValidateException(pgException);
throw;
}
}
private static void TryConvertPostgresExceptionToValidateException(PostgresException pgException)
{
if (pgException.SqlState == PostgresErrorCodes.ForeignKeyViolation)
throw new ArgumentInvalidException("dtos", pgException.Message + "\r\n" + pgException.Detail);
return offset;
}
}

12
AsbCloudInfrastructure/Repository/WellOperationRepository.cs
View File

@ -383,12 +383,12 @@ public class WellOperationRepository : IWellOperationRepository
new[] { nameof(wellOperationDtos) });
}
if (previousDateEnd > currentDateStart)
{
yield return new ValidationResult(
"Предыдущая операция не завершена",
new[] { nameof(wellOperationDtos) });
}
//if (previousDateEnd > currentDateStart)
//{
// yield return new ValidationResult(
// "Предыдущая операция не завершена",
// new[] { nameof(wellOperationDtos) });
//}
previous = current;
}

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

@ -18,6 +18,9 @@ public interface IProcessMapPlanDrillingClient
[Delete(BaseRoute)]
Task<IApiResponse<int>> DeleteRange(int idWell, [Body] IEnumerable<int> ids);
[Delete($"{BaseRoute}/clear")]
Task<IApiResponse<int>> Clear(int idWell);
[Get(BaseRoute)]
Task<IApiResponse<IEnumerable<ProcessMapPlanDrillingDto>>> Get(int idWell, ProcessMapPlanBaseRequest request);
@ -28,5 +31,5 @@ public interface IProcessMapPlanDrillingClient
Task<IApiResponse<IEnumerable<DateOnly>>> GetDatesChange(int idWell);
[Put(BaseRoute)]
Task<IApiResponse<int>> UpdateRangeAsync(int idWell, IEnumerable<ProcessMapPlanDrillingDto> dtos);
Task<IApiResponse<int>> UpdateOrInsertRange(int idWell, IEnumerable<ProcessMapPlanDrillingDto> dtos);
}

96
AsbCloudWebApi.IntegrationTests/Controllers/ProcessMapPlanDrillingControllerTest.cs
View File

@ -179,7 +179,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
Assert.Equal(2, count);
var oldEntity = dbset.First(p => p.Id == entry.Entity.Id);
Assert.Equal(ProcessMapPlanBase.IdClearedOnImport, oldEntity.IdState);
Assert.Equal(ProcessMapPlanBase.IdCleared, oldEntity.IdState);
Assert.Equal(1, oldEntity.IdEditor);
Assert.NotNull(oldEntity.Obsolete);
Assert.InRange(oldEntity.Obsolete.Value, startTime, doneTime);
@ -194,7 +194,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
}
[Fact]
public async Task UpdateRange_returns_success()
public async Task UpdateOrInsertRange_returns_success()
{
// arrange
var startTime = DateTimeOffset.UtcNow;
@ -205,33 +205,50 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
dbContext.SaveChanges();
entry.State = EntityState.Detached;
var dtoCopy = dto.Adapt<ProcessMapPlanDrillingDto>();
dtoCopy.Id = entry.Entity.Id;
dtoCopy.Comment = "nebuchadnezzar";
dtoCopy.DeltaPressureLimitMax ++;
dtoCopy.DeltaPressurePlan ++;
dtoCopy.FlowPlan ++;
dtoCopy.FlowLimitMax ++;
dtoCopy.RopPlan ++;
dtoCopy.AxialLoadPlan ++;
dtoCopy.AxialLoadLimitMax ++;
dtoCopy.DepthStart ++;
dtoCopy.DepthEnd ++;
dtoCopy.TopDriveSpeedPlan ++;
dtoCopy.TopDriveSpeedLimitMax ++;
dtoCopy.TopDriveTorquePlan ++;
dtoCopy.TopDriveTorqueLimitMax ++;
var dtoUpdate = dto.Adapt<ProcessMapPlanDrillingDto>();
dtoUpdate.Id = entry.Entity.Id;
dtoUpdate.Comment = "nebuchadnezzar";
dtoUpdate.DeltaPressureLimitMax++;
dtoUpdate.DeltaPressurePlan++;
dtoUpdate.FlowPlan++;
dtoUpdate.FlowLimitMax++;
dtoUpdate.RopPlan++;
dtoUpdate.AxialLoadPlan++;
dtoUpdate.AxialLoadLimitMax++;
dtoUpdate.DepthStart++;
dtoUpdate.DepthEnd++;
dtoUpdate.TopDriveSpeedPlan++;
dtoUpdate.TopDriveSpeedLimitMax++;
dtoUpdate.TopDriveTorquePlan++;
dtoUpdate.TopDriveTorqueLimitMax++;
var dtoInsert = dtoUpdate.Adapt<ProcessMapPlanDrillingDto>();
dtoInsert.Id = 0;
dtoInsert.Comment = "nebuchad";
dtoInsert.DeltaPressureLimitMax++;
dtoInsert.DeltaPressurePlan++;
dtoInsert.FlowPlan++;
dtoInsert.FlowLimitMax++;
dtoInsert.RopPlan++;
dtoInsert.AxialLoadPlan++;
dtoInsert.AxialLoadLimitMax++;
dtoInsert.DepthStart++;
dtoInsert.DepthEnd++;
dtoInsert.TopDriveSpeedPlan++;
dtoInsert.TopDriveSpeedLimitMax++;
dtoInsert.TopDriveTorquePlan++;
dtoInsert.TopDriveTorqueLimitMax++;
// act
var result = await client.UpdateRangeAsync(entity.IdWell, new ProcessMapPlanDrillingDto[] { dtoCopy });
var result = await client.UpdateOrInsertRange(entity.IdWell, new ProcessMapPlanDrillingDto[] { dtoUpdate, dtoInsert });
// assert
var doneTime = DateTimeOffset.UtcNow;
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
Assert.Equal(2, result.Content);
Assert.Equal(3, result.Content);
var count = dbset.Count();
Assert.Equal(2, count);
Assert.Equal(3, count);
var oldEntity = dbset.First(p => p.Id == entry.Entity.Id);
Assert.Equal(ProcessMapPlanBase.IdStateReplaced, oldEntity.IdState);
@ -239,7 +256,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
Assert.NotNull(oldEntity.Obsolete);
Assert.InRange(oldEntity.Obsolete.Value, startTime, doneTime);
var newEntity = dbset.First(p => p.Id != entry.Entity.Id);
var newEntity = dbset.First(p => p.Comment == dtoUpdate.Comment);
Assert.Equal(ProcessMapPlanBase.IdStateActual, newEntity.IdState);
Assert.Equal(1, newEntity.IdAuthor);
Assert.Null(newEntity.IdEditor);
@ -247,7 +264,7 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
Assert.Equal(oldEntity.Id, newEntity.IdPrevious);
Assert.InRange(newEntity.Creation, startTime, doneTime);
var expected = dtoCopy.Adapt<ProcessMapPlanDrilling>();
var expected = dtoUpdate.Adapt<ProcessMapPlanDrilling>();
var excludeProps = new[] {
nameof(ProcessMapPlanDrilling.Id),
nameof(ProcessMapPlanDrilling.Author),
@ -289,6 +306,39 @@ public class ProcessMapPlanDrillingControllerTest: BaseIntegrationTest
Assert.InRange(actual.Obsolete.Value, startTime, doneTime);
}
[Fact]
public async Task Clear_returns_success()
{
//arrange
var dbset = dbContext.Set<ProcessMapPlanDrilling>();
var entry = dbset.Add(entity);
dbContext.SaveChanges();
entry.State = EntityState.Detached;
var startTime = DateTimeOffset.UtcNow;
//act
var response = await client.Clear(dto.IdWell);
//assert
var doneTime = DateTimeOffset.UtcNow;
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(1, response.Content);
var actual = dbContext
.Set<ProcessMapPlanDrilling>()
.FirstOrDefault(p => p.Id == entry.Entity.Id);
Assert.NotNull(actual);
Assert.Equal(ProcessMapPlanBase.IdCleared, actual.IdState);
Assert.Equal(1, actual.IdEditor);
Assert.NotNull(actual.Obsolete);
Assert.InRange(actual.Obsolete.Value, startTime, doneTime);
}
[Fact]
public async Task GetDatesChange_returns_success()
{

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

@ -2,6 +2,7 @@ using AsbCloudApp.Data;
using AsbCloudApp.Requests;
using AsbCloudDb.Model;
using AsbCloudWebApi.IntegrationTests.Clients;
using Microsoft.EntityFrameworkCore;
using Xunit;
namespace AsbCloudWebApi.IntegrationTests.Controllers;
@ -10,7 +11,7 @@ public class SlipsStatControllerTest : BaseIntegrationTest
{
private static readonly Schedule schedule = new()
{
Id = 1,
Id = 0,
IdDriller = Data.Defaults.Drillers[0].Id,
IdWell = Data.Defaults.Wells[0].Id,
ShiftStart = new TimeOnly(8, 0, 0),
@ -21,7 +22,7 @@ public class SlipsStatControllerTest : BaseIntegrationTest
private static readonly DetectedOperation detectedOperation = new()
{
Id = 1,
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)),
@ -34,7 +35,7 @@ public class SlipsStatControllerTest : BaseIntegrationTest
private static readonly WellOperation factWellOperation = new()
{
Id = 1,
Id = 0,
IdWell = Data.Defaults.Wells[0].Id,
IdWellSectionType = 1,
IdCategory = WellOperationCategory.IdRotor,
@ -51,9 +52,18 @@ public class SlipsStatControllerTest : BaseIntegrationTest
public SlipsStatControllerTest(WebAppFactoryFixture factory)
: base(factory)
{
dbContext.Schedule.Add(schedule);
dbContext.DetectedOperations.Add(detectedOperation);
dbContext.WellOperations.Add(factWellOperation);
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>();

49
AsbCloudWebApi/Controllers/ProcessMapPlan/ProcessMapPlanBaseController.cs
View File

@ -23,10 +23,10 @@ namespace AsbCloudWebApi.Controllers.ProcessMapPlan;
public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
where TDto : ProcessMapPlanBaseDto
{
private readonly IProcessMapPlanBaseRepository<TDto> repository;
private readonly IChangeLogRepository<TDto, ProcessMapPlanBaseRequestWithWell> repository;
private readonly IWellService wellService;
public ProcessMapPlanBaseController(IProcessMapPlanBaseRepository<TDto> repository, IWellService wellService)
public ProcessMapPlanBaseController(IChangeLogRepository<TDto, ProcessMapPlanBaseRequestWithWell> repository, IWellService wellService)
{
this.repository = repository;
this.wellService = wellService;
@ -68,7 +68,9 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
return this.ValidationBadRequest(nameof(dtos), "all dtos should contain same idWell");
var idUser = await AssertUserHasAccessToWell(idWell, token);
var result = await repository.ClearAndInsertRange(idUser, idWell, dtos, token);
var request = new ProcessMapPlanBaseRequestWithWell(idWell);
var result = await repository.ClearAndInsertRange(idUser, request, dtos, token);
return Ok(result);
}
@ -85,10 +87,29 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
public async Task<IActionResult> DeleteRange([FromRoute]int idWell, IEnumerable<int> ids, CancellationToken token)
{
var idUser = await AssertUserHasAccessToWell(idWell, token);
var result = await repository.DeleteRange(idUser, ids, token);
return Ok(result);
}
/// <summary>
/// Очистка
/// </summary>
/// <param name="idWell"></param>
/// <param name="token"></param>
/// <returns></returns>
[HttpDelete("clear")]
[ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
public async Task<IActionResult> Clear([FromRoute] int idWell, CancellationToken token)
{
var idUser = await AssertUserHasAccessToWell(idWell, token);
var request = new ProcessMapPlanBaseRequestWithWell(idWell);
var result = await repository.Clear(idUser, request, token);
return Ok(result);
}
/// <summary>
/// Получение
/// </summary>
@ -102,7 +123,9 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
public async Task<ActionResult<IEnumerable<TDto>>> Get([FromRoute] int idWell, [FromQuery]ProcessMapPlanBaseRequest request, CancellationToken token)
{
await AssertUserHasAccessToWell(idWell, token);
var result = await repository.Get(idWell, request, token);
var serviceRequest = new ProcessMapPlanBaseRequestWithWell(request, idWell);
var result = await repository.Get(serviceRequest, token);
return Ok(result);
}
@ -119,7 +142,9 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
public async Task<ActionResult<IEnumerable<TDto>>> GetChangeLog([FromRoute] int idWell, [FromQuery] DateOnly? date, CancellationToken token)
{
await AssertUserHasAccessToWell(idWell, token);
var result = await repository.GetChangeLog(idWell, date, token);
var serviceRequest = new ProcessMapPlanBaseRequestWithWell(idWell);
var result = await repository.GetChangeLog(serviceRequest, date, token);
return Ok(result);
}
@ -135,24 +160,26 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
public async Task<ActionResult<IEnumerable<DateOnly>>> GetDatesChange([FromRoute] int idWell, CancellationToken token)
{
await AssertUserHasAccessToWell(idWell, token);
var result = await repository.GetDatesChange(idWell, token);
var serviceRequest = new ProcessMapPlanBaseRequestWithWell(idWell);
var result = await repository.GetDatesChange(serviceRequest, token);
return Ok(result);
}
/// <summary>
/// Редактирование
/// Редактирование или добавление [для пакетного редактирования]
/// </summary>
/// <param name="idWell"></param>
/// <param name="dtos"></param>
/// <param name="token"></param>
/// <returns></returns>
[HttpPut]
[HttpPut()]
[ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
[ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
public async Task<IActionResult> UpdateRange([FromRoute] int idWell, IEnumerable<TDto> dtos, CancellationToken token)
public async Task<IActionResult> UpdateOrInsertRange([FromRoute] int idWell, IEnumerable<TDto> dtos, CancellationToken token)
{
var first = dtos.FirstOrDefault();
if(first is null)
if (first is null)
return NoContent();
if (idWell == 0 || dtos.Any(d => d.IdWell != idWell))
@ -160,7 +187,7 @@ public abstract class ProcessMapPlanBaseController<TDto> : ControllerBase
var idUser = await AssertUserHasAccessToWell(idWell, token);
var result = await repository.UpdateRange(idUser, dtos, token);
var result = await repository.UpdateOrInsertRange(idUser, dtos, token);
return Ok(result);
}

5
AsbCloudWebApi/Controllers/ProcessMapPlan/ProcessMapPlanDrillingController.cs
View File

@ -1,12 +1,15 @@
using AsbCloudApp.Data.ProcessMapPlan;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
namespace AsbCloudWebApi.Controllers.ProcessMapPlan;
public class ProcessMapPlanDrillingController : ProcessMapPlanBaseController<ProcessMapPlanDrillingDto>
{
public ProcessMapPlanDrillingController(IProcessMapPlanBaseRepository<ProcessMapPlanDrillingDto> repository, IWellService wellService)
public ProcessMapPlanDrillingController(
IChangeLogRepository<ProcessMapPlanDrillingDto, ProcessMapPlanBaseRequestWithWell> repository,
IWellService wellService)
: base(repository, wellService)
{
}

6
AsbCloudWebApi/Extentions.cs
View File

@ -70,8 +70,10 @@ namespace Microsoft.AspNetCore.Mvc
public static BadRequestObjectResult ValidationBadRequest(this ControllerBase controller, IEnumerable<ValidationResult> validationResults)
{
var errors = validationResults
.SelectMany(e => e.MemberNames.Select(name=> new { name, e.ErrorMessage }))
.ToDictionary(e => e.name, e => new[] { e.ErrorMessage ?? string.Empty });
.SelectMany(e => e.MemberNames.Select(name => new { name, e.ErrorMessage }))
.GroupBy(e => e.name)
.ToDictionary(e => e.Key, e => e.Select(el => el.ErrorMessage ?? string.Empty).ToArray());
var problem = new ValidationProblemDetails(errors);
return controller.BadRequest(problem);
}