DD.WellWorkover.Cloud/AsbCloudInfrastructure/Repository/DataSaubStatRepository.cs

using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using Mapster;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace AsbCloudInfrastructure.Repository;
public class DataSaubStatRepository<TEntity, TDto> : IDataSaubStatRepository<TDto>
    where TDto : AsbCloudApp.Data.IDataSaubStatDto
    where TEntity : class, AsbCloudDb.Model.IDataSaubStat
{
    private readonly IAsbCloudDbContext db;
    private readonly ITelemetryService telemetryService;

    public DataSaubStatRepository(IAsbCloudDbContext dbContext, ITelemetryService telemetryService)
    {
        db = dbContext;
        this.telemetryService = telemetryService;
    }

    public async Task<IEnumerable<TDto>> GetLastsAsync(int[] idTelemetries, CancellationToken token)
    {
        var timeZoneOffsets = idTelemetries
            .Distinct()
            .ToDictionary(idTelemetry => idTelemetry, idTelemetry => TimeSpan.FromHours(telemetryService.GetTimezone(idTelemetry).Hours));

        var stats = await db.Set<TEntity>()
            .Where(s => idTelemetries.Contains(s.IdTelemetry))
            .GroupBy(s => s.IdTelemetry, (key, group) => group.OrderByDescending(el => el.DateEnd).First())
            .ToArrayAsync(token);

        var result = stats.Select(s => ConvertToDto(s, timeZoneOffsets[s.IdTelemetry]));

        return result;
    }

    public async Task<IEnumerable<TDto>> GetAsync(IEnumerable<int> idsTelemetries, DateTimeOffset geDate, DateTimeOffset leDate, CancellationToken token)
    {
        //todo
        var timeSpanDict = new Dictionary<int, TimeSpan>();

        idsTelemetries = idsTelemetries.Distinct();
        foreach (var idTelemetry in idsTelemetries)
        {
            var timeSpan = TimeSpan.FromHours(telemetryService.GetTimezone(idTelemetry).Hours);
            timeSpanDict.Add(idTelemetry, timeSpan);
        }

        var geDateUtc = geDate.ToUniversalTime();
        var leDateUtc = leDate.ToUniversalTime();

        var stats = await db.Set<TEntity>()
            .Where(s => idsTelemetries.Contains(s.IdTelemetry))
            .Where(s => s.DateStart >= geDateUtc)
            .Where(s => s.DateEnd <= leDateUtc)
            .ToArrayAsync(token);

        var result = stats.Select(s => ConvertToDto(s, timeSpanDict[s.IdTelemetry]));

        return result;
    }

    public async Task<int> InsertRangeAsync(IEnumerable<TDto> dataSaubStats, CancellationToken token)
    {
        var entities = dataSaubStats.Select(data => ConvertToEntity(data));
        db.Set<TEntity>().AddRange(entities);
        return await db.SaveChangesAsync(token);
    }

    private static TDto ConvertToDto(TEntity entity, TimeSpan timeSpan)
    {
        var dto = entity.Adapt<TDto>();
        dto.DateStart = dto.DateStart.ToOffset(timeSpan);
        dto.DateEnd = dto.DateEnd.ToOffset(timeSpan);

        return dto;
    }

    private static TEntity ConvertToEntity(TDto dto)
    {
        var entity = dto.Adapt<TEntity>();
        entity.DateStart = dto.DateStart.ToUniversalTime();
        entity.DateEnd = dto.DateEnd.ToUniversalTime();

        return entity;
    }

    private IQueryable<TEntity> BuildQuery(TelemetryPartDeleteRequest request)
    {
        var query = db.Set<TEntity>()
            .Where(o => o.IdTelemetry == request.IdTelemetry);

        if (request.LeDate is not null)
        {
            var leDate = request.LeDate.Value.ToUniversalTime();
            query = query.Where(o => o.DateStart <= leDate);
        }

        if (request.GeDate is not null)
        {
            var geDate = request.GeDate.Value.ToUniversalTime();
            query = query.Where(o => o.DateEnd >= geDate);
        }

        return query;
    }

    public async Task<int> DeleteAsync(TelemetryPartDeleteRequest request, CancellationToken token)
    {
        var query = BuildQuery(request);
        db.Set<TEntity>().RemoveRange(query);
        return await db.SaveChangesAsync(token);
    }
}