ProcessEDalerUri.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml;
using Waher.Content;
using Waher.IoTGateway;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Runtime.Transactions;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Service.IoTBroker.DataStorage;
using Waher.Service.IoTBroker.EDaler.Uris;
using Waher.Service.IoTBroker.EDaler.Uris.States;
 
namespace Waher.Service.IoTBroker.WebServices.Agent.Wallet
{
    public class ProcessEDalerUri : AgentPostResource
    {
        public ProcessEDalerUri()
            : base("Wallet/ProcessEDalerUri",
                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(ProcessEDalerUri).Namespace + ".JSON.ProcessEDalerUri.req");
        private static readonly string xmlPattern = Resources.LoadResourceAsText(typeof(ProcessEDalerUri).Namespace + ".XML.ProcessEDalerUri.req");
 
        public override async Task POST(HttpRequest Request, HttpResponse Response, Dictionary<string, IElement> Parameters)
        {
            AccountUser User = AssertUserAuthenticated(Request);
            string Uri = (string)Parameters["PUri"].AssociatedObjectValue;
 
            if (!TransactionModule.Running)
                throw new ServiceUnavailableException("Transaction module not running.");
 
            InternalProcessing State = new InternalProcessing(Uri);
            EDalerUri Parsed = await EDalerUri.Parse(Uri, State, XmppServerModule.EDaler);
 
            if (!(Parsed is null))
            {
                if (XmppServerModule.EDaler is null)
                    throw new ServiceUnavailableException("EDaler component not properly initialized.");
 
                await XmppServerModule.EDaler.ProcessUri(Parsed,
                    new XmppAddress(User.UserName + "@" + Gateway.Domain));
            }
 
            if (State.ErrorType.HasValue || !string.IsNullOrEmpty(State.ErrorMessage))
            {
                string Msg = State.ErrorMessage;
                if (string.IsNullOrEmpty(Msg))
                    Msg = "Unable to process URI.";
 
                switch (State.ErrorType ?? EDalerUriErrorType.Internal)
                {
                    case EDalerUriErrorType.BadRequest:
                        throw new BadRequestException(Msg);
 
                    case EDalerUriErrorType.Forbidden:
                        throw new ForbiddenException(Msg);
 
                    case EDalerUriErrorType.ServiceUnavailable:
                    case EDalerUriErrorType.Remote:
                    case EDalerUriErrorType.Internal:
                    default:
                        throw new ServiceUnavailableException(Msg);
 
                    case EDalerUriErrorType.ResourceConstraint:
                        throw new TooManyRequestsException(Msg);
 
                    case EDalerUriErrorType.Conflict:
                        throw new ConflictException(Msg);
                }
            }
 
            EDaler.Wallet Wallet;
 
            if (XmppServerModule.EDaler is null)
            {
                Wallet = await Database.FindFirstIgnoreRest<EDaler.Wallet>(
                    new FilterFieldEqualTo("Account", User.UserName));
            }
            else
                Wallet = await XmppServerModule.EDaler.GetWallet(User.UserName, Gateway.Domain);
 
            if (Wallet is null)
            {
                string Currency = string.Empty;
 
                if (!(XmppServerModule.EDaler is null))
                    Currency = await XmppServerModule.EDaler.GetDefaultCurrency();
 
                Wallet = new EDaler.Wallet()
                {
                    Account = User.UserName,
                    Balance = 0,
                    Reserved = 0,
                    BalanceTimestamp = DateTime.UtcNow,
                    Created = DateTime.UtcNow,
                    Currency = Currency,
                    Domain = Gateway.Domain
                };
            }
 
            XmlDocument TransactionResult;
 
            if (string.IsNullOrEmpty(State.ResultXml))
                TransactionResult = null;
            else
            {
                TransactionResult = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
                TransactionResult.LoadXml(State.ResultXml);
            }
 
            await Response.Return(new NamedDictionary<string, object>("ProcessResult", AgentNamespace)
            {
                { "Balance", new Dictionary<string, object>()
                    {
                        { "amount", Wallet.Balance },
                        { "reserved", Wallet.Reserved },
                        { "currency", Wallet.Currency.Value },
                        { "timestamp", Wallet.BalanceTimestamp }
                    }
                },
                { "Result", TransactionResult }
            });
        }
    }
}