PaiwisePaymentServices.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Json;
using Waher.IoTGateway;
using Waher.Persistence;
using Waher.Runtime.Settings;
 
namespace Paiwise.Internal
{
    public class PaiwisePaymentServices : IBuyEDalerServiceProvider, ISellEDalerServiceProvider, IPaymentServiceProvider, IConfigurableModule
    {
        private static readonly Dictionary<string, KeyValuePair<IBuyEDalerService[], DateTime>> buyEDalerServices =
            new Dictionary<string, KeyValuePair<IBuyEDalerService[], DateTime>>();
        private static readonly Dictionary<string, KeyValuePair<ISellEDalerService[], DateTime>> sellEDalerServices =
            new Dictionary<string, KeyValuePair<ISellEDalerService[], DateTime>>();
 
        public const string TokenIdSetting = "Paiwise.Internal.Token";
 
        public const string HostSetting = "Paiwise.Internal.Host";
 
        public const string TimeoutMinutesSetting = "Paiwise.Internal.TimeoutMinutes";
 
        public PaiwisePaymentServices()
        {
        }
 
        public Task Start()
        {
            return Task.CompletedTask;
        }
 
        public Task Stop()
        {
            return Task.CompletedTask;
        }
 
        public Task<IConfigurablePage[]> GetConfigurablePages()
        {
            return Task.FromResult(new IConfigurablePage[]
            {
                new ConfigurablePage("Paiwise", "/Settings/Paiwise.md", "Admin.Payments.Paiwise")
            });
        }
 
        public string Id => "paiwise";
 
        public string Name => "Paiwise";
 
        public string IconUrl => Gateway.GetUrl("/Images/paiwiseLogo_white.webp");
 
        public int IconWidth => 190;
 
        public int IconHeight => 54;
 
        public async Task<IBuyEDalerService[]> GetServicesForBuyingEDaler(CaseInsensitiveString Currency, CaseInsensitiveString Country)
        {
            string Key = Currency.Value.ToUpper() + " " + Country.Value.ToUpper();
 
            lock (buyEDalerServices)
            {
                if (buyEDalerServices.TryGetValue(Key, out KeyValuePair<IBuyEDalerService[], DateTime> P) &&
                    P.Value.Subtract(DateTime.UtcNow).TotalHours < 1)
                {
                    return P.Key;
                }
            }
 
            string Host = await RuntimeSettings.GetAsync(HostSetting, string.Empty);
            if (string.IsNullOrEmpty(Host))
                return new IBuyEDalerService[0];
 
            string Token = await RuntimeSettings.GetAsync(TokenIdSetting, string.Empty);
            if (string.IsNullOrEmpty(Token))
                return new IBuyEDalerService[0];
 
            StringBuilder Url = new StringBuilder();
 
            Url.Append("https://");
            Url.Append(Host);
            Url.Append("/payment/available-buy-payment-method");
 
            Dictionary<string, object> Request = new Dictionary<string, object>()
            {
                { "currency", Currency.Value },
                { "country", Country.Value }
            };
 
            object Obj = await InternetContent.PostAsync(new Uri(Url.ToString()), Request, Gateway.Certificate,
                new KeyValuePair<string, string>("Authorization", "Bearer " + Token),
                new KeyValuePair<string, string>("Accept", JsonCodec.DefaultContentType));
 
            if (!(Obj is Array Services))
                return new IBuyEDalerService[0];
 
            List<IBuyEDalerService> Result = new List<IBuyEDalerService>();
 
            foreach (object Obj2 in Services)
            {
                if (!(Obj2 is Dictionary<string, object> Service &&
                    Service.TryGetValue("id", out Obj) && Obj is string Id &&
                    Service.TryGetValue("displayName", out Obj) && Obj is string DisplayName &&
                    Service.TryGetValue("logo", out Obj) && Obj is Dictionary<string, object> Logo &&
                    Logo.TryGetValue("url", out Obj) && Obj is string LogoUrl &&
                    Logo.TryGetValue("width", out Obj) && Obj is int LogoWidth &&
                    Logo.TryGetValue("height", out Obj) && Obj is int LogoHeight &&
                    Service.TryGetValue("contractId", out object ContractId) &&
                    Service.TryGetValue("fields", out Obj) && Obj is Array Fields &&
                    Service.TryGetValue("endpoint", out Obj) && Obj is Dictionary<string, object> Endpoint &&
                    Endpoint.TryGetValue("method", out Obj) && Obj is string Method &&
                    string.Compare(Method, "POST", true) == 0 &&
                    Endpoint.TryGetValue("url", out Obj) && Obj is string ServiceUrl))
                {
                    continue;
                }
 
                if (!Endpoint.TryGetValue("optionsUrl", out Obj) || !(Obj is string OptionsUrl))
                    OptionsUrl = null;
 
                List<ServiceField> ServiceFields = new List<ServiceField>();
 
                foreach (object Obj3 in Fields)
                {
                    if (!(Obj3 is Dictionary<string, object> Field &&
                        Field.TryGetValue("field", out Obj) && Obj is string FieldId &&
                        Field.TryGetValue("dataType", out Obj) && Obj is string DataType &&
                        Field.TryGetValue("required", out Obj) && Obj is bool Required))
                    {
                        continue;
                    }
 
                    ServiceFields.Add(new ServiceField(FieldId, DataType, Required));
                }
 
                Result.Add(new BuyEDalerPaymentService(Id, DisplayName, LogoUrl, LogoWidth, LogoHeight,
                    ContractId?.ToString(), Method, ServiceUrl, OptionsUrl, ServiceFields.ToArray(), Host, this));
            }
 
            IBuyEDalerService[] Result2 = Result.ToArray();
 
            lock (buyEDalerServices)
            {
                buyEDalerServices[Key] = new KeyValuePair<IBuyEDalerService[], DateTime>(Result2, DateTime.UtcNow);
            }
 
            return Result2;
        }
 
        public async Task<IBuyEDalerService> GetServiceForBuyingEDaler(string ServiceId, CaseInsensitiveString Currency, CaseInsensitiveString Country)
        {
            foreach (IBuyEDalerService Service in await this.GetServicesForBuyingEDaler(Currency, Country))
            {
                if (Service.Id == ServiceId)
                    return Service;
            }
 
            return null;
        }
 
        public async Task<IPaymentService[]> GetServicesForPayment(CaseInsensitiveString Currency, CaseInsensitiveString Country)
        {
            IBuyEDalerService[] Services = await this.GetServicesForBuyingEDaler(Currency, Country);
            List<IPaymentService> Result = new List<IPaymentService>();
 
            foreach (IBuyEDalerService Service in Services)
            {
                if (Service is BuyEDalerPaymentService PaymentService && PaymentService.CanBeUsedForPayment)
                    Result.Add(PaymentService);
            }
 
            return Result.ToArray();
        }
 
        public async Task<IPaymentService> GetServiceForPayment(string ServiceId, CaseInsensitiveString Currency, CaseInsensitiveString Country)
        {
            IBuyEDalerService Service = await this.GetServiceForBuyingEDaler(ServiceId, Currency, Country);
            if (Service is BuyEDalerPaymentService PaymentService && PaymentService.CanBeUsedForPayment)
                return PaymentService;
            else
                return null;
        }
 
        public async Task<ISellEDalerService[]> GetServicesForSellingEDaler(CaseInsensitiveString Currency, CaseInsensitiveString Country)
        {
            string Key = Currency.Value.ToUpper() + " " + Country.Value.ToUpper();
 
            lock (sellEDalerServices)
            {
                if (sellEDalerServices.TryGetValue(Key, out KeyValuePair<ISellEDalerService[], DateTime> P) &&
                    P.Value.Subtract(DateTime.UtcNow).TotalHours < 1)
                {
                    return P.Key;
                }
            }
 
            string Host = await RuntimeSettings.GetAsync(HostSetting, string.Empty);
            if (string.IsNullOrEmpty(Host))
                return new ISellEDalerService[0];
 
            string Token = await RuntimeSettings.GetAsync(TokenIdSetting, string.Empty);
            if (string.IsNullOrEmpty(Token))
                return new ISellEDalerService[0];
 
            StringBuilder Url = new StringBuilder();
 
            Url.Append("https://");
            Url.Append(Host);
            Url.Append("/payout/available-sell-payment-method");
 
            Dictionary<string, object> Request = new Dictionary<string, object>()
            {
                { "currency", Currency.Value },
                { "country", Country.Value }
            };
 
            object Obj = await InternetContent.PostAsync(new Uri(Url.ToString()), Request, Gateway.Certificate,
                new KeyValuePair<string, string>("Authorization", "Bearer " + Token),
                new KeyValuePair<string, string>("Accept", JsonCodec.DefaultContentType));
 
            if (!(Obj is Array Services))
                return new ISellEDalerService[0];
 
            List<ISellEDalerService> Result = new List<ISellEDalerService>();
 
            foreach (object Obj2 in Services)
            {
                if (!(Obj2 is Dictionary<string, object> Service &&
                    Service.TryGetValue("id", out Obj) && Obj is string Id &&
                    Service.TryGetValue("displayName", out Obj) && Obj is string DisplayName &&
                    Service.TryGetValue("logo", out Obj) && Obj is Dictionary<string, object> Logo &&
                    Logo.TryGetValue("url", out Obj) && Obj is string LogoUrl &&
                    Logo.TryGetValue("width", out Obj) && Obj is int LogoWidth &&
                    Logo.TryGetValue("height", out Obj) && Obj is int LogoHeight &&
                    Service.TryGetValue("contractId", out object ContractId) &&
                    Service.TryGetValue("fields", out Obj) && Obj is Array Fields &&
                    Service.TryGetValue("endpoint", out Obj) && Obj is Dictionary<string, object> Endpoint &&
                    Endpoint.TryGetValue("method", out Obj) && Obj is string Method &&
                    string.Compare(Method, "POST", true) == 0 &&
                    Endpoint.TryGetValue("url", out Obj) && Obj is string ServiceUrl))
                {
                    continue;
                }
 
                if (!Endpoint.TryGetValue("optionsUrl", out Obj) || !(Obj is string OptionsUrl))
                    OptionsUrl = null;
 
                List<ServiceField> ServiceFields = new List<ServiceField>();
 
                foreach (object Obj3 in Fields)
                {
                    if (!(Obj3 is Dictionary<string, object> Field &&
                        Field.TryGetValue("field", out Obj) && Obj is string FieldId &&
                        Field.TryGetValue("dataType", out Obj) && Obj is string DataType &&
                        Field.TryGetValue("required", out Obj) && Obj is bool Required))
                    {
                        continue;
                    }
 
                    ServiceFields.Add(new ServiceField(FieldId, DataType, Required));
                }
 
                Result.Add(new SellEDalerPaymentService(Id, DisplayName, LogoUrl, LogoWidth, LogoHeight,
                    ContractId?.ToString(), Method, ServiceUrl, OptionsUrl, ServiceFields.ToArray(), Host, this));
            }
 
            ISellEDalerService[] Result2 = Result.ToArray();
 
            lock (sellEDalerServices)
            {
                sellEDalerServices[Key] = new KeyValuePair<ISellEDalerService[], DateTime>(Result2, DateTime.UtcNow);
            }
 
            return Result2;
        }
 
        public async Task<ISellEDalerService> GetServiceForSellingEDaler(string ServiceId, CaseInsensitiveString Currency, CaseInsensitiveString Country)
        {
            foreach (ISellEDalerService Service in await this.GetServicesForSellingEDaler(Currency, Country))
            {
                if (Service.Id == ServiceId)
                    return Service;
            }
 
            return null;
        }
 
    }
}