InitiateSellEDaler.cs

using Paiwise;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Runtime.Inventory;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.Legal.Identity;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Wallet
{
    public class InitiateSellEDaler : AgentPostResource
    {
        public InitiateSellEDaler()
            : base("Wallet/InitiateSellEDaler",
                new KeyValuePair<Type, Expression>(typeof(Dictionary<string, object>), new Expression(jsonPattern)),
                new KeyValuePair<Type, Expression>(typeof(XmlDocument), new Expression(xmlPattern)))
        {
        }
 
        private static readonly string jsonPattern = Resources.LoadResourceAsText(typeof(InitiateSellEDaler).Namespace + ".JSON.InitiateSellEDaler.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(InitiateSellEDaler).Namespace + ".XML.InitiateSellEDaler.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
 
            LegalIdentity Identity = await XmppServerModule.Legal.GetCurrentApprovedLegalIdentityAsync(User.UserName)
                ?? throw new ForbiddenException("Account has no approved legal identity.");
 
            string Country = Identity["COUNTRY"];
            if (string.IsNullOrEmpty(Country))
                throw new ForbiddenException("Approved legal identity lacks country specified.");
 
            string ServiceId = (string)Parameters["PServiceId"].AssociatedObjectValue;
            string ServiceProvider = (string)Parameters["PServiceProvider"].AssociatedObjectValue;
            decimal Amount = (decimal)((double)Parameters["PAmount"].AssociatedObjectValue);
            CaseInsensitiveString Currency = (string)Parameters["PCurrency"].AssociatedObjectValue;
            string SuccessUrl = Parameters.TryGetValue("PSuccessUrl", out IElement E) ? (string)E?.AssociatedObjectValue : null;
            string FailureUrl = Parameters.TryGetValue("PFailureUrl", out E) ? (string)E?.AssociatedObjectValue : null;
            string CancelUrl = Parameters.TryGetValue("PCancelUrl", out E) ? (string)E?.AssociatedObjectValue : null;
            string TransactionIdStr = Parameters.TryGetValue("PTransactionId", out E) ? (string)E?.AssociatedObjectValue : null;
            string TabId = Parameters.TryGetValue("PTabId", out E) ? (string)E?.AssociatedObjectValue : null;
            string FunctionName = Parameters.TryGetValue("PFunctionName", out E) ? (string)E?.AssociatedObjectValue : null;
            Guid TransactionId;
 
            if (string.IsNullOrEmpty(TransactionIdStr))
                TransactionId = Guid.NewGuid();
            else if (!Guid.TryParse(TransactionIdStr, out TransactionId))
                throw new BadRequestException("Invalid Transaction ID. Must be a GUID.");
 
            if (Amount <= 0)
                throw new BadRequestException("Invalid amount.");
 
            if (CaseInsensitiveString.IsNullOrEmpty(Currency))
                throw new BadRequestException("Invalid currency.");
 
            if (string.IsNullOrEmpty(ServiceId))
                throw new BadRequestException("Service ID not defined.");
 
            if (string.IsNullOrEmpty(ServiceProvider))
                throw new BadRequestException("Service Provider not defined.");
 
            Type T = Types.GetType(ServiceProvider)
                ?? throw new NotFoundException("Service Provider " + ServiceProvider + " not found or installed.");
 
            if (!typeof(ISellEDalerServiceProvider).IsAssignableFrom(T) ||
                !(Types.Instantiate(T) is ISellEDalerServiceProvider SellEDalerServiceProvider))
            {
                throw new BadRequestException("Service Provider does not support selling of eDaler.");
            }
 
            ISellEDalerService Service = await SellEDalerServiceProvider.GetServiceForSellingEDaler(ServiceId, Currency, Country)
                ?? throw new NotFoundException("Payment Service ID not found.");
 
            if (!await Service.CanSellEDaler(User.UserName))
                new ForbiddenException("Selected service provider cannot perform action.");
 
            if (!CaseInsensitiveString.IsNullOrEmpty(Currency) && Service.Supports(Currency) == Grade.NotAtAll)
                throw new ForbiddenException("Selected service provider does not support selected currency (" + Currency + ").");
 
            if (!string.IsNullOrEmpty(Service.SellEDalerTemplateContractId))
                throw new ForbiddenException("Service provider requires a signed contract to perform payment. See associated Contract Template ID.");
 
            EDaler.Wallet Wallet = await XmppServerModule.EDaler.GetWallet(User.UserName, Gateway.Domain);
            List<NamedDictionary<string, object>> Providers = new List<NamedDictionary<string, object>>();
 
            Dictionary<CaseInsensitiveString, object> ContractParameters = new Dictionary<CaseInsensitiveString, object>()
            {
                { "Amount", Amount },
                { "Currency", Currency.Value.ToUpper() }
            };
            Dictionary<CaseInsensitiveString, CaseInsensitiveString> SellerIdParameters = new Dictionary<CaseInsensitiveString, CaseInsensitiveString>();
 
            foreach (Property P in Identity.Properties)
                SellerIdParameters[P.Name] = P.Value;
 
            SellEDalerTransaction Transaction = PaymentTransactions.Add<SellEDalerTransaction>(
                TransactionId, ServiceId, ServiceProvider, Amount, Currency, SuccessUrl,
                FailureUrl, CancelUrl, TabId, FunctionName, User.UserName, Service,
                Identity.Id, ContractParameters, SellerIdParameters);
 
            if (!await Transaction.Prepare())
                throw new ServiceUnavailableException("Unable to initialize transaction.");
 
            await Response.Return(Transaction.GetInformation());
 
            Task _ = Task.Run(async () =>
            {
                try
                {
                    await Transaction.Process();
                }
                catch (Exception ex)
                {
                    Log.Exception(ex);
                }
            });
 
        }
    }
}