gehgassi_app/gehGassiApp/gehGassiApp.Core/Services/Synchronization/SyncService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.Messaging;
using gehGassiApp.Core.Interfaces;
using gehGassiApp.Core.Interfaces.Synchronization;
using gehGassiApp.Core.Messaging;
using gehGassiApp.Domain.Common;
using gehGassiApp.Domain.Dogs;
using gehGassiApp.Domain.Messages;
using gehGassiApp.Domain.News;
using gehGassiApp.Domain.Users;
using gehGassiApp.Domain.Walkers;
using gehGassiApp.Domain.Walks;

namespace gehGassiApp.Core.Services.Synchronization
{
    /// <summary>
    /// Service der Synchronisierungen initiieren kann
    /// </summary>
    public class SyncService : ISyncService
    {
        private readonly INewsService _newsService;
        private readonly IUserService _userService;
        private readonly IConversationService _conversationService;
        private readonly IMessageService _messageService;
        private readonly IDogRaceService _dogRaceService;
        private readonly IDogService _dogService;
        private readonly IWalkerProfileService _walkerProfileService;
        private readonly IPublicWalkRequestService _publicWalkRequestService;
        private readonly IPublicWalkResponseService _publicWalkResponseService;
        private readonly IWalkService _walkService;
        private readonly IWalkingTimeService _walkingTimeService;
        private readonly IRatingService _ratingService;
        private readonly IFavouriteService _favouriteService;
        private readonly ISystemMessageService _systemMessageService;
        private readonly ITransactionFeeService _transactionFeeService;
        private readonly IPaymentService _paymentService;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="newsService">Instanz eines INewsService</param>
        /// <param name="userService">Instanz eines IUserService</param>
        /// <param name="conversationService">Instanz eines IConversationService</param>
        /// <param name="messageService">Instanz eines IMessageService</param>
        /// <param name="dogRaceService">Instanz eines IDogRaceService</param>
        /// <param name="dogService">Instanz eines IDogService</param>
        /// <param name="walkerProfileService">Instanz eines IWalkerProfileService</param>
        /// <param name="publicWalkRequestService">Instanz eines IPublicWalkRequestService</param>
        /// <param name="publicWalkResponseService">Instanz eines IPublicWalkResponseService</param>
        /// <param name="walkService">Instanz eines IWalkService</param>
        /// <param name="walkingTimeService">Instanz eines IWalkingTimeService</param>
        /// <param name="ratingService">Instanz eines IRatingService</param>
        /// <param name="favouriteService">Instanz eines IFavouriteService</param>
        /// <param name="systemMessageService">Instanz eines ISystemMessageService</param>
        /// <param name="transactionFeeService">Instanz eines ITransactionFeeService</param>
        /// <param name="paymentService">Instanz eines IPaymentService</param>
        public SyncService(INewsService newsService, IUserService userService, IConversationService conversationService, IMessageService messageService, IDogRaceService dogRaceService, IDogService dogService, IWalkerProfileService walkerProfileService, 
            IPublicWalkRequestService publicWalkRequestService, IPublicWalkResponseService publicWalkResponseService, IWalkService walkService, IWalkingTimeService walkingTimeService, IRatingService ratingService, IFavouriteService favouriteService, 
            ISystemMessageService systemMessageService, ITransactionFeeService transactionFeeService, IPaymentService paymentService)
        {
            _newsService = newsService;
            _userService = userService;
            _conversationService = conversationService;
            _messageService = messageService;
            _dogRaceService = dogRaceService;
            _dogService = dogService;
            _walkerProfileService = walkerProfileService;
            _publicWalkRequestService = publicWalkRequestService;
            _publicWalkResponseService = publicWalkResponseService;
            _walkService = walkService;
            _walkingTimeService = walkingTimeService;
            _ratingService = ratingService;
            _favouriteService = favouriteService;
            _systemMessageService = systemMessageService;
            _transactionFeeService = transactionFeeService;
            _paymentService = paymentService;
        }

        /// <summary>
        /// App-User Synchronisieren
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncAppUserAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _userService.PushAsync(accessToken, token);
            var pullResult = await _userService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new AppUserChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Walker-Profil Synchronisieren
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncWalkerProfileAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _walkerProfileService.PushAsync(accessToken, token);
            var pullResult = await _walkerProfileService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new DogWalkerProfileChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Konversationen Synchronisieren
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncConversationsAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _conversationService.PushAsync(accessToken, token);
            var pullResult = await _conversationService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new ConversationsChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Nachrichten synchronisieren
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncMessagesAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _messageService.PushAsync(accessToken, token);
            var pullResult = await _messageService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new ConversationsUnreadChangedMessage());
                if (pullResult.Added.Any())
                {
                    var groups = pullResult.Added.GroupBy(c => c.ConversationId);
                    foreach (var group in groups)
                    {
                        WeakReferenceMessenger.Default.Send(new SignalRConversationMessageAddedMessage(group.Key));
                    }
                }
            }
        }

        /// <summary>
        /// Synchronisieren der News-Kategorien
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncNewsCategoriesAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _newsService.PushAsync(accessToken, token);
            var pullResult = await _newsService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new NewsCategoriesChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der Hunderassen
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncDogRacesAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _dogRaceService.PushAsync(accessToken, token);
            var pullResult = await _dogRaceService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new DogRacesChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der Hunde
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncDogsAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _dogService.PushAsync(accessToken, token);
            var pullResult = await _dogService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new DogsChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der offenen Anfragen
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncPublicWalkRequestsAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _publicWalkRequestService.PushAsync(accessToken, token);
            var pullResult = await _publicWalkRequestService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new PublicWalkRequestsChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der Antworten auf offenen Anfragen
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncPublicWalkResponsesAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _publicWalkResponseService.PushAsync(accessToken, token);
            var pullResult = await _publicWalkResponseService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new PublicWalkResponsesChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der Walks
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncWalksAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _walkService.PushAsync(accessToken, token);
            var pullResult = await _walkService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new WalksChangedMessage(pullResult));
                WeakReferenceMessenger.Default.Send(new WalkRequestedChangedMessage());
            }
        }

        /// <summary>
        /// Synchronisieren der WalkintgTimes
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncWalkingTimesAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _walkingTimeService.PushAsync(accessToken, token);
            var pullResult = await _walkingTimeService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new WalkingTimesChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der Ratings
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncRatingsAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _ratingService.PushAsync(accessToken, token);
            var pullResult = await _ratingService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new RatingsChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der Favoriten
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncFavouritesAsync(string language, string accessToken, CancellationToken token)
        {
            var pushResult = await _favouriteService.PushAsync(accessToken, token);
            var pullResult = await _favouriteService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new FavouritesChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der Favoriten
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncSystemMessagesAsync(string language, string accessToken, CancellationToken token)
        {
            //Bewusst kein Push
            var pullResult = await _systemMessageService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new SystemMessagesChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der Transaktionsgebühren
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncTransactionFeesAsync(string language, string accessToken, CancellationToken token)
        {
            //Bewusst kein Push
            var pullResult = await _transactionFeeService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new TransactionFeesChangedMessage(pullResult));
            }
        }

        /// <summary>
        /// Synchronisieren der Auszahlungen
        /// </summary>
        /// <param name="language">Gewünschte Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>Task</returns>
        public async Task SyncPayoutsAsync(string language, string accessToken, CancellationToken token)
        {
            //Bewusst kein Push
            var pullResult = await _paymentService.PullAsync(language, accessToken, token);
            if (pullResult.HasChanges)
            {
                //Nun Events auslösen wenn nötig
                WeakReferenceMessenger.Default.Send(new PayoutsChangedMessage(pullResult));
            }
        }
    }
}