BuyEDalerPaymentService.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Json;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Persistence;
using Waher.Runtime.Inventory;
using Waher.Runtime.Settings;
 
namespace Paiwise.Internal
{
    public class BuyEDalerPaymentService : ServiceProvider, IBuyEDalerService, IPaymentService
    {
        private readonly ServiceField[] fields;
        private readonly string method;
        private readonly string url;
        private readonly string optionsUrl;
        private readonly string host;
 
        public BuyEDalerPaymentService(string Id, string Name, string IconUrl, int IconWidth,
            int IconHeight, string TemplateContractId, string Method, string Url, string OptionsUrl,
            ServiceField[] Fields, string Host, PaiwisePaymentServices Provider)
            : base(Id, Name, IconUrl, IconWidth, IconHeight)
        {
            this.method = Method;
            this.url = Url;
            this.optionsUrl = OptionsUrl;
            this.fields = Fields;
            this.host = Host;
 
            this.BuyEDalerTemplateContractId = TemplateContractId;
            this.BuyEDalerServiceProvider = Provider;
            this.PaymentServiceProvider = Provider;
        }
 
        public string BuyEDalerTemplateContractId { get; }
 
        public IBuyEDalerServiceProvider BuyEDalerServiceProvider { get; }
 
        public Grade Supports(CaseInsensitiveString Currency)
        {
            return !CaseInsensitiveString.IsNullOrEmpty(Currency) &&
                Currency.Length == 3 ? Grade.Ok : Grade.NotAtAll;
        }
 
        public async Task<bool> CanBuyEDaler(CaseInsensitiveString AccountName)
        {
            if (string.Compare(this.method, "POST", true) != 0)
                return false;
 
            string Token = await RuntimeSettings.GetAsync(PaiwisePaymentServices.TokenIdSetting, string.Empty);
 
            return !string.IsNullOrEmpty(Token);
        }
 
        public async Task<PaymentResult> BuyEDaler(IDictionary<CaseInsensitiveString, object> ContractParameters,
            IDictionary<CaseInsensitiveString, CaseInsensitiveString> IdentityProperties,
            decimal Amount, string Currency, string SuccessUrl, string FailureUrl, string CancelUrl,
            EventHandlerAsync<ClientUrlEventArgs> ClientUrlCallback, object State)
        {
            try
            {
                if (Amount <= 0)
                    return new PaymentResult("Amount must be positive.");
 
                if (string.IsNullOrEmpty(Currency) ||
                    Currency.Length != 3 ||
                    Currency.ToUpper() != Currency)
                {
                    return new PaymentResult("Invalid currency.");
                }
 
                Dictionary<string, object> Request = new Dictionary<string, object>()
                {
                    { "webhook", string.Empty }
                };
 
                foreach (ServiceField Field in this.fields)
                {
                    if (ContractParameters.TryGetValue(Field.FieldId, out object Obj))
                        Request[Field.FieldId] = Obj;
                    else if (IdentityProperties.TryGetValue(Field.FieldId, out CaseInsensitiveString Obj2))
                        Request[Field.FieldId] = Obj2.Value;
                    else
                    {
                        switch (Field.FieldId.LowerCase)
                        {
                            case "returnurl":
                                Request[Field.FieldId] = SuccessUrl ?? string.Empty;
                                break;
 
                            case "returnerrorurl":
                                Request[Field.FieldId] = FailureUrl ?? string.Empty;
                                break;
 
                            case "cancelurl":
                                Request[Field.FieldId] = CancelUrl ?? string.Empty;
                                break;
 
                            case "amount":
                                Request[Field.FieldId] = Amount;
                                break;
 
                            case "currency":
                                Request[Field.FieldId] = Currency;
                                break;
 
                            default:
                                if (Field.Required)
                                    return new PaymentResult("Missing Contract or ID property: " + Field.FieldId);
                                break;
                        }
                    }
                }
 
                return await this.ProcessRequest(Request, Amount, Currency, ClientUrlCallback, State);
            }
            catch (Exception ex)
            {
                return new PaymentResult(ex.Message);
            }
        }
 
        private async Task<PaymentResult> ProcessRequest(Dictionary<string, object> Request, decimal Amount, string Currency,
            EventHandlerAsync<ClientUrlEventArgs> ClientUrlCallback, object State)
        {
            // TODO: Proper callback
 
            string Token = await RuntimeSettings.GetAsync(PaiwisePaymentServices.TokenIdSetting, string.Empty);
            if (string.IsNullOrEmpty(Token))
                return new PaymentResult("Paiwise token not configured");
 
            ContentResponse Result = await InternetContent.PostAsync(new Uri(this.url), Request, Gateway.Certificate,
                new KeyValuePair<string, string>("Authorization", "Bearer " + Token),
                new KeyValuePair<string, string>("Accept", JsonCodec.DefaultContentType)); ;
 
            if (Result.HasError)
            {
                Log.Error("Sending paiwise request to " + this.url + ", but an error was returned:" + Result.Error.Message);
 
                return new PaymentResult(Result.Error.Message);
            }
 
            if (!(Result.Decoded is Dictionary<string, object> Response) ||
                !Response.TryGetValue("status", out object Obj) || !(Obj is string Status))
            {
                return new PaymentResult("Invalid response returned from Paiwise");
            }
 
            if (Status == "paid")
            {
                if (Response.TryGetValue("amount", out Obj) && IsDecimal(Obj, out decimal Amount2))
                    Amount = Amount2;
 
                if (Response.TryGetValue("currency", out Obj) && Obj is string Currency2)
                    Currency = Currency2;
 
                return new PaymentResult(Amount, Currency);
            }
 
            if (int.TryParse(Status, out _) &&
                Response.TryGetValue("message", out Obj) && Obj is string Message)
            {
                return new PaymentResult(Message);
            }
 
            if (Status == "pending")        // TODO: Callback, if domain available.
            {
                if (!Response.TryGetValue("id", out Obj) || !(Obj is string TransactionId))
                    return new PaymentResult("No transaction ID returned.");
 
                if (Response.TryGetValue("redirectUrl", out Obj) && Obj is string RedirectUrl)
                {
                    if (ClientUrlCallback is null)
                        return new PaymentResult("No Client URL callback method defined.");
 
                    await ClientUrlCallback.Raise(this, new ClientUrlEventArgs(RedirectUrl, State));
                }
 
                double TimeoutMinutes = await RuntimeSettings.GetAsync(PaiwisePaymentServices.TimeoutMinutesSetting, 5.0);
 
                StringBuilder Url = new StringBuilder();
 
                Url.Append("https://");
                Url.Append(this.host);
                Url.Append("/payment/retrieve");
 
                Request = new Dictionary<string, object>()
                    {
                        { "id", TransactionId }
                    };
 
                DateTime Start = DateTime.Now;
 
                while (Status == "pending" && DateTime.Now.Subtract(Start).TotalMinutes < TimeoutMinutes)
                {
                    await Task.Delay(2000);
 
                    Result = 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 (Result.HasError)
                        return new PaymentResult(Result.Error.Message);
 
                    if (!(Result.Decoded is Dictionary<string, object> Response2) ||
                        !Response2.TryGetValue("status", out Obj) || !(Obj is string Status2))
                    {
                        return new PaymentResult("Invalid polling response returned from Paiwise");
                    }
 
                    if (int.TryParse(Status2, out _) &&
                        Response2.TryGetValue("message", out Obj) && Obj is string Message2)
                    {
                        return new PaymentResult(Message2);
                    }
 
                    Status = Status2;
 
                    if (Status == "paid" &&
                        Response2.TryGetValue("request", out Obj) &&
                        Obj is Dictionary<string, object> Request2)
                    {
                        if (Request2.TryGetValue("amount", out Obj) && IsDecimal(Obj, out decimal Amount2))
                            Amount = Amount2;
 
                        if (Request2.TryGetValue("currency", out Obj) && Obj is string Currency2)
                            Currency = Currency2;
                    }
                }
 
                if (Status == "pending")
                {
                    await Task.Delay(2000);
 
                    Url.Clear();
                    Url.Append("https://");
                    Url.Append(this.host);
                    Url.Append("/payment/cancel");
 
                    Result = 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 (Result.HasError)
                        return new PaymentResult(Result.Error.Message);
 
                    if (!(Result.Decoded is Dictionary<string, object> Response2) ||
                        !Response2.TryGetValue("status", out Obj) || !(Obj is string Status2))
                    {
                        return new PaymentResult("Invalid cancel response returned from Paiwise");
                    }
 
                    if (int.TryParse(Status2, out _) &&
                        Response2.TryGetValue("message", out Obj) && Obj is string Message2)
                    {
                        return new PaymentResult(Message2);
                    }
 
                    Status = Status2;
                }
            }
 
            if (Status == "paid")
                return new PaymentResult(Amount, Currency);
            else if (Status == "cancelled")
                return new PaymentResult("Payment has been cancelled.");
            else
                return new PaymentResult(Status);
        }
 
        private static bool IsDecimal(object Obj, out decimal Result)
        {
            if (Obj is int i)
            {
                Result = i;
                return true;
            }
            else if (Obj is decimal d)
            {
                Result = d;
                return true;
            }
            else if (Obj is double d2)
            {
                Result = (decimal)d2;
                return true;
            }
            else
            {
                Result = 0;
                return false;
            }
        }
 
        public async Task<IDictionary<CaseInsensitiveString, object>[]> GetPaymentOptionsForBuyingEDaler(
            IDictionary<CaseInsensitiveString, CaseInsensitiveString> IdentityProperties,
            string SuccessUrl, string FailureUrl, string CancelUrl,
            EventHandlerAsync<ClientUrlEventArgs> ClientUrlCallback, object State)
        {
            try
            {
                if (string.IsNullOrEmpty(this.optionsUrl))
                    return Array.Empty<IDictionary<CaseInsensitiveString, object>>();
 
                Dictionary<string, object> Request = new Dictionary<string, object>()
                {
                    { "webhook", string.Empty }
                };
 
                foreach (ServiceField Field in this.fields)
                {
                    if (IdentityProperties.TryGetValue(Field.FieldId, out CaseInsensitiveString Obj2))
                        Request[Field.FieldId] = Obj2.Value;
                    else
                    {
                        Request[Field.FieldId] = Field.FieldId.LowerCase switch
                        {
                            "returnurl" => SuccessUrl ?? string.Empty,
                            "returnerrorurl" => FailureUrl ?? string.Empty,
                            "cancelurl" => CancelUrl ?? string.Empty,
                            _ => null,
                        };
                    }
                }
 
                string Token = await RuntimeSettings.GetAsync(PaiwisePaymentServices.TokenIdSetting, string.Empty);
                if (string.IsNullOrEmpty(Token))
                    return Array.Empty<IDictionary<CaseInsensitiveString, object>>();
 
                ContentResponse Result = await InternetContent.PostAsync(new Uri(this.optionsUrl), Request, Gateway.Certificate,
                    new KeyValuePair<string, string>("Authorization", "Bearer " + Token),
                    new KeyValuePair<string, string>("Accept", JsonCodec.DefaultContentType)); ;
 
                if (Result.HasError)
                {
                    Log.Error("Requesting payment options for paiwise request to " + this.optionsUrl + ", but an error was returned:" + Result.Error.Message);
                    return Array.Empty<IDictionary<CaseInsensitiveString, object>>();
                }
 
                if (!(Result.Decoded is Array A))
                    throw new Exception("Unexpected response type returned: " + Result.GetType().FullName);
 
                List<IDictionary<CaseInsensitiveString, object>> Options = new List<IDictionary<CaseInsensitiveString, object>>();
 
                foreach (object Item in A)
                {
                    if (Item is Dictionary<string, object> Option)
                    {
                        Dictionary<CaseInsensitiveString, object> Properties = new Dictionary<CaseInsensitiveString, object>();
 
                        foreach (KeyValuePair<string, object> P in Option)
                            Properties[P.Key] = P.Value;
 
                        Options.Add(Properties);
                    }
                }
 
                return Options.ToArray();
            }
            catch (Exception ex)
            {
                Log.Exception(ex,
                    new KeyValuePair<string, object>("ServiceProvider", this.BuyEDalerServiceProvider.GetType().FullName),
                    new KeyValuePair<string, object>("ServiceId", this.Id),
                    new KeyValuePair<string, object>("URL", this.optionsUrl));
 
                return Array.Empty<IDictionary<CaseInsensitiveString, object>>();
            }
        }
 
        public bool CanBeUsedForPayment
        {
            get
            {
                if (!string.IsNullOrEmpty(this.BuyEDalerTemplateContractId))
                    return false;
 
                foreach (ServiceField Field in this.fields)
                {
                    switch (Field.FieldId.LowerCase)
                    {
                        case "returnurl":
                        case "returnerrorurl":
                        case "cancelurl":
                        case "amount":
                        case "currency":
                            break;
 
                        default:
                            if (Field.Required)
                                return false;
                            break;
                    }
                }
 
                return true;
            }
        }
 
        public IPaymentServiceProvider PaymentServiceProvider { get; }
 
        public async Task<PaymentResult> Pay(decimal Amount, string Currency, string Description, string SuccessUrl, string FailureUrl, string CancelUrl,
            EventHandlerAsync<ClientUrlEventArgs> ClientUrlCallback, object State)
        {
            try
            {
                if (Amount <= 0)
                    return new PaymentResult("Amount must be positive.");
 
                if (string.IsNullOrEmpty(Currency) ||
                    Currency.Length != 3 ||
                    Currency.ToUpper() != Currency)
                {
                    return new PaymentResult("Invalid currency.");
                }
 
                Dictionary<string, object> Request = new Dictionary<string, object>()
                {
                    { "webhook", string.Empty }
                };
 
                foreach (ServiceField Field in this.fields)
                {
                    switch (Field.FieldId.LowerCase)
                    {
                        case "returnurl":
                            Request[Field.FieldId] = SuccessUrl ?? string.Empty;
                            break;
 
                        case "returnerrorurl":
                            Request[Field.FieldId] = FailureUrl ?? string.Empty;
                            break;
 
                        case "cancelurl":
                            Request[Field.FieldId] = CancelUrl ?? string.Empty;
                            break;
 
                        case "amount":
                            Request[Field.FieldId] = Amount;
                            break;
 
                        case "currency":
                            Request[Field.FieldId] = Currency;
                            break;
 
                        default:
                            if (Field.Required)
                                return new PaymentResult("Missing Contract or ID property: " + Field.FieldId);
                            break;
                    }
                }
 
                return await this.ProcessRequest(Request, Amount, Currency, ClientUrlCallback, State);
            }
            catch (Exception ex)
            {
                return new PaymentResult(ex.Message);
            }
        }
    }
}