SellEDalerPaymentService.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
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;
using Waher.Security.CallStack;
 
namespace Paiwise.Internal
{
    public class SellEDalerPaymentService : ServiceProvider, ISellEDalerService
    {
        private readonly ServiceField[] fields;
        private readonly string method;
        private readonly string url;
        private readonly string optionsUrl;
        private readonly string host;
 
        public SellEDalerPaymentService(string Id, string Name, string IconUrl, int IconWidth,
            int IconHeight, string TemplateContractId, string Method, string Url, string OptionsUrl,
            ServiceField[] Fields, string Host, ISellEDalerServiceProvider Provider)
            : base(Id, Name, IconUrl, IconWidth, IconHeight)
        {
            this.method = Method;
            this.url = Url;
            this.optionsUrl = OptionsUrl;
            this.fields = Fields;
            this.host = Host;
 
            this.SellEDalerTemplateContractId = TemplateContractId;
            this.SellEDalerServiceProvider = Provider;
        }
 
        public string SellEDalerTemplateContractId { get; }
 
        public ISellEDalerServiceProvider SellEDalerServiceProvider { get; }
 
        public Grade Supports(CaseInsensitiveString Currency)
        {
            return !CaseInsensitiveString.IsNullOrEmpty(Currency) &&
                Currency.Length == 3 ? Grade.Ok : Grade.NotAtAll;
        }
 
        public async Task<bool> CanSellEDaler(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);
        }
 
        private static readonly Regex PaiwiseProcessorRegex = new Regex(@"Waher\.Service\.IoTBroker\.Paiwise\.PaiwiseProcessor[.+]<(SellEDaler|SellEDaler)>\w*([.]\w*)?",
            RegexOptions.Compiled | RegexOptions.Singleline);
 
        private static readonly Regex UnitTestRegex = new Regex(@"Paiwise\.Internal\.Test\.PaiwiseTests[.+]<(Test_07_ProcessSellEDalerUsingContract|Test_08_ProcessSellEDalerUsingClientUrl)>\w*([.]\w*)?",
            RegexOptions.Compiled | RegexOptions.Singleline);
 
        private static readonly object[] approvedSources = new object[]
        {
            PaiwiseProcessorRegex,
            UnitTestRegex
        };
 
        public async Task<PaymentResult> SellEDaler(IDictionary<CaseInsensitiveString, object> ContractParameters,
            IDictionary<CaseInsensitiveString, CaseInsensitiveString> IdentityProperties,
            decimal Amount, string Currency, string SuccessUrl, string FailureUrl, string CancelUrl, ClientUrlEventHandler 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.");
                }
 
                object Obj;
                Dictionary<string, object> Request = new Dictionary<string, object>()
                {
                    { "webhook", string.Empty }
                };
 
                foreach (ServiceField Field in this.fields)
                {
                    if (ContractParameters.TryGetValue(Field.FieldId, out 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;
                                break;
 
                            case "returnerrorurl":
                                Request[Field.FieldId] = FailureUrl;
                                break;
 
                            case "cancelurl":
                                Request[Field.FieldId] = CancelUrl;
                                break;
 
                            case "amount":
                                Request[Field.FieldId] = Amount;
                                break;
 
                            case "currency":
                                Request[Field.FieldId] = Currency;
                                break;
 
                            case "name":
                                StringBuilder sb = new StringBuilder();
                                bool First = true;
 
                                Append(sb, "FIRST", IdentityProperties, ref First);
                                Append(sb, "MIDDLE", IdentityProperties, ref First);
                                Append(sb, "LAST", IdentityProperties, ref First);
 
                                if (First)
                                    Append(sb, "PNR", IdentityProperties, ref First);
 
                                Request[Field.FieldId] = sb.ToString();
                                break;
 
                            case "address":
                                sb = new StringBuilder();
                                First = true;
 
                                Append(sb, "ADDR", IdentityProperties, ref First);
 
                                Request[Field.FieldId] = sb.ToString();
                                break;
 
                            default:
                                if (Field.Required)
                                    Request[Field.FieldId] = string.Empty;
                                break;
                        }
                    }
                }
 
                // TODO: Proper callback
 
                string Token = await RuntimeSettings.GetAsync(PaiwisePaymentServices.TokenIdSetting, string.Empty);
                if (string.IsNullOrEmpty(Token))
                    return new PaymentResult("Paiwise token not configured");
 
                object Result;
 
                try
                {
                    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));
                }
                catch (Exception ex)
                {
                    Log.Error("Sending paiwise request to " + this.url + ", but an error was returned:" + ex.Message + 
                        "\r\n\r\n" + JSON.Encode(Request, true), new KeyValuePair<string, object>("Token", "Token"));    // TODO: Remove
 
                    return new PaymentResult(ex.Message);
                }
 
                if (!(Result is Dictionary<string, object> Response) ||
                    !Response.TryGetValue("status", out 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.");
 
                        try
                        {
                            await ClientUrlCallback(this, new ClientUrlEventArgs(RedirectUrl, State));
                        }
                        catch (Exception ex)
                        {
                            return new PaymentResult(ex.Message);
                        }
                    }
 
                    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);
 
                        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 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");
 
                        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 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);
            }
            catch (Exception ex)
            {
                return new PaymentResult(ex.Message);
            }
        }
 
        private static void Append(StringBuilder sb, CaseInsensitiveString Key,
            IDictionary<CaseInsensitiveString, CaseInsensitiveString> IdentityProperties, ref bool First)
        {
            if (IdentityProperties.TryGetValue(Key, out CaseInsensitiveString s))
            {
                if (First)
                    First = false;
                else
                    sb.Append(' ');
 
                sb.Append(s.Value);
            }
        }
 
        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>[]> GetPaymentOptionsForSellingEDaler(
            IDictionary<CaseInsensitiveString, CaseInsensitiveString> IdentityProperties,
            string SuccessUrl, string FailureUrl, string CancelUrl,
            ClientUrlEventHandler ClientUrlCallback, object State)
        {
            try
            {
                if (string.IsNullOrEmpty(this.optionsUrl))
                    return new IDictionary<CaseInsensitiveString, object>[0];
 
                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
                    {
                        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 "name":
                                StringBuilder sb = new StringBuilder();
                                bool First = true;
 
                                Append(sb, "FIRST", IdentityProperties, ref First);
                                Append(sb, "MIDDLE", IdentityProperties, ref First);
                                Append(sb, "LAST", IdentityProperties, ref First);
 
                                if (First)
                                    Append(sb, "PNR", IdentityProperties, ref First);
 
                                Request[Field.FieldId] = sb.ToString();
                                break;
 
                            case "address":
                                sb = new StringBuilder();
                                First = true;
 
                                Append(sb, "ADDR", IdentityProperties, ref First);
 
                                Request[Field.FieldId] = sb.ToString();
                                break;
 
                            default:
                                Request[Field.FieldId] = null;
                                break;
                        }
                    }
                }
 
                string Token = await RuntimeSettings.GetAsync(PaiwisePaymentServices.TokenIdSetting, string.Empty);
                if (string.IsNullOrEmpty(Token))
                    return new IDictionary<CaseInsensitiveString, object>[0];
 
                object Result;
 
                try
                {
                    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));
                }
                catch (Exception ex)
                {
                    Log.Error("Requesting payment options for paiwise request to " + this.optionsUrl + ", but an error was returned:" + ex.Message +
                        "\r\n\r\n" + JSON.Encode(Request, true), new KeyValuePair<string, object>("Token", "Token"));    // TODO: Remove
 
                    return new IDictionary<CaseInsensitiveString, object>[0];
                }
 
                if (!(Result 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.SellEDalerServiceProvider.GetType().FullName),
                    new KeyValuePair<string, object>("ServiceId", this.Id),
                    new KeyValuePair<string, object>("URL", this.optionsUrl));
 
                return new IDictionary<CaseInsensitiveString, object>[0];
            }
        }
 
    }
}