xAiModels/Providers/Dtos/XAiProjectRepositoryService.cs

using System;
using System.Linq;
using xModels.Dtos;
using System.Threading;
using xCommons.Extensions;
using xAiModels.Interfaces;
using xAiModels.Models.Dtos;
using System.Threading.Tasks;
using xDataService.Providers;
using xAiModels.Configurations;
using xAiModels.Interfaces.Dtos;
using xAiModels.Models.Entities;
using System.Collections.Generic;
using xIdentityService.Interfaces;
using xIdentityService.Extensions;
using xAiModels.Interfaces.Entities;

namespace xAiModels.Providers.Dtos
{
    public class XAiProjectRepositoryService : XBaseRepositoryService<XAiProject, XAiProjectDto, Guid>, IXAiProjectRepositoryService
    {
        private readonly IXIdentityProvider identityProvider;
        private readonly IXAiMessageRepository messageRepository;
        private readonly IXAiConversationRepository conversationRepository;
        private readonly IXAiProjectTitleResourceProvider projectTitleResourceProvider;
        private readonly IXAiConversationTitleResourceProvider conversationTitleResourceProvider;
        private readonly IXAiProjectDescriptionResourceProvider projectDescriptionResourceProvider;

        public XAiProjectRepositoryService(
            IXAiProjectRepository repository,
            IXIdentityProvider identityProvider,
            IXAiMessageRepository messageRepository,
            IXAiConversationRepository conversationRepository,
            IXAiProjectTitleResourceProvider projectTitleResourceProvider,
            IXAiConversationTitleResourceProvider conversationTitleResourceProvider,
            IXAiProjectDescriptionResourceProvider projectDescriptionResourceProvider
        ) : base(
            repository,
            mapperProfiles:
            [
                new XAiModelMappersProfile()
            ]
        )
        {
            //
            this.identityProvider = identityProvider;
            this.messageRepository = messageRepository;
            this.conversationRepository = conversationRepository;
            this.projectTitleResourceProvider = projectTitleResourceProvider;
            this.conversationTitleResourceProvider = conversationTitleResourceProvider;
            this.projectDescriptionResourceProvider = projectDescriptionResourceProvider;
        }

        //
        #region Enrichers ...
        /// <summary>
        /// Enrich Specified Item ...
        /// </summary>
        /// <param name="source"></param>
        /// <param name="fillConversations"></param>
        /// <param name="fillConversationMessages"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<XAiProjectDto> Enrich(
            XAiProject source,
            bool fillConversations = false,
            bool fillConversationMessages = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            // Mapping Default ...
            var result = Mapper.Map<XAiProjectDto>(source);
            result = await Enrich(
                source: result,
                fillConversations: fillConversations,
                cancellationToken: cancellationToken,
                fillConversationMessages: fillConversationMessages                
            );

            //
            return result;
        }

        /// <summary>
        /// Enrich Specified Item ...
        /// </summary>
        /// <param name="source"></param>
        /// <param name="fillConversations"></param>
        /// <param name="fillConversationMessages"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<XAiProjectDto> Enrich(
            XAiProjectDto source,
            bool fillConversations = false,
            bool fillConversationMessages = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            // Handle Owner ...
            XPersonDto owner = null;
            if (!source.OwnerId.IsNullOrEmpty())
            {
                //
                // Try to Retrieve User Info ...
                var device = identityProvider.GetDevice();
                var userInfo = await identityProvider.GetUserInfo(
                    device: device,
                    userSelectByParam: source.OwnerId
                );
                owner = userInfo.ToXPersonDto();
            }

            //
            // Handle Title ...            
            XResourceDto titleResource = null;
            if (!source.Title.IsNullOrEmpty())
            {
                //
                titleResource = await projectTitleResourceProvider.GetResource(
                    owner: source.OwnerId,
                    identifier: source.Id,
                    cancellationToken: cancellationToken
                );
            }

            //
            // Handle Description ...
            XResourceDto descriptionResource = null;
            if (!source.Description.IsNullOrEmpty())
            {
                //
                descriptionResource = await projectDescriptionResourceProvider.GetResource(
                    owner: source.OwnerId,
                    identifier: source.Id,
                    cancellationToken: cancellationToken
                );
            }

            //
            // Handle Conversations ...
            IEnumerable<XAiConversationDto> conversations = [];
            if (fillConversations)
            {
                //
                // Reading Entities ...
                var entitiies = await conversationRepository.FindManyAsync(
                    includeBuilder: null,
                    ignoreSoftDeleteds: true,
                    cancellationToken: cancellationToken,
                    predicate: x => x.ProjectId == source.Id,
                    orderBuilder: x => x.OrderBy(y => y.CreatedOn)
                );

                //
                // Converts to Dto Enumerable ...
                conversations = entitiies
                    .MapConvert<XAiConversationDto, XAiConversation>();

                //
                // Handle Conversation Enrichment ...
                foreach (var conversation in conversations)
                {
                    //
                    // Handle Owner ...
                    if (!conversation.OwnerId.IsNullOrEmpty())
                    {
                        conversation.Owner = owner;
                    }

                    //
                    // Handle Title Resource ...
                    if (!conversation.Title.IsNullOrEmpty())
                    {
                        //
                        conversation.TitleResource = await conversationTitleResourceProvider.GetResource(
                            owner: source.OwnerId,
                            identifier: conversation.Id,
                            cancellationToken: cancellationToken
                        );
                    }

                    //
                    // Handle Project Info ...
                    if (!conversation.ProjectId.IsDefaultGuid())
                    {
                        conversation.ProjectTitle = source.Title;
                        conversation.ProjectTitleResource = titleResource;
                        conversation.ProjectDescription = source.Description;
                        conversation.ProjectDescriptionResource = descriptionResource;
                    }
                }

                //
                // Handle Fill Messages ...
                if (fillConversationMessages)
                {
                    //
                    foreach (var conversation in conversations)
                    {
                        //
                        IEnumerable<XAiMessageDto> messages = [];

                        //
                        // Retrieve Message Entities ...
                        var messageEntities = await messageRepository.FindManyAsync(
                            includeBuilder: null,
                            ignoreSoftDeleteds: true,
                            cancellationToken: cancellationToken,
                            orderBuilder: x => x.OrderBy(y => y.CreatedOn),
                            predicate: x => x.ConversationId == conversation.Id
                        );
                        if (messageEntities.HasChild())
                        {
                            //
                            // Converts to Message ...
                            messages = messageEntities
                                .MapConvert<XAiMessageDto, XAiMessage>();

                            //
                            // Ennrich Messages ...
                            foreach (var message in messages)
                            {
                                //
                                // Handle Owner ...
                                if (!message.OwnerId.IsNullOrEmpty())
                                {
                                    message.Owner = owner;
                                }

                                //
                                // Handle Conversation ...
                                if (!message.ConversationId.IsDefaultGuid())
                                {
                                    message.ConversationTitle = conversation.Title;
                                    message.ConversationTitleResouce = conversation.TitleResource;
                                }
                            }
                        }

                        //
                        conversation.Messages = [.. messages];
                    }
                }
            }

            //
            // Attach Extracted Items ...
            var result = Mapper.Map<XAiProjectDto>(source, options =>
            {
                //
                options.Items[nameof(source.Owner)] = owner;
                options.Items[nameof(source.Conversations)] = conversations;
                options.Items[nameof(source.TitleResource)] = titleResource;
                options.Items[nameof(source.DescriptionResource)] = descriptionResource;
            });

            //
            return result;
        }

        /// <summary>
        /// Enrich Specified Items ...
        /// </summary>
        /// <param name="sources"></param>
        /// <param name="fillConversations"></param>
        /// <param name="fillConversationMessages"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<XAiProjectDto>> EnrichRange(
            IEnumerable<XAiProject> sources,
            bool fillConversations = false,
            bool fillConversationMessages = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            var tasks = sources
                .Select(x => Enrich(
                    source: x,
                    cancellationToken: cancellationToken,
                    fillConversations: fillConversations,
                    fillConversationMessages: fillConversationMessages
                ));

            //
            var result = await Task.WhenAll(tasks);
            return result;
        }

        /// <summary>
        /// Enrich Specified Items ...
        /// </summary>
        /// <param name="sources"></param>
        /// <param name="fillConversations"></param>
        /// <param name="fillConversationMessages"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<XAiProjectDto>> EnrichRange(
            IEnumerable<XAiProjectDto> sources,
            bool fillConversations = false,
            bool fillConversationMessages = false,
            CancellationToken cancellationToken = default
        )
        {
            //
            var tasks = sources
                .Select(x => Enrich(
                    source: x,
                    cancellationToken: cancellationToken,
                    fillConversations: fillConversations,
                    fillConversationMessages: fillConversationMessages
                ));

            //
            var result = await Task.WhenAll(tasks);
            return result;
        }
        #endregion        
    }
}