persistence/Persistence.Repository/Repositories/TechMessagesRepository.cs

using Mapster;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
using Persistence.Database.Entity;
using Persistence.Models;
using Persistence.Models.Requests;
using Persistence.Repositories;
using Persistence.Repository.Extensions;

namespace Persistence.Repository.Repositories
{
	public class TechMessagesRepository : ITechMessagesRepository
	{
		private static readonly string SystemCacheKey = $"{typeof(Database.Entity.DrillingSystem).FullName}CacheKey";
		private const int CacheExpirationInMinutes = 60;
		private readonly IMemoryCache memoryCache;
		private DbContext db;

		public TechMessagesRepository(DbContext db, IMemoryCache memoryCache)
		{
			this.memoryCache = memoryCache;
			this.db = db;
		}

		protected virtual IQueryable<TechMessage> GetQueryReadOnly() => db.Set<TechMessage>()
			.Include(e => e.System);

		public async Task<PaginationContainer<TechMessageDto>> GetPage(PaginationRequest request, CancellationToken token)
		{
			var query = GetQueryReadOnly();
			var count = await query.CountAsync(token);

			var sort = request.SortSettings != string.Empty 
				? request.SortSettings 
				: nameof(TechMessage.Timestamp);
			var entities = await query
				.SortBy(request.SortSettings)
				.Skip(request.Skip)
				.Take(request.Take)
				.ToArrayAsync(token);

			var dto = new PaginationContainer<TechMessageDto>()
			{
				Skip = request.Skip,
				Take = request.Take,
				Count = count,
				Items = entities.Select(e => e.Adapt<TechMessageDto>())
			};

			return dto;
		}

		public async Task<IEnumerable<MessagesStatisticDto>> GetStatistics(IEnumerable<string> autoDrillingSystem, IEnumerable<int> categoryIds, CancellationToken token)
		{
			var query = GetQueryReadOnly();
			var systems = autoDrillingSystem.Select(s => s.ToLower().Trim());
			var result = await query
				.Where(e => systems.Count() == 0 || systems.Contains(e.System.Name.ToLower().Trim()))
				.GroupBy(e => e.System.Name, (key, group) => new
				{
					System = key,
					Categories = group
						.Where(g => categoryIds.Count() == 0 || categoryIds.Contains(g.CategoryId))
				})
				.ToArrayAsync(token);

			var entities = new List<MessagesStatisticDto>();
			foreach (var e in result)
			{
				var categories = e.Categories
					.GroupBy(g => g.CategoryId)
					.ToDictionary(c => c.Key, v => v.Count());
				var entity = new MessagesStatisticDto()
				{
					System = e.System,
					Categories = categories
				};
				entities.Add(entity);
			}

			return entities;
		}

		public async Task<IEnumerable<string>> GetSystems(CancellationToken token)
		{
			var entities = await GetDrillingSystems(token);
			var result = entities.Select(e => e.Name);

			return result;
		}

		public async Task<int> AddRange(IEnumerable<TechMessageDto> dtos, Guid userId, CancellationToken token)
		{

			var entities = new List<TechMessage>();
			foreach (var dto in dtos)
			{
				var entity = dto.Adapt<TechMessage>();
				var systems = await GetDrillingSystems(token);
				var systemId = systems.FirstOrDefault(e => e.Name.ToLower().Trim() == dto.System.ToLower().Trim())?.SystemId
					?? await CreateDrillingSystem(dto.System, token);

				entity.SystemId = systemId;
				entity.UserId = userId;

				entities.Add(entity);
			}

			await db.Set<TechMessage>().AddRangeAsync(entities, token);
			var result = await db.SaveChangesAsync(token);

			return result;
		}

		public async Task<IEnumerable<TechMessageDto>> GetPart(DateTimeOffset dateBegin, int take, CancellationToken token)
		{
			var query = GetQueryReadOnly();
			var entities = await query
				.Where(e => e.Timestamp >= dateBegin)
				.Take(take)
				.ToArrayAsync(token);
			var dtos = entities
				.Select(e => e.Adapt<TechMessageDto>());

			return dtos;
		}

		public async Task<DatesRangeDto> GetDatesRangeAsync(CancellationToken token)
		{
			var query = GetQueryReadOnly()
				.GroupBy(e => 1)
				.Select(group => new
				{
					Min = group.Min(e => e.Timestamp),
					Max = group.Max(e => e.Timestamp),
				});
			var values = await query.FirstOrDefaultAsync(token);
			var result = new DatesRangeDto()
			{
				From = values?.Min ?? DateTimeOffset.MinValue,
				To = values?.Max ?? DateTimeOffset.MaxValue
			};

			return result;
		}

		private async Task<IEnumerable<Models.DrillingSystemDto>> GetDrillingSystems(CancellationToken token)
		{
			var systems = await memoryCache.GetOrCreateAsync(SystemCacheKey, async f =>
			{
				f.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(CacheExpirationInMinutes);

				var query = db.Set<Database.Entity.DrillingSystem>();
				var entities = await query.ToListAsync(token);
				var dtos = entities.Select(e => e.Adapt<Models.DrillingSystemDto>());

				return dtos;
			});

			return systems!;
		}
		private async Task<Guid> CreateDrillingSystem(string name, CancellationToken token)
		{
			memoryCache.Remove(SystemCacheKey);

			var entity = new Database.Entity.DrillingSystem()
			{
				SystemId = default,
				Name = name.ToLower().Trim()
			};

			await db.Set<Database.Entity.DrillingSystem>().AddAsync(entity);
			await db.SaveChangesAsync(token);

			return entity.SystemId;
		}
	}
}