Fail.cs

using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Xml;
using Waher.Events;
using Waher.Networking.XMPP.Server;
using Waher.Service.IoTBroker.Legal;
using Waher.Service.IoTBroker.Legal.Contracts;
using Waher.Service.IoTBroker.NeuroFeatures;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Actions.Contracts
{
    public class Fail : ContractAction
    {
        public Fail()
            : base()
        {
        }
 
        public override string LocalName => nameof(Fail);
 
        public override IStateMachineNode Create()
        {
            return new Fail();
        }
 
        public override async Task Execute(EvaluationArguments Arguments, string Reason, string ContractId)
        {
            string TokenContractId = Arguments.Token?.CreationContract ?? Arguments.Machine.DefinitionContractId;
            Contract Contract;
            bool TerminateStateMachine;
 
            if (string.IsNullOrEmpty(ContractId))
            {
                ContractId = TokenContractId;
                TerminateStateMachine = true;
            }
            else
                TerminateStateMachine = false;
 
            KeyValuePair<Contract, IqResultEventArgs> P = await Arguments.Legal.GetContract(ContractId);
            Contract = P.Key;
            if (Contract is null)
            {
                if (string.IsNullOrEmpty(P.Value?.ErrorText))
                    throw new StateMachineException(Arguments.Machine, "Contract not found: " + ContractId);
                else
                {
                    throw new StateMachineException(Arguments.Machine, "Unable to get contract " + ContractId +
                        ": " + P.Value.ErrorText);
                }
            }
 
            if (!TerminateStateMachine)
            {
                bool ReferencesTokenContract = false;
                string ContractReferenceId = null;
 
                if (!(Contract.Parameters is null))
                {
                    foreach (Parameter P2 in Contract.Parameters)
                    {
                        if (P2 is ContractReferenceParameter ContractReference)
                        {
                            ContractReferenceId = ContractReference.Value;
 
                            if (ContractReferenceId == TokenContractId)
                            {
                                ReferencesTokenContract = true;
                                break;
                            }
                        }
                    }
                }
 
                if (!ReferencesTokenContract)
                {
                    throw new GenericException("Contract does not reference the token creation contract, so the token state machine is prohibited from failing the contract.",
                        null, null, null, null, null, null, null,
                        new KeyValuePair<string, object>("ContractId", ContractId),
                        new KeyValuePair<string, object>("Reason", Reason),
                        new KeyValuePair<string, object>("TokenContractId", TokenContractId),
                        new KeyValuePair<string, object>("ContractReferenceId", ContractReferenceId));
                }
            }
 
            Arguments.Profiler?.Event(Reason);
 
            if (TerminateStateMachine)
                await StateMachine.GoToState(string.Empty, Arguments);
            else
            {
                XmppAddress ContractAddress = new XmppAddress(ContractId);
 
                if (XmppServerModule.Legal?.IsComponentDomain(ContractAddress.Domain, true) ?? false)
                {
                    await NeuroFeaturesProcessor.RejectContract(Contract,
                        ContractId == TokenContractId, Reason, true, Arguments.Legal,
                        Arguments.EDaler);
                }
                else
                {
                    StringBuilder sb = new StringBuilder();
 
                    sb.Append("<failContract xmlns='");
                    sb.Append(LegalComponent.NamespaceSmartContracts(NamespaceSet.Current));
                    sb.Append("' contractId='");
                    sb.Append(XML.Encode(ContractId));
                    sb.Append("' reason='");
                    sb.Append(XML.Encode(Reason));
                    sb.Append("'/>");
 
                    await Arguments.Legal.Server.SendMessage(string.Empty, string.Empty,
                        Arguments.Legal.MainDomain, new XmppAddress(ContractAddress.Domain),
                        string.Empty, sb.ToString());
                }
            }
 
            if (TerminateStateMachine)
                Arguments.Profiler?.Stop();
        }
    }
}