DD.WellWorkover.Cloud/AsbCloudInfrastructure/Services/SAUB/MessageService.cs

using AsbCloudApp.Data;
using AsbCloudApp.Data.SAUB;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb;
using AsbCloudDb.Model;
using AsbCloudInfrastructure.EfCache;
using Mapster;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace AsbCloudInfrastructure.Services.SAUB
{
    public class MessageService : IMessageService
    {
        private readonly IAsbCloudDbContext db;
        private readonly ITelemetryService telemetryService;

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

        public async Task<PaginationContainer<MessageDto>> GetMessagesAsync(MessageRequest request, CancellationToken token)
        {
            var idWell = request.IdWell;
            var categoryids = request.Categoryids;
            var searchString = request.SearchString;
            var begin = request.Begin;
            var end = request.End;
            var skip = request.Skip ?? 0;
            var take = request.Take ?? 32;
            var sortFields = request.SortFields;

            var idTelemetry = telemetryService.GetOrDefaultIdTelemetryByIdWell(idWell);
            if (idTelemetry is null)
                return null;

            var allEvents = await db.TelemetryEvents.FromCacheAsync(token);
            var events = allEvents.Where(e => e.IdTelemetry == idTelemetry);

            if (!events.Any())
                return null;

            var query = db.TelemetryMessages.Where(m => m.IdTelemetry == idTelemetry)
                .OrderBy(m => m.DateTime).AsNoTracking();

            if (categoryids?.Any() == true || !string.IsNullOrEmpty(searchString))
            {
                if (!string.IsNullOrEmpty(searchString))
                    events = events.Where(e => e.MessageTemplate.Contains(searchString, StringComparison.OrdinalIgnoreCase));

                if (categoryids?.Any() == true)
                    events = events.Where(e => categoryids.ToList().Contains(e.IdCategory));

                var eventIds = events.Select(e => e.IdEvent);

                if (!eventIds.Any())
                    return null;

                query = query.Where(m => eventIds.Contains(m.IdEvent));
            }

            query = query.OrderByDescending(m => m.DateTime);

            var timezone = telemetryService.GetTimezone(idTelemetry ?? default);

            if (begin != default)
            {
                var beginUtc = begin.Value.ToUtcDateTimeOffset(timezone.Hours);
                query = query.Where(m => m.DateTime >= beginUtc);
            }

            if (end != default)
            {
                var endUtc = end.Value.ToUtcDateTimeOffset(timezone.Hours);
                query = query.Where(m => m.DateTime <= endUtc);
            }

            var result = new PaginationContainer<MessageDto>
            {
                Skip = skip,
                Take = take,
                Count = query.Count()
            };

            var hasAllSortedFieldsInDBOType = false;

            if (sortFields?.Any() == true)
            {
                hasAllSortedFieldsInDBOType = hasAllFieldsInType<TelemetryMessage>(sortFields);
                if (hasAllSortedFieldsInDBOType)
                {
                    query = query
                        .SortBy(request.SortFields)
                        .Skip(skip)
                        .Take(take);
                }
            }
            else
            {
                query = query
                    .Skip(skip)
                    .Take(take);
            }

            var messagesList = await query.AsNoTracking()
                .ToListAsync(token).ConfigureAwait(false);

            if (messagesList.Count == 0)
                return result;

            var allUsers = await db.TelemetryUsers.FromCacheAsync(token);
            var users = allUsers.Where(u => u.IdTelemetry == idTelemetry);

            var eventsDict = events.GroupBy(x => x.IdEvent).ToDictionary(x => x.Key, x => x.FirstOrDefault());
            var usersDict = users.GroupBy(x => x.IdUser).ToDictionary(x => x.Key, x => x.FirstOrDefault());

            foreach (var message in messagesList)
            {
                var messageDto = new MessageDto
                {
                    Id = message.Id,
                    WellDepth = message.WellDepth
                };

                messageDto.Date = message.DateTime.ToRemoteDateTime(timezone.Hours);

                if (message.IdTelemetryUser is not null)
                {
                    if (usersDict.TryGetValue((int)message.IdTelemetryUser, out TelemetryUser user))
                    {
                        messageDto.User = user.MakeDisplayName();
                    }
                    else
                        messageDto.User = message.IdTelemetryUser.ToString();
                }

                if (eventsDict.TryGetValue(message.IdEvent, out TelemetryEvent e))
                {
                    messageDto.CategoryId = e.IdCategory;
                    messageDto.Message = e.MakeMessageText(message);
                }

                result.Items.Add(messageDto);
            }

            if (sortFields?.Any() == true && !hasAllSortedFieldsInDBOType)
            {
                result.Items = result.Items.AsQueryable()
                    .SortBy(request.SortFields)
                    .Skip(skip)
                    .Take(take)
                    .ToList();
            }
            return result;
        }

        public Task InsertAsync(string uid, IEnumerable<TelemetryMessageDto> dtos,
            CancellationToken token = default)
        {
            if (!dtos.Any())
                return null;

            var telemetryId = telemetryService.GetOrCreateTelemetryIdByUid(uid);
            var timezone = telemetryService.GetTimezone(telemetryId);

            foreach (var dto in dtos)
            {
                var entity = dto.Adapt<TelemetryMessage>();
                entity.Id = 0;
                entity.IdTelemetry = telemetryId;
                entity.DateTime = dto.Date.ToUtcDateTimeOffset(timezone.Hours);
                db.TelemetryMessages.Add(entity);
            }

            return db.SaveChangesAsync(token);
        }

        private bool hasAllFieldsInType<T>(IEnumerable<string> sortFields)
        {
            var type = typeof(T);
            var properyNames = type.GetProperties().Select(x => x.Name.ToLower());
            sortFields = sortFields.Select(x => x.ToLower().Split(' ')[0]);
            var result = sortFields.All(field => properyNames.Contains(field));
            return result;
        }
    }
}