TokenProperty.cs

using System;
using System.Threading.Tasks;
using System.Xml;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Values
{
    public enum TokenProperties
    {
        TokenId,
 
        TokenIdMethod,
 
        Visibility,
 
        Creator,
 
        CreatorJid,
 
        Owner,
 
        OwnerJid,
 
        TrustProvider,
 
        TrustProviderJid,
 
        Currency,
 
        Reference,
 
        Definition,
 
        DefinitionNamespace,
 
        CreationContract,
 
        CreationContractTemplate,
 
        OwnershipContract,
 
        Value,
 
        Created,
 
        Updated,
 
        Expires,
 
        ArchiveRequired,
 
        ArchiveOptional,
 
        SignatureTimestamp,
 
        Signature,
 
        DefinitionSchemaDigest,
 
        DefinitionSchemaHashFunction,
 
        CreatorCanDestroy,
 
        OwnerCanDestroyBatch,
 
        OwnerCanDestroyIndividual,
 
        CertifierCanDestroy,
 
        FriendlyName,
 
        Glyph,
 
        GlyphContentType,
 
        GlyphWidth,
 
        GlyphHeight,
 
        Ordinal,
 
        BatchSize
    }
 
    public class TokenProperty : ValueNode
    {
        public TokenProperty()
            : base()
        {
        }
 
        public TokenProperties Value { get; set; }
 
        public override string LocalName => nameof(TokenProperty);
 
        public override IStateMachineNode Create()
        {
            return new TokenProperty();
        }
 
        public override Task Parse(XmlElement Xml)
        {
            if (!Enum.TryParse<TokenProperties>(Xml.InnerText, out TokenProperties p))
                throw new StateMachineException(this.StateMachine, "Invalid Token Property value.");
 
            this.Value = p;
 
            return base.Parse(Xml);
        }
 
        public override Task<object> Evaluate(EvaluationArguments Arguments)
        {
            if (Arguments.Token is null)
                throw new StateMachineException(Arguments.Machine, "State Machine does not have single token owner.");
 
            switch (this.Value)
            {
                case TokenProperties.TokenId: return Task.FromResult<object>(Arguments.Token.TokenId);
                case TokenProperties.TokenIdMethod: return Task.FromResult<object>(Arguments.Token.TokenIdMethod);
                case TokenProperties.Visibility: return Task.FromResult<object>(Arguments.Token.Visibility);
                case TokenProperties.Creator: return Task.FromResult<object>(Arguments.Token.Creator);
                case TokenProperties.CreatorJid: return Task.FromResult<object>(Arguments.Token.CreatorJid);
                case TokenProperties.Owner: return Task.FromResult<object>(Arguments.Token.Owner);
                case TokenProperties.OwnerJid: return Task.FromResult<object>(Arguments.Token.OwnerJid);
                case TokenProperties.TrustProvider: return Task.FromResult<object>(Arguments.Token.TrustProvider);
                case TokenProperties.TrustProviderJid: return Task.FromResult<object>(Arguments.Token.TrustProviderJid);
                case TokenProperties.Currency: return Task.FromResult<object>(Arguments.Token.Currency);
                case TokenProperties.Reference: return Task.FromResult<object>(Arguments.Token.Reference);
                case TokenProperties.Definition: return Task.FromResult<object>(Arguments.Token.Definition);
                case TokenProperties.DefinitionNamespace: return Task.FromResult<object>(Arguments.Token.DefinitionNamespace);
                case TokenProperties.CreationContract: return Task.FromResult<object>(Arguments.Token.CreationContract);
                case TokenProperties.CreationContractTemplate: return Task.FromResult<object>(Arguments.Token.CreationContractTemplate);
                case TokenProperties.OwnershipContract: return Task.FromResult<object>(Arguments.Token.OwnershipContract);
                case TokenProperties.Value: return Task.FromResult<object>(Arguments.Token.Value);
                case TokenProperties.Created: return Task.FromResult<object>(Arguments.Token.Created);
                case TokenProperties.Updated: return Task.FromResult<object>(Arguments.Token.Updated);
                case TokenProperties.Expires: return Task.FromResult<object>(Arguments.Token.Expires);
                case TokenProperties.ArchiveRequired: return Task.FromResult<object>(Arguments.Token.ArchiveRequired);
                case TokenProperties.ArchiveOptional: return Task.FromResult<object>(Arguments.Token.ArchiveOptional);
                case TokenProperties.SignatureTimestamp: return Task.FromResult<object>(Arguments.Token.SignatureTimestamp);
                case TokenProperties.Signature: return Task.FromResult<object>(Arguments.Token.Signature);
                case TokenProperties.DefinitionSchemaDigest: return Task.FromResult<object>(Arguments.Token.DefinitionSchemaDigest);
                case TokenProperties.DefinitionSchemaHashFunction: return Task.FromResult<object>(Arguments.Token.DefinitionSchemaHashFunction);
                case TokenProperties.CreatorCanDestroy: return Task.FromResult<object>(Arguments.Token.CreatorCanDestroy);
                case TokenProperties.OwnerCanDestroyBatch: return Task.FromResult<object>(Arguments.Token.OwnerCanDestroyBatch);
                case TokenProperties.OwnerCanDestroyIndividual: return Task.FromResult<object>(Arguments.Token.OwnerCanDestroyIndividual);
                case TokenProperties.CertifierCanDestroy: return Task.FromResult<object>(Arguments.Token.CertifierCanDestroy);
                case TokenProperties.FriendlyName: return Task.FromResult<object>(Arguments.Token.FriendlyName);
                case TokenProperties.Glyph: return Task.FromResult<object>(Arguments.Token.Glyph);
                case TokenProperties.GlyphContentType: return Task.FromResult<object>(Arguments.Token.GlyphContentType);
                case TokenProperties.GlyphWidth: return Task.FromResult<object>(Arguments.Token.GlyphWidth);
                case TokenProperties.GlyphHeight: return Task.FromResult<object>(Arguments.Token.GlyphHeight);
                case TokenProperties.Ordinal: return Task.FromResult<object>(Arguments.Token.Ordinal);
                case TokenProperties.BatchSize: return Task.FromResult<object>(Arguments.Token.BatchSize);
                default: return Task.FromResult<object>(null);
            }
        }
    }
}