on.nemtina/persistence
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

Setpoint API #1

Merged
on.nemtina merged 10 commits from Setpoint into master 2024-11-25 10:33:36 +05:00
Conversation 0 Commits 10 Files Changed 16 +337 -167
29 changed files with 337 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit c496cea07a - Show all commits

20
Persistence.API/Controllers/TimeSeriesController.cs
View File

@ -19,24 +19,32 @@ public class TimeSeriesController<TDto> : ControllerBase, ITimeSeriesDataApi<TDt
[HttpGet]
[ProducesResponseType(StatusCodes.Status200OK)]
public async Task<IActionResult> GetAsync(DateTimeOffset dateBegin, DateTimeOffset dateEnd, CancellationToken token)
public async Task<IActionResult> Get(DateTimeOffset dateBegin, CancellationToken token)
{
var result = await this.timeSeriesDataRepository.GetAsync(dateBegin, dateEnd, token);
var result = await this.timeSeriesDataRepository.GetGtDate(dateBegin, token);
return Ok(result);
}
[HttpGet("datesRange")]
public async Task<IActionResult> GetDatesRangeAsync(CancellationToken token)
public async Task<IActionResult> GetDatesRange(CancellationToken token)
{
var result = await this.timeSeriesDataRepository.GetDatesRangeAsync(token);
var result = await this.timeSeriesDataRepository.GetDatesRange(token);
return Ok(result);
}
[HttpGet("resampled")]
public async Task<IActionResult> GetResampledData(DateTimeOffset dateBegin, double intervalSec = 600d, int approxPointsCount = 1024, CancellationToken token = default)
{
var result = await this.timeSeriesDataRepository.GetResampledData(dateBegin, intervalSec, approxPointsCount, token);
return Ok(result);
}
[HttpPost]
public async Task<IActionResult> InsertRangeAsync(IEnumerable<TDto> dtos, CancellationToken token)
public async Task<IActionResult> InsertRange(IEnumerable<TDto> dtos, CancellationToken token)
{
var result = await this.timeSeriesDataRepository.InsertRange(dtos, token);
return Ok(result);
}
}

3
Persistence.API/Program.cs
View File

@ -1,10 +1,13 @@
using Persistence.Models;
namespace Persistence.API;
public class Program
{
public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
Startup.BeforeRunHandler(host);
host.Run();

5
Persistence.API/Startup.cs
View File

@ -33,6 +33,11 @@ public class Startup
app.UseRouting();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseAuthentication();
app.UseAuthorization();

9
Persistence.API/appsettings.Tests.json
View File

@ -4,5 +4,12 @@
"Port": 5432,
"Username": "postgres",
"Password": "q"
}
},
"KeycloakTestUser": {
"username": "myuser",
"password": 12345,
"clientId": "webapi",
"grantType": "password"
},
"KeycloakGetTokenUrl": "http://192.168.0.10:8321/realms/Persistence/protocol/openid-connect/token"
}

6
Persistence.API/appsettings.json
View File

@ -10,9 +10,9 @@
},
"AllowedHosts": "*",
"Authentication": {
"MetadataAddress": "http://localhost:8080/realms/TestRealm/.well-known/openid-configuration",
"MetadataAddress": "http://192.168.0.10:8321/realms/Persistence/.well-known/openid-configuration",
"Audience": "account",
"ValidIssuer": "http://localhost:8080/realms/TestRealm",
"AuthorizationUrl": "http://localhost:8080/realms/TestRealm/protocol/openid-connect/auth"
"ValidIssuer": "http://192.168.0.10:8321/realms/Persistence",
"AuthorizationUrl": "http://192.168.0.10:8321/realms/Persistence/protocol/openid-connect/auth"
}
}

17
Persistence.Database.Postgres/Migrations/20241118091712_InitialCreate.Designer.cs → Persistence.Database.Postgres/Migrations/20241122074646_InitialCreate.Designer.cs generated
View File

@ -12,7 +12,7 @@ using Persistence.Database.Model;
namespace Persistence.Database.Postgres.Migrations
{
[DbContext(typeof(PersistenceDbContext))]
[Migration("20241118091712_InitialCreate")]
[Migration("20241122074646_InitialCreate")]
partial class InitialCreate
{
/// <inheritdoc />
@ -29,12 +29,9 @@ namespace Persistence.Database.Postgres.Migrations
modelBuilder.Entity("Persistence.Database.Model.DataSaub", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("integer")
.HasColumnName("id");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
b.Property<DateTimeOffset>("Date")
.HasColumnType("timestamp with time zone")
.HasColumnName("date");
b.Property<double?>("AxialLoad")
.HasColumnType("double precision")
@ -52,10 +49,6 @@ namespace Persistence.Database.Postgres.Migrations
.HasColumnType("double precision")
.HasColumnName("blockSpeed");
b.Property<DateTimeOffset>("Date")
.HasColumnType("timestamp with time zone")
.HasColumnName("date");
b.Property<double?>("Flow")
.HasColumnType("double precision")
.HasColumnName("flow");
@ -112,7 +105,7 @@ namespace Persistence.Database.Postgres.Migrations
.HasColumnType("double precision")
.HasColumnName("wellDepth");
b.HasKey("Id");
b.HasKey("Date");
b.ToTable("DataSaub");
});

5
Persistence.Database.Postgres/Migrations/20241118091712_InitialCreate.cs → Persistence.Database.Postgres/Migrations/20241122074646_InitialCreate.cs
View File

@ -1,6 +1,5 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
#nullable disable
@ -19,8 +18,6 @@ namespace Persistence.Database.Postgres.Migrations
name: "DataSaub",
columns: table => new
{
id = table.Column<int>(type: "integer", nullable: false)
.Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
date = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
mode = table.Column<int>(type: "integer", nullable: true),
user = table.Column<string>(type: "text", nullable: true),
@ -43,7 +40,7 @@ namespace Persistence.Database.Postgres.Migrations
},
constraints: table =>
{
table.PrimaryKey("PK_DataSaub", x => x.id);
table.PrimaryKey("PK_DataSaub", x => x.date);
});
}

15
Persistence.Database.Postgres/Migrations/PersistenceDbContextModelSnapshot.cs
View File

@ -26,12 +26,9 @@ namespace Persistence.Database.Postgres.Migrations
modelBuilder.Entity("Persistence.Database.Model.DataSaub", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("integer")
.HasColumnName("id");
NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
b.Property<DateTimeOffset>("Date")
.HasColumnType("timestamp with time zone")
.HasColumnName("date");
b.Property<double?>("AxialLoad")
.HasColumnType("double precision")
@ -49,10 +46,6 @@ namespace Persistence.Database.Postgres.Migrations
.HasColumnType("double precision")
.HasColumnName("blockSpeed");
b.Property<DateTimeOffset>("Date")
.HasColumnType("timestamp with time zone")
.HasColumnName("date");
b.Property<double?>("Flow")
.HasColumnType("double precision")
.HasColumnName("flow");
@ -109,7 +102,7 @@ namespace Persistence.Database.Postgres.Migrations
.HasColumnType("double precision")
.HasColumnName("wellDepth");
b.HasKey("Id");
b.HasKey("Date");
b.ToTable("DataSaub");
});

9
Persistence.Database/Entity/DataSaub.cs
View File

@ -1,12 +1,11 @@
using System.ComponentModel.DataAnnotations.Schema;
using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace Persistence.Database.Model;
public class DataSaub : ITimestampedData
{
[Column("id")]
public int Id { get; set; }
[Column("date")]
[Key, Column("date")]
public DateTimeOffset Date { get; set; }
[Column("mode")]

17
Persistence.IntegrationTests/Clients/ITimeSeriesClient.cs
View File

@ -1,13 +1,22 @@
using Microsoft.AspNetCore.Mvc;
using Persistence.Models;
using Refit;
namespace Persistence.IntegrationTests.Clients;
public interface ITimeSeriesClient<TDto>
where TDto : class, new()
{
[Post("/api/dataSaub")]
Task<IApiResponse<int>> InsertRangeAsync(IEnumerable<TDto> dtos);
private const string BaseRoute = "/api/dataSaub";
[Get("/api/dataSaub")]
Task<IApiResponse<IEnumerable<TDto>>> GetAsync(DateTimeOffset dateBegin, DateTimeOffset dateEnd);
[Post($"{BaseRoute}")]
Task<IApiResponse<int>> InsertRange(IEnumerable<TDto> dtos);
[Get($"{BaseRoute}")]
Task<IApiResponse<IEnumerable<TDto>>> Get(DateTimeOffset dateBegin, DateTimeOffset dateEnd);
[Get($"{BaseRoute}/resampled")]
Task<IApiResponse<IEnumerable<TDto>>> GetResampledData(DateTimeOffset dateBegin, double intervalSec = 600d, int approxPointsCount = 1024);
[Get($"{BaseRoute}/datesRange")]
Task<IApiResponse<DatesRangeDto?>> GetDatesRange();
}

18
Persistence.IntegrationTests/Controllers/DataSaubControllerTest.cs
View File

@ -11,10 +11,9 @@ public class DataSaubControllerTest : TimeSeriesBaseControllerTest<DataSaub, Dat
BitDepth = 2,
BlockPosition = 3,
BlockSpeed = 4,
Date = DateTimeOffset.Now,
Date = DateTimeOffset.UtcNow,
Flow = 5,
HookWeight = 6,
Id = 7,
IdFeedRegulator = 8,
Mode = 9,
Mse = 10,
@ -38,7 +37,6 @@ public class DataSaubControllerTest : TimeSeriesBaseControllerTest<DataSaub, Dat
Date = DateTimeOffset.UtcNow,
Flow = 5,
HookWeight = 6,
Id = 7,
IdFeedRegulator = 8,
Mode = 9,
Mse = 10,
@ -70,4 +68,18 @@ public class DataSaubControllerTest : TimeSeriesBaseControllerTest<DataSaub, Dat
var endDate = DateTimeOffset.UtcNow;
await GetSuccess(beginDate, endDate, entity);
}
[Fact]
public async Task GetDatesRange_returns_success()
{
await GetDatesRangeSuccess(entity);
}
[Fact]
public async Task GetResampledData_returns_success()
{
await GetResampledDataSuccess(entity);
}
}

91
Persistence.IntegrationTests/Controllers/TimeSeriesBaseControllerTest.cs
View File

@ -1,20 +1,12 @@
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration.UserSecrets;
using Persistence.Database.Model;
using Persistence.IntegrationTests.Clients;
using Persistence.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using Xunit;
namespace Persistence.IntegrationTests.Controllers;
public abstract class TimeSeriesBaseControllerTest<TEntity, TDto> : BaseIntegrationTest
where TEntity : class
where TEntity : class, ITimestampedData, new()
where TDto : class, new()
{
private ITimeSeriesClient<TDto> client;
@ -22,7 +14,11 @@ public abstract class TimeSeriesBaseControllerTest<TEntity, TDto> : BaseIntegrat
public TimeSeriesBaseControllerTest(WebAppFactoryFixture factory) : base(factory)
{
dbContext.CleanupDbSet<TEntity>();
client = factory.GetHttpClient<ITimeSeriesClient<TDto>>(string.Empty);
Task.Run(async () =>
{
client = await factory.GetAuthorizedHttpClient<ITimeSeriesClient<TDto>>(string.Empty);
}).Wait();
}
public async Task InsertRangeSuccess(TDto dto)
@ -31,7 +27,7 @@ public abstract class TimeSeriesBaseControllerTest<TEntity, TDto> : BaseIntegrat
var expected = dto.Adapt<TDto>();
//act
var response = await client.InsertRangeAsync(new TDto[] { expected });
var response = await client.InsertRange(new TDto[] { expected });
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
@ -47,11 +43,80 @@ public abstract class TimeSeriesBaseControllerTest<TEntity, TDto> : BaseIntegrat
dbContext.SaveChanges();
var response = await client.GetAsync(beginDate, endDate);
var response = await client.Get(beginDate, endDate);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
Assert.Single(response.Content);
}
public async Task GetDatesRangeSuccess(TEntity entity)
{
//arrange
var datesRangeExpected = 30;
var entity2 = entity.Adapt<TEntity>();
entity2.Date = entity.Date.AddDays(datesRangeExpected);
var dbset = dbContext.Set<TEntity>();
dbset.Add(entity);
dbset.Add(entity2);
dbContext.SaveChanges();
var response = await client.GetDatesRange();
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
var datesRangeActual = (response.Content.To - response.Content.From).Days;
Assert.Equal(datesRangeExpected, datesRangeActual);
}
public async Task GetResampledDataSuccess(TEntity entity)
{
//arrange
var approxPointsCount = 10;
var differenceBetweenStartAndEndDays = 50;
var entities = new List<TEntity>();
for (var i = 1; i <= differenceBetweenStartAndEndDays; i++)
{
var entity2 = entity.Adapt<TEntity>();
entity2.Date = entity.Date.AddDays(i - 1);
entities.Add(entity2);
}
var dbset = dbContext.Set<TEntity>();
dbset.AddRange(entities);
dbContext.SaveChanges();
var response = await client.GetResampledData(entity.Date.AddMinutes(-1), differenceBetweenStartAndEndDays * 24 * 60 * 60 + 60, approxPointsCount);
//assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.NotNull(response.Content);
var ratio = entities.Count() / approxPointsCount;
if (ratio > 1)
{
var expectedResampledCount = entities
.Where((_, index) => index % ratio == 0)
.Count();
Assert.Equal(expectedResampledCount, response.Content.Count());
}
else
{
Assert.Equal(entities.Count(), response.Content.Count());
}
}
}

8
Persistence.IntegrationTests/JwtToken.cs Normal file
View File

@ -0,0 +1,8 @@
using System.Text.Json.Serialization;
namespace Persistence.IntegrationTests;
public class JwtToken
{
[JsonPropertyName("access_token")]
public required string AccessToken { get; set; }
}

27
Persistence.IntegrationTests/KeyCloakUser.cs Normal file
View File

@ -0,0 +1,27 @@
namespace Persistence.IntegrationTests;
/// <summary>
/// настройки credentials для пользователя в KeyCloak
/// </summary>
public class KeyCloakUser
{
/// <summary>
///
/// </summary>
public required string Username { get; set; }
/// <summary>
///
/// </summary>
public required string Password { get; set; }
/// <summary>
///
/// </summary>
public required string ClientId { get; set; }
/// <summary>
///
/// </summary>
public required string GrantType { get; set; }
}

1
Persistence.IntegrationTests/Persistence.IntegrationTests.csproj
View File

@ -15,6 +15,7 @@
<PackageReference Include="Microsoft.Extensions.Configuration" Version="9.0.0" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
<PackageReference Include="Refit" Version="8.0.0" />
<PackageReference Include="RestSharp" Version="112.1.0" />
<PackageReference Include="xunit" Version="2.9.2" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
<PrivateAssets>all</PrivateAssets>

64
Persistence.IntegrationTests/WebAppFactoryFixture.cs
View File

@ -3,10 +3,12 @@ using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Persistence.API;
using Persistence.Database.Model;
using Persistence.Database.Postgres;
using Persistence.API;
using Refit;
using RestSharp;
using System.Net.Http.Headers;
using System.Text.Json;
using Persistence.Database.Postgres;
@ -23,6 +25,8 @@ public class WebAppFactoryFixture : WebApplicationFactory<Startup>
private static readonly RefitSettings RefitSettings = new(new SystemTextJsonContentSerializer(JsonSerializerOptions));
private readonly string connectionString;
private readonly KeyCloakUser keycloakTestUser;
public readonly string KeycloakGetTokenUrl;
public WebAppFactoryFixture()
{
@ -32,6 +36,10 @@ public class WebAppFactoryFixture : WebApplicationFactory<Startup>
var dbConnection = configuration.GetSection("DbConnection").Get<DbConnection>()!;
connectionString = dbConnection.GetConnectionString();
keycloakTestUser = configuration.GetSection("KeycloakTestUser").Get<KeyCloakUser>()!;
KeycloakGetTokenUrl = configuration.GetSection("KeycloakGetTokenUrl").Value!;
}
protected override void ConfigureWebHost(IWebHostBuilder builder)
@ -53,7 +61,6 @@ public class WebAppFactoryFixture : WebApplicationFactory<Startup>
var dbContext = scopedServices.GetRequiredService<PersistenceDbContext>();
dbContext.Database.EnsureCreatedAndMigrated();
//dbContext.Deposits.AddRange(Data.Defaults.Deposits);
dbContext.SaveChanges();
});
}
@ -80,23 +87,44 @@ public class WebAppFactoryFixture : WebApplicationFactory<Startup>
return RestService.For<T>(httpClient, RefitSettings);
}
//public T GetAuthorizedHttpClient<T>(string uriSuffix)
//{
// var httpClient = GetAuthorizedHttpClient();
// if (string.IsNullOrEmpty(uriSuffix))
// return RestService.For<T>(httpClient, RefitSettings);
public async Task<T> GetAuthorizedHttpClient<T>(string uriSuffix)
{
var httpClient = await GetAuthorizedHttpClient();
if (string.IsNullOrEmpty(uriSuffix))
return RestService.For<T>(httpClient, RefitSettings);
// if (httpClient.BaseAddress is not null)
// httpClient.BaseAddress = new Uri(httpClient.BaseAddress, uriSuffix);
if (httpClient.BaseAddress is not null)
httpClient.BaseAddress = new Uri(httpClient.BaseAddress, uriSuffix);
// return RestService.For<T>(httpClient, RefitSettings);
//}
return RestService.For<T>(httpClient, RefitSettings);
}
//private HttpClient GetAuthorizedHttpClient()
//{
// var httpClient = CreateClient();
// var jwtToken = ApiTokenHelper.GetAdminUserToken();
// httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", jwtToken);
// return httpClient;
//}
private async Task<HttpClient> GetAuthorizedHttpClient()
{
var httpClient = CreateClient();
var token = await GetTokenAsync();
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
return httpClient;
}
private async Task<string> GetTokenAsync()
{
var restClient = new RestClient();
var request = new RestRequest(KeycloakGetTokenUrl, Method.Post);
request.AddParameter("username", keycloakTestUser.Username);
request.AddParameter("password", keycloakTestUser.Password);
request.AddParameter("client_id", keycloakTestUser.ClientId);
request.AddParameter("grant_type", keycloakTestUser.GrantType);
var keyCloackResponse = await restClient.PostAsync(request);
if (keyCloackResponse.IsSuccessful && !String.IsNullOrEmpty(keyCloackResponse.Content))
{
var token = JsonSerializer.Deserialize<JwtToken>(keyCloackResponse.Content)!;
return token.AccessToken;
}
return String.Empty;
}
}

2
Persistence.Repository/Data/DataSaubDto.cs
View File

@ -4,8 +4,6 @@ using System.ComponentModel.DataAnnotations.Schema;
namespace Persistence.Repository.Data;
public class DataSaubDto : ITimeSeriesAbstractDto
{
public int Id { get; set; }
public DateTimeOffset Date { get; set; } = DateTimeOffset.UtcNow;
public int? Mode { get; set; }

51
Persistence.Repository/Repositories/TimeSeriesDataCachedRepository.cs
View File

@ -10,8 +10,8 @@ public class TimeSeriesDataCachedRepository<TEntity, TDto> : TimeSeriesDataRepos
where TEntity : class, ITimestampedData, new()
where TDto : class, ITimeSeriesAbstractDto, new()
{
public static TDto FirstByDate { get; set; } = default!;
public static CyclicArray<TDto> LastData { get; set; } = null!;
public static TDto? FirstByDate { get; private set; }
public static CyclicArray<TDto> LastData { get; } = new CyclicArray<TDto>(CacheItemsCount);
private const int CacheItemsCount = 3600;
@ -19,8 +19,6 @@ public class TimeSeriesDataCachedRepository<TEntity, TDto> : TimeSeriesDataRepos
{
Task.Run(async () =>
{
LastData = new CyclicArray<TDto>(CacheItemsCount);
var firstDateItem = await base.GetFirstAsync(CancellationToken.None);
if (firstDateItem == null)
{
@ -35,17 +33,17 @@ public class TimeSeriesDataCachedRepository<TEntity, TDto> : TimeSeriesDataRepos
}).Wait();
}
public override async Task<IEnumerable<TDto>> GetAsync(DateTimeOffset dateBegin, DateTimeOffset dateEnd, CancellationToken token)
public override async Task<IEnumerable<TDto>> GetGtDate(DateTimeOffset dateBegin, CancellationToken token)
{
if (LastData.Count() == 0 || LastData[0].Date > dateBegin)
{
var dtos = await base.GetAsync(dateBegin, dateEnd, token);
var dtos = await base.GetGtDate(dateBegin, token);
return dtos;
}
var items = LastData
.Where(i => i.Date >= dateBegin && i.Date <= dateEnd);
.Where(i => i.Date >= dateBegin);
return items;
}
@ -64,5 +62,44 @@ public class TimeSeriesDataCachedRepository<TEntity, TDto> : TimeSeriesDataRepos
return result;
}
public override async Task<DatesRangeDto?> GetDatesRange(CancellationToken token)
{
if (FirstByDate == null)
return null;
return await Task.Run(() =>
{
return new DatesRangeDto
{
From = FirstByDate.Date,
To = LastData[^1].Date
};
});
}
public override async Task<IEnumerable<TDto>> GetResampledData(
DateTimeOffset dateBegin,
double intervalSec = 600d,
int approxPointsCount = 1024,
CancellationToken token = default)
{
var dtos = LastData.Where(i => i.Date >= dateBegin);
if (LastData.Count == 0 || LastData[0].Date > dateBegin)
{
dtos = await base.GetGtDate(dateBegin, token);
}
var dateEnd = dateBegin.AddSeconds(intervalSec);
dtos = dtos
.Where(i => i.Date <= dateEnd);
var ratio = dtos.Count() / approxPointsCount;
if (ratio > 1)
dtos = dtos
.Where((_, index) => index % ratio == 0);
return dtos;
}
}

37
Persistence.Repository/Repositories/TimeSeriesDataRepository.cs
View File

@ -18,16 +18,7 @@ public class TimeSeriesDataRepository<TEntity, TDto> : ITimeSeriesDataRepository
protected virtual IQueryable<TEntity> GetQueryReadOnly() => this.db.Set<TEntity>();
public virtual async Task<IEnumerable<TDto>> GetAsync(DateTimeOffset dateBegin, DateTimeOffset dateEnd, CancellationToken token)
{
var query = GetQueryReadOnly();
var entities = await query.ToArrayAsync(token);
var dtos = entities.Select(e => e.Adapt<TDto>());
return dtos;
}
public virtual async Task<DatesRangeDto> GetDatesRangeAsync(CancellationToken token)
public virtual async Task<DatesRangeDto?> GetDatesRange(CancellationToken token)
{
var query = GetQueryReadOnly();
var minDate = await query.MinAsync(o => o.Date, token);
@ -60,7 +51,7 @@ public class TimeSeriesDataRepository<TEntity, TDto> : ITimeSeriesDataRepository
return result;
}
public async Task<IEnumerable<TDto>> GetLastAsync(int takeCount, CancellationToken token)
protected async Task<IEnumerable<TDto>> GetLastAsync(int takeCount, CancellationToken token)
{
var query = GetQueryReadOnly()
.OrderByDescending(e => e.Date)
@ -72,17 +63,37 @@ public class TimeSeriesDataRepository<TEntity, TDto> : ITimeSeriesDataRepository
return dtos;
}
public async Task<TDto?> GetFirstAsync(CancellationToken token)
protected async Task<TDto?> GetFirstAsync(CancellationToken token)
{
var query = GetQueryReadOnly()
.OrderBy(e => e.Date);
var entity = await query.FirstOrDefaultAsync(token);
if(entity == null)
if (entity == null)
return null;
var dto = entity.Adapt<TDto>();
return dto;
}
public async virtual Task<IEnumerable<TDto>> GetResampledData(
DateTimeOffset dateBegin,
double intervalSec = 600d,
int approxPointsCount = 1024,
CancellationToken token = default)
{
var dtos = await GetGtDate(dateBegin, token);
var dateEnd = dateBegin.AddSeconds(intervalSec);
dtos = dtos
.Where(i => i.Date <= dateEnd);
var ratio = dtos.Count() / approxPointsCount;
if (ratio > 1)
dtos = dtos
.Where((_, index) => index % ratio == 0);
return dtos;
}
}

12
Persistence/API/IChangeLogApi.cs
View File

@ -31,7 +31,7 @@ public interface IChangeLogApi<TDto, TChangeLogDto>
/// <param name="dto"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<int>> AddAsync(TDto dto, CancellationToken token);
Task<ActionResult<int>> Add(TDto dto, CancellationToken token);
/// <summary>
/// Добавить несколько записей
@ -39,7 +39,7 @@ public interface IChangeLogApi<TDto, TChangeLogDto>
/// <param name="dtos"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<int>> AddRangeAsync(IEnumerable<TDto> dtos, CancellationToken token);
Task<ActionResult<int>> AddRange(IEnumerable<TDto> dtos, CancellationToken token);
/// <summary>
/// Обновить одну запись
@ -47,7 +47,7 @@ public interface IChangeLogApi<TDto, TChangeLogDto>
/// <param name="dto"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<int>> UpdateAsync(TDto dto, CancellationToken token);
Task<ActionResult<int>> Update(TDto dto, CancellationToken token);
/// <summary>
/// Обновить несколько записей
@ -55,7 +55,7 @@ public interface IChangeLogApi<TDto, TChangeLogDto>
/// <param name="dtos"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<int>> UpdateRangeAsync(IEnumerable<TDto> dtos, CancellationToken token);
Task<ActionResult<int>> UpdateRange(IEnumerable<TDto> dtos, CancellationToken token);
/// <summary>
/// Удалить одну запись
@ -63,7 +63,7 @@ public interface IChangeLogApi<TDto, TChangeLogDto>
/// <param name="id"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<int>> DeleteAsync(int id, CancellationToken token);
Task<ActionResult<int>> Delete(int id, CancellationToken token);
/// <summary>
/// Удалить несколько записей
@ -71,5 +71,5 @@ public interface IChangeLogApi<TDto, TChangeLogDto>
/// <param name="ids"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<int>> DeleteRangeAsync(IEnumerable<int> ids, CancellationToken token);
Task<ActionResult<int>> DeleteRange(IEnumerable<int> ids, CancellationToken token);
}

8
Persistence/API/IDictionaryElementApi.cs
View File

@ -13,7 +13,7 @@ public interface IDictionaryElementApi<TDto> where TDto : class, new()
/// <param name="dictionaryKey">ключ справочника</param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<IEnumerable<TDto>>> GetAsync(Guid dictionaryKey, CancellationToken token);
Task<ActionResult<IEnumerable<TDto>>> Get(Guid dictionaryKey, CancellationToken token);
/// <summary>
/// Добавить элемент в справочник
@ -22,7 +22,7 @@ public interface IDictionaryElementApi<TDto> where TDto : class, new()
/// <param name="dto"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<Guid>> AddAsync(Guid dictionaryKey, TDto dto, CancellationToken token);
Task<ActionResult<Guid>> Add(Guid dictionaryKey, TDto dto, CancellationToken token);
/// <summary>
/// Изменить одну запись
@ -32,7 +32,7 @@ public interface IDictionaryElementApi<TDto> where TDto : class, new()
/// <param name="dto"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<Guid>> UpdateAsync(Guid dictionaryKey, Guid dictionaryElementKey, TDto dto, CancellationToken token);
Task<ActionResult<Guid>> Update(Guid dictionaryKey, Guid dictionaryElementKey, TDto dto, CancellationToken token);
/// <summary>
/// Удалить одну запись
@ -41,5 +41,5 @@ public interface IDictionaryElementApi<TDto> where TDto : class, new()
/// <param name="dictionaryElementKey">ключ элемента в справочнике</param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<int>> DeleteAsync(Guid dictionaryKey, Guid dictionaryElementKey, CancellationToken token);
Task<ActionResult<int>> Delete(Guid dictionaryKey, Guid dictionaryElementKey, CancellationToken token);
}

2
Persistence/API/ISyncApi.cs
View File

@ -15,7 +15,7 @@ public interface ISyncApi<TDto> where TDto : class, new()
/// <param name="take">количество записей</param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<IEnumerable<TDto>>> GetPartAsync(DateTimeOffset dateBegin, int take = 24 * 60 * 60, CancellationToken token = default);
Task<ActionResult<IEnumerable<TDto>>> GetPart(DateTimeOffset dateBegin, int take = 24 * 60 * 60, CancellationToken token = default);
/// <summary>
/// Получить диапазон дат, для которых есть данные в репозитории

2
Persistence/API/ITableDataApi.cs
View File

@ -19,5 +19,5 @@ public interface ITableDataApi<TDto, TRequest>
/// <param name="request">параметры фильтрации</param>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<PaginationContainer<TDto>>> GetPageAsync(TRequest request, CancellationToken token);
Task<ActionResult<PaginationContainer<TDto>>> GetPage(TRequest request, CancellationToken token);
}

14
Persistence/API/IGraphDataApi.cs → Persistence/API/ITimeSeriesBaseDataApi.cs
View File

@ -4,23 +4,27 @@ using Persistence.Models;
namespace Persistence.API;
/// <summary>
/// Интерфейс для работы с API графиков
/// Базовый интерфейс для работы с временными рядами
/// </summary>
public interface IGraphDataApi<TDto>
public interface ITimeSeriesBaseDataApi<TDto>
{
/// <summary>
/// Получить список объектов с прореживанием, удовлетворящий диапазону дат
/// Получить список объектов с прореживанием, удовлетворяющий диапазону дат
/// </summary>
/// <param name="dateBegin">дата начала</param>
/// <param name="dateEnd">дата окончания</param>
/// <param name="approxPointsCount"></param>
/// <returns></returns>
Task<ActionResult<IEnumerable<TDto>>> GetThinnedDataAsync(DateTimeOffset dateBegin, DateTimeOffset dateEnd, int approxPointsCount = 1024);
Task<IActionResult> GetResampledData(
DateTimeOffset dateBegin,
double intervalSec = 600d,
int approxPointsCount = 1024,
CancellationToken token = default);
/// <summary>
/// Получить диапазон дат, для которых есть данные в репозитории
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
Task<ActionResult<DatesRangeDto>> GetDatesRangeAsync(CancellationToken token);
Task<IActionResult> GetDatesRange(CancellationToken token);
}

14
Persistence/API/ITimeSeriesDataApi.cs
View File

@ -11,24 +11,16 @@ namespace Persistence.API;
/// <summary>
/// Интерфейс для работы с API временных данных
/// </summary>
public interface ITimeSeriesDataApi<TDto>
public interface ITimeSeriesDataApi<TDto> : ITimeSeriesBaseDataApi<TDto>
where TDto : class, ITimeSeriesAbstractDto, new()
{
/// <summary>
/// Получить список объектов, удовлетворяющий диапазон дат
/// </summary>
/// <param name="dateBegin">дата начала</param>
/// <param name="dateEnd">дата окончания</param>
/// <param name="token"></param>
/// <returns></returns>
Task<IActionResult> GetAsync(DateTimeOffset dateBegin, DateTimeOffset dateEnd, CancellationToken token);
/// <summary>
/// Получить диапазон дат, для которых есть данные в репозитории
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
Task<IActionResult> GetDatesRangeAsync(CancellationToken token);
Task<IActionResult> Get(DateTimeOffset dateBegin, CancellationToken token);
/// <summary>
/// Добавление записей
@ -36,7 +28,7 @@ public interface ITimeSeriesDataApi<TDto>
/// <param name="dtos"></param>
/// <param name="token"></param>
/// <returns></returns>
Task<IActionResult> InsertRangeAsync(IEnumerable<TDto> dtos, CancellationToken token);
Task<IActionResult> InsertRange(IEnumerable<TDto> dtos, CancellationToken token);
}

2
Persistence/Models/ChangeLogDto.cs
View File

@ -26,7 +26,7 @@ public class ChangeLogDto<T> where T: class
public DateTimeOffset Creation { get; set; }
/// <summary>
/// Дата устаревания (например при удалении)
/// Дата устаревания (например, при удалении)
/// </summary>
public DateTimeOffset? Obsolete { get; set; }

2
Persistence/Repositories/ITableDataRepository.cs
View File

@ -15,5 +15,5 @@ public interface ITableDataRepository<TDto, TRequest>
/// <param name="request">параметры фильтрации</param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<TDto>> GetAsync(TRequest request, CancellationToken token);
Task<IEnumerable<TDto>> Get(TRequest request, CancellationToken token);
}

11
Persistence/Repositories/IGraphDataRepository.cs → Persistence/Repositories/ITimeSeriesBaseRepository.cs
View File

@ -5,22 +5,25 @@ namespace Persistence.Repositories;
/// <summary>
/// Интерфейс по работе с прореженными данными
/// </summary>
public interface IGraphDataRepository<TDto>
public interface ITimeSeriesBaseRepository<TDto>
where TDto : class, new()
{
/// <summary>
/// Получить список объектов с прореживанием
/// </summary>
/// <param name="dateBegin">дата начала</param>
/// <param name="dateEnd">дата окончания</param>
/// <param name="approxPointsCount"></param>
/// <returns></returns>
Task<IEnumerable<TDto>> GetThinnedDataAsync(DateTimeOffset dateBegin, DateTimeOffset dateEnd, int approxPointsCount = 1024);
Task<IEnumerable<TDto>> GetResampledData(
DateTimeOffset dateBegin,
double intervalSec = 600d,
int approxPointsCount = 1024,
CancellationToken token = default);
/// <summary>
/// Получить диапазон дат, для которых есть данные в репозитории
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
Task<DatesRangeDto> GetDatesRangeAsync(CancellationToken token);
Task<DatesRangeDto?> GetDatesRange(CancellationToken token);
}

32
Persistence/Repositories/ITimeSeriesDataRepository.cs
View File

@ -6,24 +6,9 @@ namespace Persistence.Repositories;
/// Интерфейс по работе с временными данными
/// </summary>
/// <typeparam name="TDto"></typeparam>
public interface ITimeSeriesDataRepository<TDto> : ISyncRepository<TDto>
public interface ITimeSeriesDataRepository<TDto> : ISyncRepository<TDto>, ITimeSeriesBaseRepository<TDto>
where TDto : class, ITimeSeriesAbstractDto, new()
{
/// <summary>
/// Получить страницу списка объектов
/// </summary>
/// <param name="dateBegin">дата начала</param>
/// <param name="dateEnd">дата окончания</param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<TDto>> GetAsync(DateTimeOffset dateBegin, DateTimeOffset dateEnd, CancellationToken token);
/// <summary>
/// Получить диапазон дат, для которых есть данные в репозитории
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
Task<DatesRangeDto> GetDatesRangeAsync(CancellationToken token);
/// <summary>
/// Добавление записей
/// </summary>
@ -31,19 +16,4 @@ public interface ITimeSeriesDataRepository<TDto> : ISyncRepository<TDto>
/// <param name="token"></param>
/// <returns></returns>
Task<int> InsertRange(IEnumerable<TDto> dtos, CancellationToken token);
/// <summary>
/// Получение списка последних записей
/// </summary>
/// <param name="takeCount">количество записей</param>
/// <param name="token"></param>
/// <returns></returns>
Task<IEnumerable<TDto>> GetLastAsync(int takeCount, CancellationToken token);
/// <summary>
/// Получение первой записи
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
Task<TDto?> GetFirstAsync(CancellationToken token);
}