gehgassi_app/gehGassiApp/gehGassiApp.Core/Services/SubscriptionService.cs

using gehGassi.Dto;
using gehGassiApp.Core.Interfaces;
using gehGassiApp.Core.Resources;
using gehGassiApp.Domain.Common;
using gehGassiApp.Domain.Subscriptions;
using Platform = gehGassiApp.Domain.Common.Platform;

namespace gehGassiApp.Core.Services
{
    /// <summary>
    /// Service für die Verwaltung von Abonnements
    /// </summary>
    public class SubscriptionService : ISubscriptionService
    {
        private readonly ICommunicationService _communicationService;

        /// <summary>
        /// Erstellt eine Instanz
        /// </summary>
        /// <param name="communicationService">Instanz eines ICommunicationService</param>
        public SubscriptionService(ICommunicationService communicationService)
        {
            _communicationService = communicationService;
        }

        /// <summary>
        /// Gibt eine Liste von verfügbaren Abos zurück
        /// </summary>
        /// <param name="appMode">AppMode - Hundebesitzer oder Walker</param>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<List<Subscription>>> GetSubscriptionsAsync(AppMode appMode, string language, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<List<Subscription>>() { Value = null };

            var isConnected = await _communicationService.IsConnected();
            if (isConnected)
            {
                var communicationResult = await _communicationService.GetSubscriptionsAsync(appMode, language, accessToken, token);
                if (communicationResult.Success)
                    return communicationResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Gibt eine Liste von gebuchten Abos zurück
        /// </summary>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<List<AppUserSubscription>>> GetMySubscriptionsAsync(string language, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<List<AppUserSubscription>>() { Value = null };

            var isConnected = await _communicationService.IsConnected();
            if (isConnected)
            {
                var communicationResult = await _communicationService.GetMySubscriptionsAsync(language, accessToken, token);
                if (communicationResult.Success)
                    return communicationResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Gibt eine Liste von gebuchten aktiven Abos zurück
        /// </summary>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<List<AppUserSubscription>>> GetMyActiveSubscriptionsAsync(string language, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<List<AppUserSubscription>>() { Value = null };

            var isConnected = await _communicationService.IsConnected();
            if (isConnected)
            {
                var communicationResult = await _communicationService.GetMyActiveSubscriptionsAsync(language, accessToken, token);
                if (communicationResult.Success)
                    return communicationResult;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Erstellen einer Abo-Buchung
        /// </summary>
        /// <param name="appUserId">AppUserId</param>
        /// <param name="subscriptionId">Id des Abos</param>
        /// <param name="language">Sprache</param>
        /// <param name="inAppBillingPurchase">InAppBillingPurchase serialisiert als JSON</param>
        /// <param name="expirationDateToSet">Optional: Ablaufdatum das gesetzt werden soll</param>
        /// <param name="platform">Plattform auf welcher das Abo erstellt wird</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<AppUserSubscription>> CreateSubscriptionAsync(string appUserId, string subscriptionId, string language, string inAppBillingPurchase, DateTime? expirationDateToSet, Platform platform, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<AppUserSubscription>() { Value = null };

            var isConnected = await _communicationService.IsConnected();
            if (isConnected)
            {
                var communicationResult = await _communicationService.CreateSubscriptionAsync(appUserId, subscriptionId, language, inAppBillingPurchase, expirationDateToSet, platform, accessToken, token);
                if (communicationResult.Success && communicationResult.Value.Status != CreateStatus.Error)
                {
                    if (communicationResult.Value.Status == CreateStatus.Success)
                    {
                        result.Success = true;
                        result.Value = communicationResult.Value.Value;
                    }
                    else
                    {
                        result.Success = false;
                        result.ErrorCode = CommunicationErrors.Subscription_Exists;
                    }
                }
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Wechseln eines Abos in der Gruppe für eine Abo-Buchung
        /// </summary>
        /// <param name="bookingId">Id der Abo-Buchung</param>
        /// <param name="appUserId">AppUserId</param>
        /// <param name="subscriptionId">Id des Abos auf das gechselt werden soll</param>
        /// <param name="language">Sprache</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<AppUserSubscription>> SwitchSubscriptionAsync(long bookingId, string appUserId, string subscriptionId, string language, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<AppUserSubscription>() { Value = null };

            var isConnected = await _communicationService.IsConnected();
            if (isConnected)
            {
                var communicationResult = await _communicationService.SwitchSubscriptionAsync(bookingId, appUserId, subscriptionId, language, accessToken, token);
                if (communicationResult.Success)
                    return communicationResult;
                
                result.Success = false;
                result.ErrorCode = communicationResult.ErrorCode;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Stornieren einer Abo-Buchung
        /// </summary>
        /// <param name="bookingId">Abo-Buchungs ID</param>
        /// <param name="appUserId">AppUserId</param>
        /// <param name="language">Sprache</param>
        /// <param name="platform">Plattform auf der das Abo erstellt wurde</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<AppUserSubscription>> CancelSubscriptionAsync(long bookingId, string appUserId, string language, Platform platform, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<AppUserSubscription>() { Value = null };

            var isConnected = await _communicationService.IsConnected();
            if (isConnected)
            {
                var communicationResult = await _communicationService.CancelSubscriptionAsync(bookingId, appUserId, language, platform, accessToken, token);
                if (communicationResult.Success)
                    return communicationResult;

                result.Success = false;
                result.ErrorCode = communicationResult.ErrorCode;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }

        /// <summary>
        /// Verlängern einer Abo-Buchung
        /// </summary>
        /// <param name="bookingId">Abo-Buchungs ID</param>
        /// <param name="appUserId">AppUserId</param>
        /// <param name="language">Sprache</param>
        /// <param name="platform">Plattform auf der das Abo erstellt wurde</param>
        /// <param name="accessToken">Aktuelles Accesstoken</param>
        /// <param name="token">CancellationToken</param>
        /// <returns>CommunicationResult</returns>
        public async Task<CommunicationResult<AppUserSubscription>> RenewSubscriptionAsync(long bookingId, string appUserId, string language, Platform platform, string accessToken, CancellationToken token)
        {
            var result = new CommunicationResult<AppUserSubscription>() { Value = null };

            var isConnected = await _communicationService.IsConnected();
            if (isConnected)
            {
                var communicationResult = await _communicationService.RenewSubscriptionAsync(bookingId, appUserId, language, platform, accessToken, token);
                if (communicationResult.Success)
                    return communicationResult;

                result.Success = false;
                result.ErrorCode = communicationResult.ErrorCode;
            }
            else
            {
                result.Success = false;
                result.ErrorCode = CommunicationErrors.ServerNoConnection;
                result.ErrorMessage = Errors.Server_NoConnection;
            }

            return result;
        }
    }
}