d4/db4/_xmpp_service_8cs_source.html

//#define DEBUG_XMPP_REMOTE

#define DEBUG_XMPP_LOCAL

//#define DEBUG_LOG_REMOTE

//#define DEBUG_DB_REMOTE

//#define DEBUG_NFC_REMOTE


using System.Collections.Generic;

using System.ComponentModel;

using System.Diagnostics;

using System.Diagnostics.CodeAnalysis;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Text;

using System.Xml;

using CommunityToolkit.Mvvm.Messaging;

using EDaler;

using EDaler.Events;

using EDaler.Uris;

using NeuroAccessMaui.Extensions;

using NeuroAccessMaui.Resources.Languages;

using NeuroAccessMaui.Services.Contacts;

using NeuroAccessMaui.Services.Contracts;

using NeuroAccessMaui.Services.Identity;

using NeuroAccessMaui.Services.Kyc;

using NeuroAccessMaui.Services.Kyc.Models;

using NeuroAccessMaui.Services.Notification;

using NeuroAccessMaui.Services.Notification.Things;

using NeuroAccessMaui.Services.Notification.Xmpp;

using NeuroAccessMaui.Services.Push;

using NeuroAccessMaui.Services.Tag;

using NeuroAccessMaui.Services.UI.Photos;

using NeuroAccessMaui.Services.Wallet;

using NeuroAccessMaui.UI.Pages.Applications.Applications;

using NeuroAccessMaui.UI.Pages.Contacts.Chat;

using NeuroAccessMaui.UI.Pages.Kyc;

using NeuroAccessMaui.UI.Pages.Onboarding;

using NeuroAccessMaui.UI.Popups.Xmpp.ReportOrBlock;

using NeuroAccessMaui.UI.Popups.Xmpp.ReportType;

using NeuroAccessMaui.UI.Popups.Xmpp.SubscribeTo;

using NeuroAccessMaui.UI.Popups.Xmpp.SubscriptionRequest;

using NeuroFeatures;

using NeuroFeatures.EventArguments;

using NeuroFeatures.Events;

using Waher.Content;

using Waher.Content.Html;

using Waher.Content.Markdown;

using Waher.Content.Xml;

using Waher.Events;

using Waher.Events.Filter;

using Waher.Events.XMPP;

using Waher.Networking;

using Waher.Networking.Sniffers;

using Waher.Networking.XMPP;

using Waher.Networking.XMPP.Abuse;

using Waher.Networking.XMPP.Concentrator;

using Waher.Networking.XMPP.Contracts;

using Waher.Networking.XMPP.Contracts.EventArguments;

using Waher.Networking.XMPP.Control;

using Waher.Networking.XMPP.DataForms;

using Waher.Networking.XMPP.Events;

using Waher.Networking.XMPP.HttpFileUpload;

using Waher.Networking.XMPP.HTTPX;

using Waher.Networking.XMPP.PEP;

using Waher.Networking.XMPP.PEP.Events;

using Waher.Networking.XMPP.Provisioning;

using Waher.Networking.XMPP.Provisioning.Events;

using Waher.Networking.XMPP.Provisioning.SearchOperators;

using Waher.Networking.XMPP.PubSub;

using Waher.Networking.XMPP.PubSub.Events;

using Waher.Networking.XMPP.Push;

using Waher.Networking.XMPP.ResultSetManagement;

using Waher.Networking.XMPP.Sensor;

using Waher.Networking.XMPP.ServiceDiscovery;

using Waher.Networking.XMPP.StanzaErrors;

using Waher.Networking.XMPP.StreamErrors;

using Waher.Persistence;

using Waher.Persistence.Filters;

using Waher.Runtime.Inventory;

using Waher.Runtime.Settings;

using Waher.Runtime.Temporary;

using Waher.Script.Constants;

using Waher.Security.JWT;

using Waher.Things;

using Waher.Things.SensorData;


namespace NeuroAccessMaui.Services.Xmpp

{

    [Singleton]

    internal sealed class XmppService : LoadableService, IXmppService, IDisposableAsync

    {

        //private bool isDisposed;

        private XmppClient? xmppClient;

        private ContractsClient? contractsClient;

        private HttpFileUploadClient? fileUploadClient;

        private ThingRegistryClient? thingRegistryClient;

        private ProvisioningClient? provisioningClient;

        private ControlClient? controlClient;

        private SensorClient? sensorClient;

        private ConcentratorClient? concentratorClient;

        private EDalerClient? eDalerClient;

        private NeuroFeaturesClient? neuroFeaturesClient;

        private PushNotificationClient? pushNotificationClient;

        private AbuseClient? abuseClient;

        private PepClient? pepClient;

        private HttpxClient? httpxClient;

        private PubSubClient? pubSubClient;

        private Timer? reconnectTimer;

        private Timer? updatePasswordTimer;

        private string? domainName;

        private string? accountName;

        private string? passwordHash;

        private string? passwordHashMethod;

        private bool xmppConnected = false;

        private DateTime xmppLastStateChange = DateTime.MinValue;

        private readonly InMemorySniffer? sniffer = new(250, "Connection In-memory sniffer.");

        private bool isCreatingClient;

        private EventFilter? xmppFilteredEventSink;

        private string? token = null;

        private DateTime tokenCreated = DateTime.MinValue;

#if DEBUG_XMPP_REMOTE || DEBUG_LOG_REMOTE || DEBUG_DB_REMOTE || DEBUG_NFC_REMOTE

        private const string debugRecipient = "";     // TODO: Set JID of recipient of debug messages.

#endif

#if DEBUG_XMPP_REMOTE || DEBUG_DB_REMOTE || DEBUG_NFC_REMOTE

        private RemoteSniffer? debugSniffer = null;

#endif

#if DEBUG_LOG_REMOTE

        private EventFilter? debugEventSink = null;

#endif


        #region Creation / Destruction


        public XmppService()

        {

        }


        private async Task CreateXmppClient()

        {

            if (this.isCreatingClient)

                return;


            try

            {

                this.isCreatingClient = true;


                if (!this.XmppParametersCurrent() || this.XmppStale())

                {

                    if (this.xmppClient is not null)

                        await this.DestroyXmppClient();


                    this.domainName = ServiceRef.TagProfile.Domain;

                    this.accountName = ServiceRef.TagProfile.Account;

                    this.passwordHash = ServiceRef.TagProfile.XmppPasswordHash;

                    this.passwordHashMethod = ServiceRef.TagProfile.XmppPasswordHashMethod;


                    string? HostName;

                    int PortNumber;

                    bool IsIpAddress;


                    if (ServiceRef.TagProfile.DefaultXmppConnectivity)

                    {

                        HostName = this.domainName;

                        PortNumber = XmppCredentials.DefaultPort;

                        IsIpAddress = false;

                    }

                    else

                    {

                        (HostName, PortNumber, IsIpAddress) = await ServiceRef.NetworkService.LookupXmppHostnameAndPort(this.domainName!);


                        if (HostName == this.domainName && PortNumber == XmppCredentials.DefaultPort)

                        {

                            ServiceRef.TagProfile.SetDomain(this.domainName, true, ServiceRef.TagProfile.ApiKey ?? string.Empty,

                                ServiceRef.TagProfile.ApiSecret ?? string.Empty);

                        }

                    }


                    this.xmppLastStateChange = DateTime.Now;

                    this.xmppConnected = false;


                    Assembly AppAssembly = App.Current!.GetType().Assembly;


                    if (string.IsNullOrEmpty(this.passwordHashMethod))

                    {

                        this.xmppClient = new XmppClient(HostName, PortNumber, this.accountName, this.passwordHash,

                            Constants.LanguageCodes.Default, AppAssembly, this.sniffer);

                    }

                    else

                    {

                        this.xmppClient = new XmppClient(HostName, PortNumber, this.accountName, this.passwordHash, this.passwordHashMethod,

                            Constants.LanguageCodes.Default, AppAssembly, this.sniffer);

                    }

#if DEBUG_XMPP_LOCAL

                    DebugSniffer LocalSniffer = new(BinaryPresentationMethod.Hexadecimal);

                    this.xmppClient.Add(LocalSniffer);

#endif


#if DEBUG_XMPP_REMOTE || DEBUG_LOG_REMOTE || DEBUG_DB_REMOTE

                    if (!string.IsNullOrEmpty(debugRecipient))

                    {

#endif

#if DEBUG_XMPP_REMOTE || DEBUG_DB_REMOTE || DEBUG_NFC_REMOTE

                        this.debugSniffer = new RemoteSniffer(debugRecipient, DateTime.MaxValue, this.xmppClient, this.xmppClient,

                            ConcentratorServer.NamespaceConcentratorCurrent);

#endif

#if DEBUG_XMPP_REMOTE

                        this.xmppClient.Add(this.debugSniffer);

#endif

#if DEBUG_LOG_REMOTE

                        if (this.debugEventSink is not null)

                        {

                            Log.Unregister(this.debugEventSink);

                            this.debugEventSink?.Dispose();

                            this.debugEventSink = null;

                        }


                        this.debugEventSink = new EventFilter("Debug Event Filter",

                            new XmppEventSink("Debug Event Sink", this.xmppClient, debugRecipient, false),

                            EventType.Informational, (Event) =>

                            {

                                if (this.xmppClient is null || this.xmppClient.State != XmppState.Connected)

                                    return false;


                                return string.IsNullOrEmpty(Event.StackTrace) || !Event.StackTrace.Contains("XmppEventSink");

                            });


                        Log.Register(this.debugEventSink);

#endif

#if DEBUG_DB_REMOTE

                        if (!Ledger.HasProvider)

                        {

                            XmlFileLedger XmlFileLedger = new(new RemoteLedgerWriter());

                            Ledger.Register(XmlFileLedger);


                            await XmlFileLedger.Start();


                            Ledger.StartListeningToDatabaseEvents();

                        }

#endif

#if DEBUG_XMPP_REMOTE || DEBUG_LOG_REMOTE || DEBUG_DB_REMOTE

                    }

#endif

                    this.xmppClient.DefaultRetryTimeout = 30000;

                    this.xmppClient.DefaultNrRetries = 0;

                    this.xmppClient.RequestRosterOnStartup = false;

                    this.xmppClient.TrustServer = !IsIpAddress;

                    this.xmppClient.AllowCramMD5 = false;

                    this.xmppClient.AllowDigestMD5 = false;

                    this.xmppClient.AllowPlain = false;

                    this.xmppClient.AllowEncryption = true;

                    this.xmppClient.AllowScramSHA1 = true;

                    this.xmppClient.AllowScramSHA256 = true;

                    this.xmppClient.AllowQuickLogin = true;


                    this.xmppClient.RequestRosterOnStartup = true;

                    this.xmppClient.OnStateChanged += this.XmppClient_StateChanged;

                    this.xmppClient.OnConnectionError += this.XmppClient_ConnectionError;

                    this.xmppClient.OnError += this.XmppClient_Error;

                    this.xmppClient.OnChatMessage += this.XmppClient_OnChatMessage;

                    this.xmppClient.OnNormalMessage += this.XmppClient_OnNormalMessage;

                    this.xmppClient.OnPresenceSubscribe += this.XmppClient_OnPresenceSubscribe;

                    this.xmppClient.OnPresenceUnsubscribed += this.XmppClient_OnPresenceUnsubscribed;

                    this.xmppClient.OnRosterItemAdded += this.XmppClient_OnRosterItemAdded;

                    this.xmppClient.OnRosterItemUpdated += this.XmppClient_OnRosterItemUpdated;

                    this.xmppClient.OnRosterItemRemoved += this.XmppClient_OnRosterItemRemoved;

                    this.xmppClient.OnPresence += this.XmppClient_OnPresence;


                    this.xmppClient.RegisterMessageHandler("Delivered", ContractsClient.NamespaceOnboarding, this.TransferIdDelivered, true);


                    this.xmppFilteredEventSink = new EventFilter("XMPP Event Filter",

                        new XmppEventSink("XMPP Event Sink", this.xmppClient, ServiceRef.TagProfile.LogJid, false),

                        EventType.Error);


                    // Add extensions before connecting


                    this.abuseClient = new AbuseClient(this.xmppClient);


                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.LegalJid))

                    {

                        this.contractsClient = new ContractsClient(this.xmppClient, ServiceRef.TagProfile.LegalJid);

                        this.RegisterContractsEventHandlers();


                        await this.contractsClient.LoadKeys(false);

                    }


                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.HttpFileUploadJid) && (ServiceRef.TagProfile.HttpFileUploadMaxSize > 0))

                        this.fileUploadClient = new HttpFileUploadClient(this.xmppClient, ServiceRef.TagProfile.HttpFileUploadJid, ServiceRef.TagProfile.HttpFileUploadMaxSize);


                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.RegistryJid))

                        this.thingRegistryClient = new ThingRegistryClient(this.xmppClient, ServiceRef.TagProfile.RegistryJid);


                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.ProvisioningJid))

                    {

                        this.provisioningClient = new ProvisioningClient(this.xmppClient, ServiceRef.TagProfile.ProvisioningJid)

                        {

                            ManagePresenceSubscriptionRequests = false

                        };


                        this.provisioningClient.CanControlQuestion += this.ProvisioningClient_CanControlQuestion;

                        this.provisioningClient.CanReadQuestion += this.ProvisioningClient_CanReadQuestion;

                        this.provisioningClient.IsFriendQuestion += this.ProvisioningClient_IsFriendQuestion;

                    }


                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.EDalerJid))

                    {

                        this.eDalerClient = new EDalerClient(this.xmppClient, this.contractsClient, ServiceRef.TagProfile.EDalerJid);

                        this.RegisterEDalerEventHandlers(this.eDalerClient);

                    }


                    if (!string.IsNullOrWhiteSpace(ServiceRef.TagProfile.NeuroFeaturesJid))

                    {

                        this.neuroFeaturesClient = new NeuroFeaturesClient(this.xmppClient, this.contractsClient, ServiceRef.TagProfile.NeuroFeaturesJid);

                        this.RegisterNeuroFeatureEventHandlers(this.neuroFeaturesClient);

                    }


                    if (ServiceRef.TagProfile.SupportsPushNotification)

                        this.pushNotificationClient = new PushNotificationClient(this.xmppClient);


                    this.sensorClient = new SensorClient(this.xmppClient);

                    this.controlClient = new ControlClient(this.xmppClient);

                    this.concentratorClient = new ConcentratorClient(this.xmppClient);


                    if (string.IsNullOrEmpty(ServiceRef.TagProfile.PubSubJid))

                        this.pepClient = new PepClient(this.xmppClient);

                    else

                        this.pepClient = new PepClient(this.xmppClient, ServiceRef.TagProfile.PubSubJid);

                    this.ReregisterPepEventHandlers(this.pepClient);


                    this.httpxClient = new HttpxClient(this.xmppClient, 8192);

                    Types.SetModuleParameter("XMPP", this.xmppClient);      // Makes the XMPP Client the default XMPP client, when resolving HTTP over XMPP requests.


                    //if(this.pubSubClient is null && !string.IsNullOrEmpty(ServiceRef.TagProfile.PubSubJid))

                    //  this.pubSubClient = new PubSubClient(this.xmppClient, ServiceRef.TagProfile.PubSubJid);


                    this.IsLoggedOut = false;

                    await this.xmppClient.Connect(IsIpAddress ? string.Empty : this.domainName);

                    this.RecreateReconnectTimer();


                    // Await connected state during registration or user initiated log in, but not otherwise.

                    if (!ServiceRef.TagProfile.IsCompleteOrWaitingForValidation())

                    {

                        if (!await this.WaitForConnectedState(Constants.Timeouts.XmppConnect))

                        {

                            ServiceRef.LogService.LogWarning("Connection to XMPP server failed.",

                                new KeyValuePair<string, object?>("Domain", this.domainName ?? string.Empty),

                                new KeyValuePair<string, object?>("Account", this.accountName ?? string.Empty),

                                new KeyValuePair<string, object?>("Timeout", Constants.Timeouts.XmppConnect));

                        }

                    }

                }

            }

            finally

            {

                this.isCreatingClient = false;

            }

        }


#if DEBUG_DB_REMOTE

        private class RemoteLedgerWriter()

            : TextWriter(CultureInfo.CurrentCulture)

        {

            private readonly StringBuilder sb = new();


            public override Encoding Encoding => Encoding.Unicode;

            public override void Flush() => this.FlushAsync().Wait();

            public override Task FlushAsync(CancellationToken cancellationToken) => this.FlushAsync();


            public override async Task FlushAsync()

            {

                try

                {

                    string s = this.sb.ToString();

                    string s2 = s.TrimStart();

                    if (string.IsNullOrEmpty(s2))

                        return;


                    if (ServiceRef.XmppService is not XmppService Service)

                        return;


                    RemoteSniffer? Sniffer = Service.debugSniffer;

                    if (Sniffer is null)

                        return;


                    this.sb.Clear();


                    int i = s2.IndexOf('<');

                    if (i > 0)

                        s2 = s2[i..];


                    string[] Rows = s.Replace("\r\n", "\n").Replace('\r', '\n').Split('\n');


                    if (s2.StartsWith("<New", StringComparison.OrdinalIgnoreCase))

                    {

                        foreach (string Row in Rows)

                            await Sniffer.TransmitText(Row);

                    }

                    else if (s2.StartsWith("<Update", StringComparison.OrdinalIgnoreCase))

                    {

                        foreach (string Row in Rows)

                            await Sniffer.ReceiveText(Row);

                    }

                    else if (s2.StartsWith("<Delete", StringComparison.OrdinalIgnoreCase))

                    {

                        foreach (string Row in Rows)

                            await Sniffer.Error(Row);

                    }

                    else if (s2.StartsWith("<Clear", StringComparison.OrdinalIgnoreCase))

                    {

                        foreach (string Row in Rows)

                            await Sniffer.Warning(Row);

                    }

                    else

                    {

                        foreach (string Row in Rows)

                            await Sniffer.Information(Row);

                    }

                }

                catch (Exception)

                {

                    // Ignore

                }

            }


            public override void Write(char value) => this.sb.Append(value);

            public override void Write(char[]? buffer) => this.sb.Append(buffer);

            public override void Write(char[] buffer, int index, int count) => this.sb.Append(new string(buffer, index, count));

            public override void Write(ReadOnlySpan<char> buffer) => this.sb.Append(new string(buffer));

            public override void Write(bool value) => this.sb.Append(value);

            public override void Write(int value) => this.sb.Append(value);

            public override void Write(uint value) => this.sb.Append(value);

            public override void Write(long value) => this.sb.Append(value);

            public override void Write(ulong value) => this.sb.Append(value);

            public override void Write(float value) => this.sb.Append(value);

            public override void Write(double value) => this.sb.Append(value);

            public override void Write(decimal value) => this.sb.Append(value);

            public override void Write(string? value) => this.sb.Append(value);

            public override void Write(object? value) => this.sb.Append(value);

            public override void Write(StringBuilder? value) => this.sb.Append(value);

            public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0) => this.sb.Append(string.Format(this.FormatProvider, format, arg0));

            public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0, object? arg1) => this.sb.Append(string.Format(this.FormatProvider, format, arg0, arg1));

            public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0, object? arg1, object? arg2) => this.sb.Append(string.Format(this.FormatProvider, format, arg0, arg1, arg2));

            public override void Write([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params object?[] arg) => this.sb.Append(string.Format(this.FormatProvider, format, arg));

            public override Task WriteAsync(char value) { this.sb.Append(value); return Task.CompletedTask; }

            public override Task WriteAsync(string? value) { this.sb.Append(value); return Task.CompletedTask; }

            public override Task WriteAsync(StringBuilder? value, CancellationToken cancellationToken = default) { this.sb.Append(value); return Task.CompletedTask; }

            public override Task WriteAsync(char[] buffer, int index, int count) { this.sb.Append(new string(buffer, index, count)); return Task.CompletedTask; }

            public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default) { this.sb.Append(buffer); return Task.CompletedTask; }

            public override void WriteLine() => this.sb.AppendLine(string.Empty);

            public override void WriteLine(char value) => this.sb.AppendLine(value.ToString());

            public override void WriteLine(char[]? buffer) => this.sb.AppendLine(new string(buffer));

            public override void WriteLine(char[] buffer, int index, int count) => this.sb.AppendLine(new string(buffer, index, count));

            public override void WriteLine(ReadOnlySpan<char> buffer) => this.sb.AppendLine(new string(buffer));

            public override void WriteLine(bool value) => this.sb.AppendLine(value.ToString());

            public override void WriteLine(int value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));

            public override void WriteLine(uint value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));

            public override void WriteLine(long value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));

            public override void WriteLine(ulong value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));

            public override void WriteLine(float value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));

            public override void WriteLine(double value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));

            public override void WriteLine(decimal value) => this.sb.AppendLine(value.ToString(CultureInfo.CurrentCulture));

            public override void WriteLine(string? value) => this.sb.AppendLine(value?.ToString());

            public override void WriteLine(StringBuilder? value) => this.sb.AppendLine(value?.ToString());

            public override void WriteLine(object? value) => this.sb.AppendLine(value?.ToString());

            public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0) => this.sb.AppendLine(string.Format(this.FormatProvider, format, arg0));

            public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0, object? arg1) => this.sb.AppendLine(string.Format(this.FormatProvider, format, arg0, arg1));

            public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0, object? arg1, object? arg2) => this.sb.AppendLine(string.Format(this.FormatProvider, format, arg0, arg1, arg2));

            public override void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, params object?[] arg) => this.sb.AppendLine(string.Format(this.FormatProvider, format, arg));

            public override Task WriteLineAsync(char value) { this.sb.AppendLine(value.ToString()); return Task.CompletedTask; }

            public override Task WriteLineAsync(string? value) { this.sb.AppendLine(value); return Task.CompletedTask; }

            public override Task WriteLineAsync(StringBuilder? value, CancellationToken cancellationToken = default) { this.sb.AppendLine(value?.ToString()); return Task.CompletedTask; }

            public override Task WriteLineAsync(char[] buffer, int index, int count) { this.sb.AppendLine(new string(buffer, index, count)); return Task.CompletedTask; }

            public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default) { this.sb.AppendLine(new string(buffer.Span)); return Task.CompletedTask; }

            public override Task WriteLineAsync() { this.sb.AppendLine(string.Empty); return Task.CompletedTask; }

        }

#endif


        private async Task DestroyXmppClient()

        {

            this.reconnectTimer?.Dispose();

            this.reconnectTimer = null;


            await this.OnConnectionStateChanged(XmppState.Offline);


            if (this.xmppFilteredEventSink is not null)

            {

                ServiceRef.LogService.RemoveListener(this.xmppFilteredEventSink);

                await this.xmppFilteredEventSink.SecondarySink.DisposeAsync();

                await this.xmppFilteredEventSink.DisposeAsync();

                this.xmppFilteredEventSink = null;

            }


            this.contractsClient?.Dispose();

            this.contractsClient = null;


            this.fileUploadClient?.Dispose();

            this.fileUploadClient = null;


            this.thingRegistryClient?.Dispose();

            this.thingRegistryClient = null;


            this.provisioningClient?.Dispose();

            this.provisioningClient = null;


            this.eDalerClient?.Dispose();

            this.eDalerClient = null;


            this.neuroFeaturesClient?.Dispose();

            this.neuroFeaturesClient = null;


            this.pushNotificationClient?.Dispose();

            this.pushNotificationClient = null;


            this.sensorClient?.Dispose();

            this.sensorClient = null;


            this.controlClient?.Dispose();

            this.controlClient = null;


            this.concentratorClient?.Dispose();

            this.concentratorClient = null;


            this.pepClient?.Dispose();

            this.pepClient = null;


            this.abuseClient?.Dispose();

            this.abuseClient = null;


#if DEBUG_XMPP_REMOTE || DEBUG_DB_REMOTE || DEBUG_NFC_REMOTE

            this.debugSniffer = null;

#endif

#if DEBUG_LOG_REMOTE

            if (this.debugEventSink is not null)

            {

                Log.Unregister(this.debugEventSink);

                this.debugEventSink?.Dispose();

                this.debugEventSink = null;

            }

#endif

            if (this.xmppClient is not null)

            {

                await this.xmppClient.DisposeAsync();

                this.xmppClient = null;

            }

        }


        private bool XmppStale()

        {

            return this.xmppClient is null ||

                this.xmppClient.State == XmppState.Offline ||

                this.xmppClient.State == XmppState.Error ||

                (this.xmppClient.State != XmppState.Connected && (DateTime.Now - this.xmppLastStateChange).TotalSeconds >= 10);

        }


        public ISniffer[] RemoteSniffers

        {

            get

            {

#if DEBUG_XMPP_REMOTE || DEBUG_DB_REMOTE || DEBUG_NFC_REMOTE

                if (this.debugSniffer is null)

                    return [];

                else

                    return [this.debugSniffer];


#else

                return [];

#endif

            }

        }


        private bool XmppParametersCurrent()

        {

            if (this.xmppClient is null)

                return false;


            if (this.domainName != ServiceRef.TagProfile.Domain)

                return false;


            if (this.accountName != ServiceRef.TagProfile.Account)

                return false;


            if (this.passwordHash != ServiceRef.TagProfile.XmppPasswordHash)

                return false;


            if (this.passwordHashMethod != ServiceRef.TagProfile.XmppPasswordHashMethod)

                return false;


            if (this.contractsClient?.ComponentAddress != ServiceRef.TagProfile.LegalJid)

                return false;


            if (this.fileUploadClient?.FileUploadJid != ServiceRef.TagProfile.HttpFileUploadJid)

                return false;


            if (this.thingRegistryClient?.ThingRegistryAddress != ServiceRef.TagProfile.RegistryJid)

                return false;


            if (this.provisioningClient?.ProvisioningServerAddress != ServiceRef.TagProfile.ProvisioningJid)

                return false;


            if (this.eDalerClient?.ComponentAddress != ServiceRef.TagProfile.EDalerJid)

                return false;


            if (this.neuroFeaturesClient?.ComponentAddress != ServiceRef.TagProfile.NeuroFeaturesJid)

                return false;


            if ((this.pushNotificationClient is null) ^ !ServiceRef.TagProfile.SupportsPushNotification)

                return false;


            return true;

        }


        private void RecreateReconnectTimer()

        {

            this.reconnectTimer?.Dispose();

            this.reconnectTimer = new Timer(this.ReconnectTimer_Tick, null, Constants.Intervals.Reconnect, Constants.Intervals.Reconnect);

        }


        [Obsolete("Use the DisposeAsync method.")]

        public void Dispose()

        {

            this.DisposeAsync().Wait();

        }


        public async Task DisposeAsync()

        {

            this.reconnectTimer?.Dispose();

            this.reconnectTimer = null;


            if (this.xmppFilteredEventSink is not null)

            {

                ServiceRef.LogService.RemoveListener(this.xmppFilteredEventSink);

                await this.xmppFilteredEventSink.SecondarySink.DisposeAsync();

                await this.xmppFilteredEventSink.DisposeAsync();

                this.xmppFilteredEventSink = null;

            }


            this.contractsClient?.Dispose();

            this.contractsClient = null;


            this.fileUploadClient?.Dispose();

            this.fileUploadClient = null;


            this.thingRegistryClient?.Dispose();

            this.thingRegistryClient = null;


            this.provisioningClient?.Dispose();

            this.provisioningClient = null;


            this.eDalerClient?.Dispose();

            this.eDalerClient = null;


            this.neuroFeaturesClient?.Dispose();

            this.neuroFeaturesClient = null;


            this.pushNotificationClient?.Dispose();

            this.pushNotificationClient = null;


            this.sensorClient?.Dispose();

            this.sensorClient = null;


            this.controlClient?.Dispose();

            this.controlClient = null;


            this.concentratorClient?.Dispose();

            this.concentratorClient = null;


            this.pepClient?.Dispose();

            this.pepClient = null;


            this.abuseClient?.Dispose();

            this.abuseClient = null;


            if (this.xmppClient is not null)

            {

                await this.xmppClient.DisposeAsync();

                this.xmppClient = null;

            }


            /*

            this.Dispose(true);

            GC.SuppressFinalize(this);

            */

        }


        /*

        protected virtual void Dispose(bool disposing)

        {

            if (this.isDisposed)

            {

                return;

            }


            if (disposing)

            {

                this.abuseClient.Dispose();

                this.contractsClient.Dispose();

                this.fileUploadClient.Dispose();

                this.httpxClient.Dispose();

                this.reconnectTimer.Dispose();

                this.sniffer.Dispose();

                this.xmppClient.Dispose();

                this.xmppFilteredEventSink.SecondarySink.Dispose();

                this.xmppFilteredEventSink.Dispose();

            }


            this.isDisposed = true;

        }

        */

#endregion


        #region Lifecycle


        public async Task<bool> WaitForConnectedState(TimeSpan Timeout)

        {

            if (this.xmppClient is null)

            {

                DateTime Start = DateTime.Now;


                while (this.xmppClient is null && DateTime.Now - Start < Timeout)

                    await Task.Delay(1000);


                if (this.xmppClient is null)

                    return false;


                Timeout -= DateTime.Now - Start;

            }


            if (this.xmppClient.State == XmppState.Connected)

                return true;


            if (Timeout < TimeSpan.Zero)

                return false;


            int i = await this.xmppClient.WaitStateAsync((int)Timeout.TotalMilliseconds, XmppState.Connected);

            return i >= 0;

        }


        public override Task Load(bool IsResuming, CancellationToken CancellationToken)

        {

            if (this.BeginLoad(IsResuming, CancellationToken))

            {

                try

                {

                    ServiceRef.TagProfile.StepChanged += this.TagProfile_StepChanged;

                    ServiceRef.TagProfile.Changed += this.TagProfile_Changed;


                    _ = this.CreateClientAsync();


                    this.EndLoad(true);

                }

                catch (Exception Ex)

                {

                    Ex = Log.UnnestException(Ex);

                    ServiceRef.LogService.LogException(Ex, this.GetClassAndMethod(MethodBase.GetCurrentMethod()));

                    this.EndLoad(false);

                }

            }

            return Task.CompletedTask;

        }


        private async Task CreateClientAsync()

        {

            try

            {

                if (ServiceRef.TagProfile.ShouldCreateClient() && !this.XmppParametersCurrent())

                    await this.CreateXmppClient();


                if ((this.xmppClient is not null) &&

                    this.xmppClient.State == XmppState.Connected &&

                    ServiceRef.TagProfile.IsCompleteOrWaitingForValidation())

                {

                    // Don't await this one, just fire and forget, to improve startup time.

                    _ = this.xmppClient.SetPresenceAsync(Availability.Online);

                }

            }

            catch (Exception ex)

            {

                ex = Log.UnnestException(ex);

                ServiceRef.LogService.LogException(ex, this.GetClassAndMethod(MethodBase.GetCurrentMethod()));

            }

        }


        public override Task Unload()

        {

            return this.Unload(false);

        }


        public Task UnloadFast()

        {

            return this.Unload(true);

        }


        private async Task Unload(bool fast)

        {

            if (this.BeginUnload())

            {

                try

                {

                    ServiceRef.TagProfile.StepChanged -= this.TagProfile_StepChanged;

                    ServiceRef.TagProfile.Changed -= this.TagProfile_Changed;


                    this.reconnectTimer?.Dispose();

                    this.reconnectTimer = null;


                    if (this.xmppClient is not null)

                    {

                        this.xmppClient.CheckConnection = false;


                        if (!fast)

                        {

                            try

                            {

                                await Task.WhenAny(

                                    this.xmppClient.SetPresenceAsync(Availability.Offline),

                                    Task.Delay(1000)    // Wait at most 1000 ms.

                                );

                            }

                            catch (Exception)

                            {

                                // Ignore

                            }

                        }

                    }


                    await this.DestroyXmppClient();

                }

                catch (Exception ex)

                {

                    ServiceRef.LogService.LogException(ex, this.GetClassAndMethod(MethodBase.GetCurrentMethod()));

                }


                this.EndUnload();

            }

        }


        private void TagProfile_StepChanged(object? Sender, EventArgs e)

        {

            if (!this.IsLoaded)

                return;


            Task ExecutionTask = Task.Run(async () =>

            {

                try

                {

                    bool CreateXmppClient = ServiceRef.TagProfile.ShouldCreateClient();


                    if (CreateXmppClient && !this.XmppParametersCurrent())

                        await this.CreateXmppClient();

                    else if (!CreateXmppClient)

                        await this.DestroyXmppClient();

                }

                catch (Exception ex)

                {

                    ServiceRef.LogService.LogException(ex);

                }

            });

        }


        private void TagProfile_Changed(object? Sender, PropertyChangedEventArgs e)

        {

            if (e.PropertyName == nameof(ITagProfile.Account))

                this.TagProfile_StepChanged(Sender, new EventArgs());

        }


        private Task XmppClient_Error(object? _, Exception e)

        {

            this.LatestError = e.Message;

            return Task.CompletedTask;

        }


        private Task XmppClient_ConnectionError(object? _, Exception e)

        {

            if (e is ObjectDisposedException)

                this.LatestConnectionError = ServiceRef.Localizer[nameof(AppResources.UnableToConnect)];

            else if (e is Waher.Networking.XMPP.AuthenticationErrors.NotAuthorizedException || e is Waher.Networking.XMPP.StreamErrors.NotAuthorizedException)

            {

                this.reconnectTimer?.Dispose();

                this.reconnectTimer = null;

                this.LatestConnectionError = e.Message;

            }

            else

                this.LatestConnectionError = e.Message;


            return Task.CompletedTask;

        }


        private async Task XmppClient_StateChanged(object? Sender, XmppState NewState)

        {

            this.xmppLastStateChange = DateTime.Now;


            switch (NewState)

            {

                case XmppState.Connecting:

                    this.LatestError = string.Empty;

                    this.LatestConnectionError = string.Empty;

                    break;


                case XmppState.Connected:

                    this.LatestError = string.Empty;

                    this.LatestConnectionError = string.Empty;


                    this.xmppConnected = true;


                    this.RecreateReconnectTimer();


                    if (string.IsNullOrEmpty(ServiceRef.TagProfile.XmppPasswordHashMethod))

                    {

                        ServiceRef.TagProfile.SetAccount(ServiceRef.TagProfile.Account ?? string.Empty,

                            this.xmppClient?.PasswordHash ?? string.Empty,

                            this.xmppClient?.PasswordHashMethod ?? string.Empty);

                    }

                    if (ServiceRef.TagProfile.NeedsUpdating() && await this.DiscoverServices())

                    {

                        if (this.contractsClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.LegalJid))

                        {

                            this.contractsClient = new ContractsClient(this.xmppClient, ServiceRef.TagProfile.LegalJid);

                            this.RegisterContractsEventHandlers();


                            if (!await this.contractsClient.LoadKeys(false))

                            {

                                this.contractsClient.Dispose();

                                this.contractsClient = null;

                            }

                        }


                        if (this.fileUploadClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.HttpFileUploadJid) && (ServiceRef.TagProfile.HttpFileUploadMaxSize > 0))

                            this.fileUploadClient = new HttpFileUploadClient(this.xmppClient, ServiceRef.TagProfile.HttpFileUploadJid, ServiceRef.TagProfile.HttpFileUploadMaxSize);


                        if (this.thingRegistryClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.RegistryJid))

                            this.thingRegistryClient = new ThingRegistryClient(this.xmppClient, ServiceRef.TagProfile.RegistryJid);


                        if (this.provisioningClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.RegistryJid))

                        {

                            this.provisioningClient = new ProvisioningClient(this.xmppClient, ServiceRef.TagProfile.ProvisioningJid)

                            {

                                ManagePresenceSubscriptionRequests = false

                            };


                            this.provisioningClient.CanControlQuestion += this.ProvisioningClient_CanControlQuestion;

                            this.provisioningClient.CanReadQuestion += this.ProvisioningClient_CanReadQuestion;

                            this.provisioningClient.IsFriendQuestion += this.ProvisioningClient_IsFriendQuestion;

                        }


                        if (this.eDalerClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.EDalerJid))

                        {

                            this.eDalerClient = new EDalerClient(this.xmppClient, this.contractsClient, ServiceRef.TagProfile.EDalerJid);

                            this.RegisterEDalerEventHandlers(this.eDalerClient);

                        }


                        if (this.neuroFeaturesClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.NeuroFeaturesJid))

                        {

                            this.neuroFeaturesClient = new NeuroFeaturesClient(this.xmppClient, this.contractsClient, ServiceRef.TagProfile.NeuroFeaturesJid);

                            this.RegisterNeuroFeatureEventHandlers(this.neuroFeaturesClient);

                        }


                        if (this.pushNotificationClient is null && ServiceRef.TagProfile.SupportsPushNotification)

                            this.pushNotificationClient = new PushNotificationClient(this.xmppClient);


                        if (this.pepClient is null && !string.IsNullOrWhiteSpace(ServiceRef.TagProfile.PubSubJid))

                        {

                            this.pepClient = new PepClient(this.xmppClient, ServiceRef.TagProfile.PubSubJid);

                            this.ReregisterPepEventHandlers(this.pepClient);

                            //this.RegisterPubSubEventHandlers(this.pubSubClient);

                        }

                    }


                    // Check is xmpp password needs updating.

                    if (ServiceRef.TagProfile.GetXmppPasswordNeedsUpdating())

                        await ServiceRef.XmppService.TryGenerateAndChangePassword();


                    if (this.xmppFilteredEventSink is not null)

                        ServiceRef.LogService.AddListener(this.xmppFilteredEventSink);

                    break;


                case XmppState.Offline:

                case XmppState.Error:

                    if (this.xmppConnected && !this.IsUnloading)

                    {

                        this.xmppConnected = false;


                        try

                        {

                            if (this.xmppClient is not null && !this.xmppClient.Disposed)

                                await this.xmppClient.Reconnect();

                        }

                        catch (Exception)

                        {

                            // Ignore

                        }

                    }

                    break;

            }


            await this.OnConnectionStateChanged(NewState);

        }


        public event EventHandlerAsync<XmppState>? ConnectionStateChanged;


        private async Task OnConnectionStateChanged(XmppState NewState)

        {

            await this.ConnectionStateChanged.Raise(this, NewState);

        }


        #endregion


        #region State


        public bool IsLoggedOut { get; private set; }

        public bool IsOnline => (this.xmppClient is not null) && this.xmppClient.State == XmppState.Connected;

        public XmppState State => this.xmppClient?.State ?? XmppState.Offline;

        public string BareJid => this.xmppClient?.BareJID ?? string.Empty;


        public string? LatestError { get; private set; }

        public string? LatestConnectionError { get; private set; }


        #endregion


        #region Connections


        private enum ConnectOperation

        {

            Connect,

            ConnectAndCreateAccount,

            ConnectToAccount

        }


        public Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnect(string domain, bool isIpAddress, string hostName, int portNumber,

            string languageCode, Assembly applicationAssembly, Func<XmppClient, Task> connectedFunc)

        {

            return this.TryConnectInner(domain, isIpAddress, hostName, portNumber, string.Empty, string.Empty, string.Empty, languageCode,

                string.Empty, string.Empty, applicationAssembly, connectedFunc, ConnectOperation.Connect);

        }


        public Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnectAndCreateAccount(string domain, bool isIpAddress, string hostName,

            int portNumber, string userName, string password, string languageCode, string ApiKey, string ApiSecret,

            Assembly applicationAssembly, Func<XmppClient, Task> connectedFunc)

        {

            return this.TryConnectInner(domain, isIpAddress, hostName, portNumber, userName, password, string.Empty, languageCode,

                ApiKey, ApiSecret, applicationAssembly, connectedFunc, ConnectOperation.ConnectAndCreateAccount);

        }


        public Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnectAndConnectToAccount(string domain, bool isIpAddress, string hostName,

            int portNumber, string userName, string password, string passwordMethod, string languageCode, Assembly applicationAssembly,

            Func<XmppClient, Task> connectedFunc)

        {

            return this.TryConnectInner(domain, isIpAddress, hostName, portNumber, userName, password, passwordMethod, languageCode,

                string.Empty, string.Empty, applicationAssembly, connectedFunc, ConnectOperation.ConnectToAccount);

        }


        private async Task<(bool Succeeded, string? ErrorMessage, string[]? Alternatives)> TryConnectInner(string Domain, bool IsIpAddress, string HostName,

            int PortNumber, string UserName, string Password, string PasswordMethod, string LanguageCode, string ApiKey, string ApiSecret,

            Assembly ApplicationAssembly, Func<XmppClient, Task> ConnectedFunc, ConnectOperation Operation)

        {

            // Use TaskCompletionSource for single completion

            TaskCompletionSource<bool> Tcs = new(TaskCreationOptions.RunContinuationsAsynchronously);


            // Flags for tracking progress and outcome

            bool StreamNegotiation = false, StreamOpened = false, StartingEncryption = false, Authenticating = false, Registering = false, IsTimeout = false;

            string? ConnectionError = null;

            string? ErrorMessage = null;

            string[]? Alternatives = null;


            XmppClient? Client = null;

            int Disposed = 0; // 0 = not disposed, 1 = disposing/disposing done


            // Local guard function for tcs

            void TrySetResult(bool result)

            {

                // Ensure only one completion and don't run during/after dispose

                if (Interlocked.CompareExchange(ref Disposed, 0, 0) == 0)

                    Tcs.TrySetResult(result);

            }


            // Connection error event handler

            Task OnConnectionError(object? _, Exception ex)

            {

                if (Interlocked.CompareExchange(ref Disposed, 0, 0) == 1)

                    return Task.CompletedTask; // Ignore after dispose


                switch (ex)

                {

                    case ObjectDisposedException:

                        ConnectionError = ServiceRef.Localizer[nameof(AppResources.UnableToConnect)];

                        break;

                    case Waher.Networking.XMPP.StreamErrors.NotAuthorizedException:

                        this.reconnectTimer?.Dispose();

                        this.reconnectTimer = null;

                        break;

                    case Waher.Networking.XMPP.StanzaErrors.ConflictException Conflict:

                        Alternatives = Conflict.Alternatives;

                        break;

                    default:

                        ConnectionError = ex.Message;

                        break;

                }


                TrySetResult(false);

                return Task.CompletedTask;

            }


            // State change event handler

            async Task OnStateChanged(object? _, XmppState newState)

            {

                if (Interlocked.CompareExchange(ref Disposed, 0, 0) == 1)

                    return;


                switch (newState)

                {

                    case XmppState.StreamNegotiation:

                        StreamNegotiation = true;

                        break;

                    case XmppState.StreamOpened:

                        StreamOpened = true;

                        break;

                    case XmppState.StartingEncryption:

                        StartingEncryption = true;

                        break;

                    case XmppState.Authenticating:

                        Authenticating = true;

                        if (Operation == ConnectOperation.Connect)

                            TrySetResult(true);

                        break;

                    case XmppState.Registering:

                        Registering = true;

                        break;

                    case XmppState.Connected:

                        TrySetResult(true);

                        break;

                    case XmppState.Offline:

                        TrySetResult(false);

                        break;

                    case XmppState.Error:

                        // Wait a bit for error event, but still time out if nothing else happens

                        await Task.Delay(Constants.Timeouts.XmppConnect);

                        TrySetResult(false);

                        break;

                }

            }


            try

            {

                if (string.IsNullOrEmpty(PasswordMethod))

                    Client = new XmppClient(HostName, PortNumber, UserName, Password, LanguageCode, ApplicationAssembly, this.sniffer);

                else

                    Client = new XmppClient(HostName, PortNumber, UserName, Password, PasswordMethod, LanguageCode, ApplicationAssembly, this.sniffer);


                if (Operation == ConnectOperation.ConnectAndCreateAccount)

                {

                    if (!string.IsNullOrEmpty(ApiKey) && !string.IsNullOrEmpty(ApiSecret))

                        Client.AllowRegistration(ApiKey, ApiSecret);

                    else

                        Client.AllowRegistration();

                }


                Client.TrustServer = !IsIpAddress;

                Client.AllowCramMD5 = false;

                Client.AllowDigestMD5 = false;

                Client.AllowPlain = false;

                Client.AllowEncryption = true;

                Client.AllowScramSHA1 = true;

                Client.AllowScramSHA256 = true;

                Client.AllowQuickLogin = true;


                // Register handlers

                Client.OnConnectionError += OnConnectionError;

                Client.OnStateChanged += OnStateChanged;


                // Begin connect

                Task ConnectTask = Client.Connect(IsIpAddress ? string.Empty : Domain);


                // Set up timeout with cancellation

                using CancellationTokenSource Cts = new (Constants.Timeouts.XmppConnect);


                Task CompletedTask = await Task.WhenAny(Tcs.Task, ConnectTask, Task.Delay(TimeSpan.FromSeconds(5), Cts.Token));

                bool Succeeded = false;


                if (CompletedTask == Tcs.Task)

                {

                    Succeeded = Tcs.Task.Result;

                }

                else if (CompletedTask == ConnectTask)

                {

                    // The connect operation finished before the state machine did,

                    // but we need to wait for state change events

                    Succeeded = await Tcs.Task;

                }

                else

                {

                    // Timeout

                    IsTimeout = true;

                    TrySetResult(false); // Attempt to signal timeout if not already completed

                    Succeeded = false;

                }


                // Call ConnectedFunc if successful

                if (Succeeded && ConnectedFunc is not null)

                    await ConnectedFunc(Client);


                // Remove event handlers BEFORE disposal

                Interlocked.Exchange(ref Disposed, 1);

                Client.OnStateChanged -= OnStateChanged;

                Client.OnConnectionError -= OnConnectionError;


                await Client.DisposeAsync();

                Client = null;


                // Set error message if needed

                if (!Succeeded && string.IsNullOrEmpty(ErrorMessage))

                {

                    if (this.sniffer is not null)

                        System.Diagnostics.Debug.WriteLine(await this.sniffer.SnifferToTextAsync(), "Sniffer");


                    if (!StreamNegotiation || IsTimeout)

                        ErrorMessage = ServiceRef.Localizer[nameof(AppResources.CantConnectTo), Domain];

                    else if (!StreamOpened)

                        ErrorMessage = ServiceRef.Localizer[nameof(AppResources.DomainIsNotAValidOperator), Domain];

                    else if (!StartingEncryption)

                        ErrorMessage = ServiceRef.Localizer[nameof(AppResources.DomainDoesNotFollowEncryptionPolicy), Domain];

                    else if (!Authenticating)

                        ErrorMessage = ServiceRef.Localizer[nameof(AppResources.UnableToAuthenticateWith), Domain];

                    else if (!Registering)

                    {

                        if (!string.IsNullOrWhiteSpace(ConnectionError))

                            ErrorMessage = ConnectionError;

                        else

                            ErrorMessage = ServiceRef.Localizer[nameof(AppResources.OperatorDoesNotSupportRegisteringNewAccounts), Domain];

                    }

                    else if (Operation == ConnectOperation.ConnectAndCreateAccount)

                        ErrorMessage = ServiceRef.Localizer[nameof(AppResources.UsernameNameAlreadyTaken), this.accountName ?? string.Empty];

                    else if (Operation == ConnectOperation.ConnectToAccount)

                        ErrorMessage = ServiceRef.Localizer[nameof(AppResources.InvalidUsernameOrPassword), this.accountName ?? string.Empty];

                    else

                        ErrorMessage = ServiceRef.Localizer[nameof(AppResources.UnableToConnectTo), Domain];

                }


                return (Succeeded, ErrorMessage, Alternatives);

            }

            catch (Exception ex)

            {

                ServiceRef.LogService.LogException(ex, new KeyValuePair<string, object?>(nameof(ConnectOperation), Operation.ToString()));

                return (false, ServiceRef.Localizer[nameof(AppResources.UnableToConnectTo), Domain], null);

            }

            finally

            {

                // Final fallback cleanup if not already disposed

                if (Client is not null)

                {

                    try

                    {

                        Interlocked.Exchange(ref Disposed, 1);

                        Client.OnStateChanged -= OnStateChanged;

                        Client.OnConnectionError -= OnConnectionError;

                        await Client.DisposeAsync();

                        Client = null;


                    }

                    catch { /* Swallow to avoid masking original exception */ }

                }

            }

        }


        private void ReconnectTimer_Tick(object? _)

        {

            if (this.xmppClient is null)

                return;


            if (!ServiceRef.NetworkService.IsOnline)

                return;


            if (this.XmppStale())

            {

                this.xmppLastStateChange = DateTime.Now;


                if (!this.xmppClient.Disposed)

                    SafeFireAndForget(this.xmppClient.Reconnect());

            }

        }

        private static void SafeFireAndForget(Task task)

        {

            if (task is null)

                return;


            _ = task.ContinueWith(t =>

            {

                if (t.Exception is not null)

                    ServiceRef.LogService.LogException(t.Exception);

            }, TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.RunContinuationsAsynchronously);

        }

        #endregion


        #region Password


        public Task<bool> ChangePassword(string NewPassword)

        {

            TaskCompletionSource<bool> PasswordChanged = new();


            this.XmppClient.ChangePassword(NewPassword, (sender, e) =>

            {

                PasswordChanged.TrySetResult(e.Ok);

                return Task.CompletedTask;

            }, null);


            return PasswordChanged.Task;

        }


        public async Task<bool> TryGenerateAndChangePassword()

        {

            bool ChangeSucceeded = false;


            try

            {

                string NewPassword = ServiceRef.CryptoService.CreateRandomPassword();

                if (await this.ChangePassword(NewPassword))

                {

                    ServiceRef.TagProfile.SetAccount(ServiceRef.TagProfile.Account!, NewPassword, string.Empty);

                    ChangeSucceeded = true;

                }

            }

            catch (Exception Ex)

            {

                ServiceRef.LogService.LogException(Ex, this.GetClassAndMethod(MethodBase.GetCurrentMethod()));

            }


            // Update the profile & timer based on success/failure:

            ServiceRef.TagProfile.SetXmppPasswordNeedsUpdating(!ChangeSucceeded);

            if (ChangeSucceeded)

            {

                this.updatePasswordTimer?.Dispose();

                this.updatePasswordTimer = null;

            }

            else

            {

                this.RecreateUpdatePasswordTimer();

            }


            return ChangeSucceeded;

        }


        private async void UpdatePasswordTimer_Tick(object? _)

        {

            if (this.xmppClient is null)

                return;


            if (!ServiceRef.NetworkService.IsOnline)

                return;


            await this.TryGenerateAndChangePassword();

        }


        private void RecreateUpdatePasswordTimer()

        {

            this.updatePasswordTimer?.Dispose();

            this.updatePasswordTimer = new Timer(this.UpdatePasswordTimer_Tick, null, Constants.Intervals.Reconnect, Constants.Intervals.Reconnect);

        }


        #endregion


        #region Components & Services


        public Task<ServiceDiscoveryEventArgs> SendServiceDiscoveryRequest(string FullJid)

        {

            TaskCompletionSource<ServiceDiscoveryEventArgs> Result = new();


            this.XmppClient.SendServiceDiscoveryRequest(FullJid, (_, e) =>

            {

                Result.TrySetResult(e);

                return Task.CompletedTask;

            }, null);


            return Result.Task;

        }


        public async Task<bool> DiscoverServices(XmppClient? Client = null)

        {

            Client ??= this.xmppClient;


            if (Client is null)

                return false;


            ServiceItemsDiscoveryEventArgs Response;


            try

            {

                Response = await Client.ServiceItemsDiscoveryAsync(null, string.Empty, string.Empty);

            }

            catch (Exception ex)

            {

                if (this.sniffer is not null)

                {

                    string CommsDump = await this.sniffer.SnifferToTextAsync();

                    ServiceRef.LogService.LogException(ex, new KeyValuePair<string, object?>("Sniffer", CommsDump));

                }


                return false;

            }


            List<Task> Tasks = [];

            object SynchObject = new();


            Tasks.Add(CheckFeatures(Client, SynchObject));


            foreach (Item Item in Response.Items)

                Tasks.Add(CheckComponent(Client, Item, SynchObject));


            await Task.WhenAll([.. Tasks]);


            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.LegalJid))

                return false;


            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.HttpFileUploadJid) || (ServiceRef.TagProfile.HttpFileUploadMaxSize <= 0))

                return false;


            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.LogJid))

                return false;


            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.EDalerJid))

                return false;


            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.NeuroFeaturesJid))

                return false;


            if (string.IsNullOrWhiteSpace(ServiceRef.TagProfile.PubSubJid))

                return false;


            if (!ServiceRef.TagProfile.SupportsPushNotification)

                return false;


            return true;

        }


        private static async Task CheckFeatures(XmppClient Client, object SynchObject)

        {

            ServiceDiscoveryEventArgs e = await Client.ServiceDiscoveryAsync(string.Empty);


            lock (SynchObject)

            {

                ServiceRef.TagProfile.SupportsPushNotification = e.HasFeature(PushNotificationClient.MessagePushNamespace);

            }

        }


        private static async Task CheckComponent(XmppClient Client, Item Item, object SynchObject)

        {

            ServiceDiscoveryEventArgs ItemResponse = await Client.ServiceDiscoveryAsync(null, Item.JID, Item.Node);


            lock (SynchObject)

            {

                if (ItemResponse.HasAnyFeature(ContractsClient.NamespacesLegalIdentities))

                    ServiceRef.TagProfile.LegalJid = Item.JID;


                if (ItemResponse.HasAnyFeature(ThingRegistryClient.NamespacesDiscovery))

                    ServiceRef.TagProfile.RegistryJid = Item.JID;


                if (ItemResponse.HasAnyFeature(ProvisioningClient.NamespacesProvisioningDevice) &&

                    ItemResponse.HasAnyFeature(ProvisioningClient.NamespacesProvisioningOwner) &&

                    ItemResponse.HasAnyFeature(ProvisioningClient.NamespacesProvisioningToken))

                {

                    ServiceRef.TagProfile.ProvisioningJid = Item.JID;

                }


                if (ItemResponse.HasFeature(HttpFileUploadClient.Namespace))

                {

                    long MaxSize = HttpFileUploadClient.FindMaxFileSize(Client, ItemResponse) ?? 0;

                    ServiceRef.TagProfile.SetFileUploadParameters(Item.JID, MaxSize);

                }


                if (ItemResponse.HasFeature(XmppEventSink.NamespaceEventLogging))

                    ServiceRef.TagProfile.LogJid = Item.JID;


                if (ItemResponse.HasFeature(XmppEventSink.NamespaceEventLogging))

                    ServiceRef.TagProfile.LogJid = Item.JID;


                if (ItemResponse.HasFeature(EDalerClient.NamespaceEDaler))

                    ServiceRef.TagProfile.EDalerJid = Item.JID;


                if (ItemResponse.HasFeature(NeuroFeaturesClient.NamespaceNeuroFeatures))

                    ServiceRef.TagProfile.NeuroFeaturesJid = Item.JID;


                if (ItemResponse.HasFeature(PubSubClient.NamespacePubSub))

                    ServiceRef.TagProfile.PubSubJid = Item.JID;

            }

        }


        #endregion


        #region Transfer


        private async Task TransferIdDelivered(object? Sender, MessageEventArgs e)

        {

            if (e.From != Constants.Domains.OnboardingDomain)

                return;


            string Code = XML.Attribute(e.Content, "code");

            bool Deleted = XML.Attribute(e.Content, "deleted", false);


            if (!Deleted)

                return;


            string CodesGenerated = await RuntimeSettings.GetAsync(Constants.Settings.TransferIdCodeSent, string.Empty);

            string[] Codes = CodesGenerated.Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);


            if (Array.IndexOf<string>(Codes, Code) < 0)

                return;


            await this.DestroyXmppClient();


            this.domainName = string.Empty;

            this.accountName = string.Empty;

            this.passwordHash = string.Empty;

            this.passwordHashMethod = string.Empty;

            this.xmppConnected = false;


            ServiceRef.TagProfile.ClearAll();

            if (App.Current is not null)

                await App.Current.ForceSaveAsync();

            await RuntimeSettings.SetAsync(Constants.Settings.TransferIdCodeSent, string.Empty);

            await Database.Provider.Flush();

            WeakReferenceMessenger.Default.Send(new RegistrationPageMessage(ServiceRef.TagProfile.Step));

            await ServiceRef.NavigationService.GoToAsync(nameof(OnboardingPage), new OnboardingNavigationArgs() { Scenario = OnboardingScenario.FullSetup });

        }


        public async Task AddTransferCode(string Code)

        {

            string CodesGenerated = await RuntimeSettings.GetAsync(Constants.Settings.TransferIdCodeSent, string.Empty);


            if (string.IsNullOrEmpty(CodesGenerated))

                CodesGenerated = Code;

            else

                CodesGenerated += "\r\n" + Code;


            await RuntimeSettings.SetAsync(Constants.Settings.TransferIdCodeSent, CodesGenerated);

            await Database.Provider.Flush();

        }


        #endregion


        #region Presence Subscriptions


        private async Task XmppClient_OnPresenceSubscribe(object? Sender, PresenceEventArgs e)

        {

            LegalIdentity? RemoteIdentity = null;

            string FriendlyName = string.IsNullOrWhiteSpace(e.NickName) ? e.FromBareJID : e.NickName;

            string? PhotoUrl = null;

            int PhotoWidth = 0;

            int PhotoHeight = 0;


            foreach (XmlNode N in e.Presence.ChildNodes)

            {

                if (N is XmlElement E && E.LocalName == "identity" && E.NamespaceURI == ContractsClient.NamespaceLegalIdentitiesCurrent)

                {

                    RemoteIdentity = LegalIdentity.Parse(E);

                    if (RemoteIdentity is not null)

                    {

                        FriendlyName = ContactInfo.GetFriendlyName(RemoteIdentity);


                        IdentityValidationEventArgs IdentityValidationEventArgs = await this.ContractsClient.ValidateAsync(RemoteIdentity);

                        IdentityStatus Status = IdentityValidationEventArgs.Status;

                        if (Status != IdentityStatus.Valid)

                        {

                            await e.Decline();


                            Log.Warning("Invalid ID received. Presence subscription declined.", e.FromBareJID, RemoteIdentity.Id, "IdValidationError",

                                new KeyValuePair<string, object?>("Recipient JID", this.BareJid),

                                new KeyValuePair<string, object?>("Sender JID", e.FromBareJID),

                                new KeyValuePair<string, object?>("Legal ID", RemoteIdentity.Id),

                                new KeyValuePair<string, object?>("Validation", Status));

                            return;

                        }


                        break;

                    }

                }

            }


            ContactInfo Info = await ContactInfo.FindByBareJid(e.FromBareJID);

            if ((Info is not null) && Info.AllowSubscriptionFrom.HasValue)

            {

                if (Info.AllowSubscriptionFrom.Value)

                    await e.Accept();

                else

                    await e.Decline();


                if (Info.FriendlyName != FriendlyName || ((RemoteIdentity is not null) && Info.LegalId != RemoteIdentity.Id))

                {

                    if (RemoteIdentity is not null)

                    {

                        Info.LegalId = RemoteIdentity.Id;

                        Info.LegalIdentity = RemoteIdentity;

                    }


                    Info.FriendlyName = FriendlyName;

                    await Database.Update(Info);

                }


                return;

            }


            if ((RemoteIdentity is not null) && (RemoteIdentity.Attachments is not null))

            {

                (PhotoUrl, PhotoWidth, PhotoHeight) = await PhotosLoader.LoadPhotoAsTemporaryFile(RemoteIdentity.Attachments,

                    Constants.QrCode.DefaultImageWidth, Constants.QrCode.DefaultImageHeight);

            }


            SubscriptionRequestViewModel SubscriptionRequestViewModel = new(e.FromBareJID, FriendlyName, PhotoUrl, PhotoWidth, PhotoHeight);

            SubscriptionRequestPopup SubscriptionRequestPopup = new(SubscriptionRequestViewModel);


            await ServiceRef.PopupService.PushAsync(SubscriptionRequestPopup);

            PresenceRequestAction Action = await SubscriptionRequestViewModel.Result;


            switch (Action)

            {

                case PresenceRequestAction.Accept:

                    await e.Accept();


                    if (Info is null)

                    {

                        Info = new ContactInfo()

                        {

                            AllowSubscriptionFrom = true,

                            BareJid = e.FromBareJID,

                            FriendlyName = string.IsNullOrWhiteSpace(e.NickName) ? e.FromBareJID : e.NickName,

                            IsThing = false

                        };


                        await Database.Insert(Info);

                    }

                    else if (!Info.AllowSubscriptionFrom.HasValue || !Info.AllowSubscriptionFrom.Value)

                    {

                        Info.AllowSubscriptionFrom = true;

                        await Database.Update(Info);

                    }


                    RosterItem? Item = this.XmppClient[e.FromBareJID];


                    if (Item is null || (Item.State != SubscriptionState.Both && Item.State != SubscriptionState.To))

                    {

                        SubscribeToViewModel SubscribeToViewModel = new(e.FromBareJID);

                        SubscribeToPopup SubscribeToPopup = new(SubscribeToViewModel);


                        await ServiceRef.PopupService.PushAsync(SubscribeToPopup);

                        bool? SubscribeTo = await SubscribeToViewModel.Result;


                        if (SubscribeTo.HasValue && SubscribeTo.Value)

                        {

                            string IdXml;


                            if (ServiceRef.TagProfile.LegalIdentity is null)

                                IdXml = string.Empty;

                            else

                            {

                                StringBuilder Xml = new();

                                ServiceRef.TagProfile.LegalIdentity.Serialize(Xml, true, true, true, true, true, true, true);

                                IdXml = Xml.ToString();

                            }


                            await e.Client.RequestPresenceSubscription(e.FromBareJID, IdXml);

                        }

                    }

                    break;


                case PresenceRequestAction.Reject:

                    await e.Decline();


                    if (this.abuseClient is null)

                        break;


                    ReportOrBlockViewModel ReportOrBlockViewModel = new(e.FromBareJID);

                    ReportOrBlockPopup ReportOrBlockPopup = new(ReportOrBlockViewModel);


                    await ServiceRef.PopupService.PushAsync(ReportOrBlockPopup);

                    ReportOrBlockAction ReportOrBlock = await ReportOrBlockViewModel.Result;


                    if (ReportOrBlock == ReportOrBlockAction.Block || ReportOrBlock == ReportOrBlockAction.Report)

                    {

                        if (Info is null)

                        {

                            Info = new ContactInfo()

                            {

                                AllowSubscriptionFrom = false,

                                BareJid = e.FromBareJID,

                                FriendlyName = string.IsNullOrWhiteSpace(e.NickName) ? e.FromBareJID : e.NickName,

                                IsThing = false

                            };


                            await Database.Insert(Info);

                        }

                        else if (!Info.AllowSubscriptionFrom.HasValue || Info.AllowSubscriptionFrom.Value)

                        {

                            Info.AllowSubscriptionFrom = false;

                            await Database.Update(Info);

                        }


                        if (ReportOrBlock == ReportOrBlockAction.Report)

                        {

                            ReportTypeViewModel ReportTypeViewModel = new(e.FromBareJID);

                            ReportTypePopup ReportTypePopup = new(ReportTypeViewModel);


                            await ServiceRef.PopupService.PushAsync(ReportTypePopup);

                            ReportingReason? ReportType = await ReportTypeViewModel.Result;


                            if (ReportType.HasValue)

                            {

                                TaskCompletionSource<bool> Result = new();


                                await this.abuseClient.BlockJID(e.FromBareJID, ReportType.Value, (sender2, e2) =>

                                {

                                    Result.TrySetResult(e.Ok);

                                    return Task.CompletedTask;

                                }, null);


                                await Result.Task;

                            }

                        }

                    }

                    break;


                case PresenceRequestAction.Ignore:

                default:

                    break;

            }


            await this.OnPresenceSubscribe.Raise(this, e);

        }


        private async Task XmppClient_OnPresenceUnsubscribed(object? Sender, PresenceEventArgs e)

        {

            ContactInfo ContactInfo = await ContactInfo.FindByBareJid(e.FromBareJID);

            if ((ContactInfo is not null) && ContactInfo.AllowSubscriptionFrom.HasValue && ContactInfo.AllowSubscriptionFrom.Value)

            {

                ContactInfo.AllowSubscriptionFrom = null;

                await Database.Update(ContactInfo);

            }


            await this.OnPresenceUnsubscribed.Raise(this, e);

        }


        #endregion


        #region IQ Stanzas (Information Query)


        public Task<XmlElement> IqSetAsync(string To, string Xml)

        {

            return this.XmppClient.IqSetAsync(To, Xml);

        }


        private XmppClient XmppClient

        {

            get

            {

                if (this.xmppClient is null)

                    throw new Exception("Not connected to XMPP network.");


                return this.xmppClient;

            }

        }


        #endregion


        #region Messages


        public void SendMessage(QoSLevel QoS, Waher.Networking.XMPP.MessageType Type, string Id, string To, string CustomXml, string Body,

            string Subject, string Language, string ThreadId, string ParentThreadId, EventHandlerAsync<DeliveryEventArgs>? DeliveryCallback, object? State)

        {

            this.XmppClient.SendMessage(QoS, Type, Id, To, CustomXml, Body, Subject, Language, ThreadId, ParentThreadId, DeliveryCallback, State);

            //TODO: ENABLE E2E

        }


        private Task XmppClient_OnNormalMessage(object? Sender, MessageEventArgs e)

        {

            Log.Warning("Unhandled message received.", e.To, e.From,

                new KeyValuePair<string, object?>("Stanza", e.Message.OuterXml));


            return Task.CompletedTask;

        }


        private async Task XmppClient_OnChatMessage(object? Sender, MessageEventArgs e)

        {

            string RemoteBareJid = e.FromBareJID;


            foreach (XmlNode N in e.Message.ChildNodes)

            {

                if (N is XmlElement E &&

                    E.LocalName == "qlRef" &&

                    E.NamespaceURI == XmppClient.NamespaceQuickLogin &&

                    RemoteBareJid.IndexOf('@') < 0 &&

                    RemoteBareJid.IndexOf('/') < 0)

                {

                    LegalIdentity? RemoteIdentity = null;


                    foreach (XmlNode N2 in E.ChildNodes)

                    {

                        if (N2 is XmlElement E2 &&

                            E2.LocalName == "identity" &&

                            E2.NamespaceURI == ContractsClient.NamespaceLegalIdentitiesCurrent)

                        {

                            RemoteIdentity = LegalIdentity.Parse(E2);

                            break;

                        }

                    }


                    if (RemoteIdentity is not null)

                    {

                        IdentityStatus Status = await this.ValidateIdentity(RemoteIdentity);

                        if (Status != IdentityStatus.Valid)

                        {

                            Log.Warning("Message rejected because the embedded legal identity was not valid.",

                                new KeyValuePair<string, object?>("Identity", RemoteIdentity.Id),

                                new KeyValuePair<string, object?>("From", RemoteBareJid),

                                new KeyValuePair<string, object?>("Status", Status));

                            return;

                        }


                        string Jid = RemoteIdentity["JID"];


                        if (string.IsNullOrEmpty(Jid))

                        {

                            Log.Warning("Message rejected because the embedded legal identity lacked JID.",

                                new KeyValuePair<string, object?>("Identity", RemoteIdentity.Id),

                                new KeyValuePair<string, object?>("From", RemoteBareJid),

                                new KeyValuePair<string, object?>("Status", Status));

                            return;

                        }


                        if (!string.Equals(XML.Attribute(E, "bareJid", string.Empty), Jid, StringComparison.OrdinalIgnoreCase))

                        {

                            Log.Warning("Message rejected because the embedded legal identity had a different JID compared to the JID of the quick-login reference.",

                                new KeyValuePair<string, object?>("Identity", RemoteIdentity.Id),

                                new KeyValuePair<string, object?>("From", RemoteBareJid),

                                new KeyValuePair<string, object?>("Status", Status));

                            return;

                        }


                        RemoteBareJid = Jid;

                    }

                }

            }


            ContactInfo ContactInfo = await ContactInfo.FindByBareJid(RemoteBareJid);

            string FriendlyName = ContactInfo?.FriendlyName ?? RemoteBareJid;

            string? ReplaceObjectId = null;


            ChatMessage Message = new()

            {

                Created = DateTime.UtcNow,

                RemoteBareJid = RemoteBareJid,

                RemoteObjectId = e.Id,

                MessageType = NeuroAccessMaui.UI.Pages.Contacts.Chat.MessageType.Received,

                Html = string.Empty,

                PlainText = e.Body,

                Markdown = string.Empty

            };


            foreach (XmlNode N in e.Message.ChildNodes)

            {

                if (N is XmlElement E)

                {

                    switch (N.LocalName)

                    {

                        case "content":

                            if (E.NamespaceURI == "urn:xmpp:content")

                            {

                                string Type = XML.Attribute(E, "type");


                                switch (Type)

                                {

                                    case "text/markdown":

                                        Message.Markdown = E.InnerText;

                                        break;


                                    case "text/plain":

                                        Message.PlainText = E.InnerText;

                                        break;


                                    case "text/html":

                                        Message.Html = E.InnerText;

                                        break;

                                }

                            }

                            break;


                        case "html":

                            if (E.NamespaceURI == "http://jabber.org/protocol/xhtml-im")

                            {

                                string Html = E.InnerXml;


                                int i = Html.IndexOf("<body", StringComparison.OrdinalIgnoreCase);

                                if (i >= 0)

                                {

                                    i = Html.IndexOf('>', i + 5);

                                    if (i >= 0)

                                        Html = Html[(i + 1)..].TrimStart();


                                    i = Html.LastIndexOf("</body>", StringComparison.OrdinalIgnoreCase);

                                    if (i >= 0)

                                        Html = Html[..i].TrimEnd();

                                }


                                Message.Html = Html;

                            }

                            break;


                        case "replace":

                            if (E.NamespaceURI == "urn:xmpp:message-correct:0")

                                ReplaceObjectId = XML.Attribute(E, "id");

                            break;


                        case "delay":

                            if (E.NamespaceURI == PubSubClient.NamespaceDelayedDelivery &&

                                E.HasAttribute("stamp") &&

                                XML.TryParse(E.GetAttribute("stamp"), out DateTime Timestamp2))

                            {

                                Message.Created = Timestamp2.ToUniversalTime();

                            }

                            break;

                    }

                }

            }


            if (!string.IsNullOrEmpty(Message.Markdown))

            {

                try

                {

                    MarkdownSettings Settings = new()

                    {

                        AllowScriptTag = false,

                        EmbedEmojis = false,    // TODO: Emojis

                        AudioAutoplay = false,

                        AudioControls = false,

                        ParseMetaData = false,

                        VideoAutoplay = false,

                        VideoControls = false

                    };


                    MarkdownDocument Doc = await MarkdownDocument.CreateAsync(Message.Markdown, Settings);


                    if (string.IsNullOrEmpty(Message.PlainText))

                        Message.PlainText = (await Doc.GeneratePlainText()).Trim();


                    if (string.IsNullOrEmpty(Message.Html))

                        Message.Html = HtmlDocument.GetBody(await Doc.GenerateHTML());

                }

                catch (Exception ex)

                {

                    ServiceRef.LogService.LogException(ex);

                    Message.Markdown = string.Empty;

                }

            }


            if (string.IsNullOrEmpty(ReplaceObjectId))

                await Database.Insert(Message);

            else

            {

                ChatMessage Old = await Database.FindFirstIgnoreRest<ChatMessage>(new FilterAnd(

                    new FilterFieldEqualTo("RemoteBareJid", RemoteBareJid),

                    new FilterFieldEqualTo("RemoteObjectId", ReplaceObjectId)));


                if (Old is null)

                {

                    ReplaceObjectId = null;

                    await Database.Insert(Message);

                }

                else

                {

                    Old.Updated = Message.Created;

                    Old.Html = Message.Html;

                    Old.PlainText = Message.PlainText;

                    Old.Markdown = Message.Markdown;


                    await Database.Update(Old);


                    Message = Old;

                }

            }


            MainThread.BeginInvokeOnMainThread(async () =>

            {

                if (ServiceRef.NavigationService.CurrentPage is ChatPage &&

                    ServiceRef.NavigationService.CurrentPage.BindingContext is ChatViewModel ChatViewModel &&

                    string.Equals(ChatViewModel.BareJid, RemoteBareJid, StringComparison.OrdinalIgnoreCase))

                {

                    if (string.IsNullOrEmpty(ReplaceObjectId))

                        await ChatViewModel.MessageAddedAsync(Message);

                    else

                        await ChatViewModel.MessageUpdatedAsync(Message);

                }

                else

                {

                    string Title = ServiceRef.Localizer[nameof(AppResources.NotificationChatTitle), RemoteBareJid];

                    string Body = ServiceRef.Localizer[nameof(AppResources.NotificationChatBody)];


                    NotificationIntent Intent = new()

                    {

                        Channel = Constants.PushChannels.Messages,

                        Title = Title,

                        Body = Body,

                        Action = NotificationAction.OpenChat,

                        EntityId = RemoteBareJid,

                        CorrelationId = RemoteBareJid,

                        Presentation = NotificationPresentation.StoreOnly

                    };


                    await ServiceRef.Provider.GetRequiredService<INotificationServiceV2>().AddAsync(Intent, NotificationSource.Xmpp, null, CancellationToken.None);

                }

            });

        }


        private Task ContractsClient_ClientMessage(object? Sender, ClientMessageEventArgs e)

        {

            string Message = e.Body ?? string.Empty;


            if (!string.IsNullOrEmpty(e.Code))

            {

                try

                {

                    string Key = "ClientMessage" + e.Code;

                    string LocalizedMessage = ServiceRef.Localizer[Key, false];


                    if (!string.IsNullOrEmpty(LocalizedMessage) && !LocalizedMessage.Equals(Key, StringComparison.Ordinal))

                    {

                        Message = LocalizedMessage;

                    }

                }

                catch (Exception)

                {

                    // Ignore localization lookup issues.

                }

            }


            ApplicationReview? Review = BuildApplicationReview(e, Message);


            // Persist rejection details on current KYC reference, and reflect in UI if open

            MainThread.BeginInvokeOnMainThread(async () =>

                {

                    try

                    {

                        KycReference? Ref = null;

                        LegalIdentity? AppId = ServiceRef.TagProfile.IdentityApplication;


                        if (AppId is not null)

                        {

                            try

                            {

                                Ref = await Database.FindFirstIgnoreRest<KycReference>(new FilterFieldEqualTo(nameof(KycReference.CreatedIdentityId), AppId.Id));

                            }

                            catch (Exception Ex2)

                            {

                                ServiceRef.LogService.LogException(Ex2);

                            }

                        }


                        if (Ref is null)

                        {

                            try

                            {

                                List<KycReference> All = [.. await Database.Find<KycReference>()];

                                if (AppId is not null)

                                {

                                    Ref = All.FirstOrDefault(r => string.Equals(r.CreatedIdentityId, AppId.Id, StringComparison.OrdinalIgnoreCase));

                                }


                                Ref ??= All

                                    .Where(r => r.CreatedIdentityState == IdentityState.Created && !string.IsNullOrEmpty(r.CreatedIdentityId))

                                    .OrderByDescending(r => r.UpdatedUtc)

                                    .FirstOrDefault();


                                Ref ??= All

                                    .Where(r => !string.IsNullOrEmpty(r.CreatedIdentityId))

                                    .OrderByDescending(r => r.UpdatedUtc)

                                    .FirstOrDefault();

                            }

                            catch (Exception Ex3)

                            {

                                ServiceRef.LogService.LogException(Ex3);

                            }

                        }


                        if (Ref is not null && Review is not null)

                        {

                            await ServiceRef.KycService.ApplyApplicationReviewAsync(Ref, Review);


                            if (ServiceRef.NavigationService.CurrentPage is KycProcessPage Page && Page.BindingContext is KycProcessViewModel Vm)

                            {

                                await Vm.ApplyApplicationReviewAsync(Review);

                            }

                        }

                    }

                    catch (Exception Ex)

                    {

                        ServiceRef.LogService.LogException(Ex);

                    }

                });


            // TODO: Event arguments contain more detailed information about:

            //

            //  Properties & attachments that have been validated: e.ValidClaims, e.ValidPhotos

            //  Properties & attachments that have been invalidated: e.InvalidClaims, e.InvalidPhotos

            //  Properties & attachments that are still unvalidated: e.UnvalidatedClaims, e.UnvalidatedPhotos

            //

            // Body message only contains first message reported.

            //

            // Codes that need localized messages (defined in broker & services):

            //

            // ManualReview: Unable to validate application automatically. The application needs to be validated manually, or by peer review.

            // UnableReview: Unable to validate the review.

            // InvalidType: "Expected value of type " + typeof(T).FullName + "."

            // IdMismatch: Identifier does not correspond to created identifier.

            // JidMismatch: JID does not correspond to client JID.

            // AccountMismatch: Account name does not match account.

            // ProviderMismatch: Provider does not match legal component address.

            // StateMismatch: State does not match identity state.

            // CreatedMismatch: Created does not match identity creation timestamp.

            // UpdatedMismatch: Updated does not match identity update timestamp.

            // FromMismatch: From does not match identity creation timestamp.

            // ToMismatch: To does not match identity creation timestamp.

            // NoClientURL: No Client URL provided.

            // ReviewerExternal: Peer reviewer is external. Peer-review request should be sent directly to reviewer.

            // ServiceNotConfigured: Service not configured correctly. Please contact operator.

            // MissingCountry: Application does not contain country information.

            // CountryNotSupported: Service not available in your country.

            // MissingPNr: Application does not contain a personal number.

            // NoCompanyId: Service cannot be used to review company IDs.

            // ServiceClientTimeout: Service timed out waiting for user to approve request.

            // ServiceFailed: Service failed to process request.

            // PNrMismatch: Personal number mismatch.

            // FirstNameMismatch: First name mismatch.

            // LastNameMismatch: Last name mismatch.

            // NameMismatch: Name mismatch.

            // InvalidJid: Invalid JID.

            // NoLogin: No login registered on Neuron.

            // UnexpectedOnboardingServer: Unexpected response received from onboarding server.

            // PersonDead: Person is dead.

            // BirthDateMismatch: Birth date mismatch.

            // AddressMismatch: Address mismatch.

            // ZipMismatch: Postal Code mismatch.

            // AreaMismatch: Area mismatch.

            // CityMismatch: City mismatch.

            // RegionMismatch: Region mismatch.

            // LivenessFailed: Liveness check failed.

            // PhotoFake: Photo is fake.

            // PhotoPoor: Photo has poor quality.

            // BankIdRFA1: Start your BankID app.

            // BankIdRFA2: The BankID app is not installed. Please contact your internet bank.

            // BankIdRFA3: Action cancelled. Please try again.

            // BankIdRFA4: An identification or signing for this personal number is already started. Please try again.

            // BankIdRFA5: Internal error. Please try again.

            // BankIdRFA6: Action cancelled.

            // BankIdRFA8: The BankID app is not responding. Please check that the program is started and that you have internet access. If you don�t have a valid BankID you can get one from your bank. Try again.

            // BankIdRFA9: Enter your security code in the BankID app and select Identify or Sign.

            // BankIdRFA13: Trying to start your BankID app.

            // BankIdRFA14A: Searching for BankID:s, it may take a little while... If a few seconds have passed and still no BankID has been found, you probably don�t have a BankID which can be used for this identification/signing on this computer. If you have a BankID card, please insert it into your card reader. If you don�t have a BankID you can order one from your internet bank. If you have a BankID on another device you can start the BankID app on that device.

            // BankIdRFA14B: Searching for BankID:s, it may take a little while... If a few seconds have passed and still no BankID has been found, you probably don�t have a BankID which can be used for this identification/signing on this device. If you don�t have a BankID you can order one from your internet bank. If you have a BankID on another device you can start the BankID app on that device.

            // BankIdRFA15A: Searching for BankID:s, it may take a little while... If a few seconds have passed and still no BankID has been found, you probably don�t have a BankID which can be used for this identification/signing on this computer. If you have a BankID card, please insert it into your card reader. If you don�t have a BankID you can order one from your internet bank.

            // BankIdRFA15B: Searching for BankID:s, it may take a little while... If a few seconds have passed and still no BankID has been found, you probably don�t have a BankID which can be used for this identification/signing on this device. If you don�t have a BankID you can order one from your internet bank

            // BankIdRFA16: The BankID you are trying to use is revoked or too old. Please use another BankID or order a new one from your internet bank.

            // BankIdRFA17A: The BankID app couldn�t be found on your computer or mobile device. Please install it and order a BankID from your internet bank. Install the app from your app store or https://install.bankid.com.

            // BankIdRFA17B: Failed to scan the QR code. Start the BankID app and scan the QR code. Check that the BankID app is up to date. If you don't have the BankID app, you need to install it and order a BankID from your internet bank. Install the app from your app store or https://install.bankid.com.

            // BankIdRFA18: Start the BankID app

            // BankIdRFA19: Would you like to identify yourself or sign with a BankID on this computer or with a Mobile BankID?

            // BankIdRFA20: Would you like to identify yourself or sign with a BankID on this device or with a BankID on another device?

            // BankIdRFA21: Identification or signing in progress.

            // BankIdRFA22: Unknown error. Please try again.

            Message = Message.Trim();


            bool ShouldShowAlert = Review is null ||

                (Review.InvalidClaims.Length == 0 &&

                Review.InvalidPhotos.Length == 0 &&

                Review.UnvalidatedClaims.Length == 0 &&

                Review.UnvalidatedPhotos.Length == 0);


            if (ShouldShowAlert)

            {

                MainThread.BeginInvokeOnMainThread(async () =>

                {

                    await ServiceRef.UiService.DisplayAlert(

                        ServiceRef.Localizer[nameof(AppResources.ErrorTitle)], string.IsNullOrEmpty(Message) ? ServiceRef.Localizer[nameof(AppResources.SomethingWentWrong)] : Message,

                        ServiceRef.Localizer[nameof(AppResources.Ok)]);

                });

            }


            return Task.CompletedTask;

        }


        #endregion


        private static ApplicationReview? BuildApplicationReview(ClientMessageEventArgs e, string message)

        {

            try

            {

                ApplicationReview Candidate = new()

                {

                    Message = message,

                    Code = e.Code,

                    ReceivedUtc = DateTime.UtcNow

                };


                try

                {

                    IEnumerable<InvalidClaim> InvalidClaimsEnumerable = e.InvalidClaims as IEnumerable<InvalidClaim> ?? Array.Empty<InvalidClaim>();

                    List<string> InvalidClaimNames = [];

                    List<ApplicationReviewClaimDetail> InvalidClaimDetailList = [];


                    foreach (InvalidClaim InvalidClaim in InvalidClaimsEnumerable)

                    {

                        if (InvalidClaim is null || string.IsNullOrWhiteSpace(InvalidClaim.Claim))

                            continue;


                        string ClaimValue = InvalidClaim.Claim.Trim();

                        if (ClaimValue.Length == 0)

                            continue;


                        InvalidClaimNames.Add(ClaimValue);


                        ApplicationReviewClaimDetail Detail = new(

                            ClaimValue,

                            InvalidClaim.Reason ?? string.Empty,

                            InvalidClaim.ReasonLanguage,

                            InvalidClaim.ReasonCode,

                            InvalidClaim.Service ?? string.Empty);

                        InvalidClaimDetailList.Add(Detail);

                    }


                    Candidate.InvalidClaims = InvalidClaimNames.Count > 0 ? [.. InvalidClaimNames] : [];

                    Candidate.InvalidClaimDetails = InvalidClaimDetailList.Count > 0 ? [.. InvalidClaimDetailList] : [];

                }

                catch

                {

                    // Ignore conversion issues.

                }


                try

                {

                    IEnumerable<InvalidPhoto> InvalidPhotosEnumerable = e.InvalidPhotos as IEnumerable<InvalidPhoto> ?? Array.Empty<InvalidPhoto>();

                    List<string> InvalidPhotoNames = [];

                    List<ApplicationReviewPhotoDetail> InvalidPhotoDetailList = [];


                    foreach (InvalidPhoto InvalidPhoto in InvalidPhotosEnumerable)

                    {

                        if (InvalidPhoto is null || string.IsNullOrWhiteSpace(InvalidPhoto.FileName))

                            continue;


                        string FileName = InvalidPhoto.FileName.Trim();

                        if (FileName.Length == 0)

                            continue;


                        string FileNameWithoutExtension = Path.GetFileNameWithoutExtension(FileName);

                        string DisplayName = string.IsNullOrEmpty(FileNameWithoutExtension) ? FileName : FileNameWithoutExtension;

                        DisplayName = DisplayName.Trim();

                        if (DisplayName.Length == 0)

                            DisplayName = FileName;


                        InvalidPhotoNames.Add(DisplayName);


                        ApplicationReviewPhotoDetail Detail = new(

                            FileName,

                            DisplayName,

                            InvalidPhoto.Reason ?? string.Empty,

                            InvalidPhoto.ReasonLanguage,

                            InvalidPhoto.ReasonCode,

                            InvalidPhoto.Service ?? string.Empty);

                        InvalidPhotoDetailList.Add(Detail);

                    }


                    Candidate.InvalidPhotos = InvalidPhotoNames.Count > 0 ? [.. InvalidPhotoNames] : [];

                    Candidate.InvalidPhotoDetails = InvalidPhotoDetailList.Count > 0 ? [.. InvalidPhotoDetailList] : [];

                }

                catch

                {

                    // Ignore conversion issues.

                }


                try

                {

                    IEnumerable<string> UnvalidatedClaimsEnumerable = e.UnvalidatedClaims as IEnumerable<string> ?? [];

                    List<string> UnvalidatedClaimList = [];

                    foreach (string Claim in UnvalidatedClaimsEnumerable)

                    {

                        if (string.IsNullOrWhiteSpace(Claim))

                            continue;


                        string TrimmedClaim = Claim.Trim();

                        if (TrimmedClaim.Length > 0)

                            UnvalidatedClaimList.Add(TrimmedClaim);

                    }


                    Candidate.UnvalidatedClaims = UnvalidatedClaimList.Count > 0 ? [.. UnvalidatedClaimList] : [];

                }

                catch

                {

                    // Ignore conversion issues.

                }


                try

                {

                    IEnumerable<string> UnvalidatedPhotosEnumerable = e.UnvalidatedPhotos as IEnumerable<string> ?? [];

                    List<string> UnvalidatedPhotoList = [];

                    foreach (string Photo in UnvalidatedPhotosEnumerable)

                    {

                        if (string.IsNullOrWhiteSpace(Photo))

                            continue;


                        string TrimmedPhoto = Photo.Trim();

                        if (TrimmedPhoto.Length > 0)

                            UnvalidatedPhotoList.Add(TrimmedPhoto);

                    }


                    Candidate.UnvalidatedPhotos = UnvalidatedPhotoList.Count > 0 ? [.. UnvalidatedPhotoList] : [];

                }

                catch

                {

                    // Ignore conversion issues.

                }


                bool HasMeaningfulData =

                    !string.IsNullOrEmpty(Candidate.Message) ||

                    !string.IsNullOrEmpty(Candidate.Code) ||

                    Candidate.InvalidClaims.Length > 0 ||

                    Candidate.InvalidPhotos.Length > 0 ||

                    Candidate.UnvalidatedClaims.Length > 0 ||

                    Candidate.UnvalidatedPhotos.Length > 0;


                return HasMeaningfulData ? Candidate : null;

            }

            catch (Exception Ex)

            {

                ServiceRef.LogService.LogException(Ex);

                return null;

            }

        }


        #region Presence


        private async Task XmppClient_OnPresence(object? Sender, PresenceEventArgs e)

        {

            await this.OnPresence.Raise(this, e);

        }


        public event EventHandlerAsync<PresenceEventArgs>? OnPresence;


        public event EventHandlerAsync<PresenceEventArgs>? OnPresenceSubscribe;


        public event EventHandlerAsync<PresenceEventArgs>? OnPresenceUnsubscribed;


        public void RequestPresenceSubscription(string BareJid)

        {

            this.XmppClient.RequestPresenceSubscription(BareJid);

        }


        public void RequestPresenceSubscription(string BareJid, string CustomXml)

        {

            this.XmppClient.RequestPresenceSubscription(BareJid, CustomXml);

        }


        public void RequestPresenceUnsubscription(string BareJid)

        {

            this.XmppClient.RequestPresenceUnsubscription(BareJid);

        }


        public void RequestRevokePresenceSubscription(string BareJid)

        {

            this.XmppClient.RequestRevokePresenceSubscription(BareJid);

        }


        #endregion


        #region Roster


        public RosterItem[] Roster => this.xmppClient?.Roster ?? [];


        public RosterItem? GetRosterItem(string BareJid)

        {

            return this.XmppClient?.GetRosterItem(BareJid);

        }


        public void AddRosterItem(RosterItem Item)

        {

            this.XmppClient.AddRosterItem(Item);

        }


        public void RemoveRosterItem(string BareJid)

        {

            this.XmppClient.RemoveRosterItem(BareJid);

        }


        private async Task XmppClient_OnRosterItemAdded(object? Sender, RosterItem Item)

        {

            await this.OnRosterItemAdded.Raise(this, Item);

        }


        public event EventHandlerAsync<RosterItem>? OnRosterItemAdded;


        private async Task XmppClient_OnRosterItemUpdated(object? Sender, RosterItem Item)

        {

            await this.OnRosterItemUpdated.Raise(this, Item);

        }


        public event EventHandlerAsync<RosterItem>? OnRosterItemUpdated;


        private async Task XmppClient_OnRosterItemRemoved(object? Sender, RosterItem Item)

        {

            await this.OnRosterItemRemoved.Raise(this, Item);

        }


        public event EventHandlerAsync<RosterItem>? OnRosterItemRemoved;


        #endregion


        #region Push Notification


        public bool SupportsPushNotification => this.pushNotificationClient is not null;


        private PushNotificationClient PushNotificationClient

        {

            get

            {

                if (this.pushNotificationClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.PushNotificationServiceNotFound)]);


                return this.pushNotificationClient;

            }

        }


        public async Task<bool> NewPushNotificationToken(TokenInformation TokenInformation)

        {

            // TODO: Check if started


            if (this.pushNotificationClient is null || !this.IsOnline || string.IsNullOrEmpty(TokenInformation.Token))

                return false;

            else

            {

                await this.ReportNewPushNotificationToken(TokenInformation.Token, TokenInformation.Service, TokenInformation.ClientType);


                return true;

            }

        }


        public Task ReportNewPushNotificationToken(string Token, PushMessagingService Service, ClientType ClientType)

        {

            return this.PushNotificationClient.NewTokenAsync(Token, Service, ClientType);

        }


        public Task ClearPushNotificationRules()

        {

            return this.PushNotificationClient.ClearRulesAsync();

        }


        public Task AddPushNotificationRule(Waher.Networking.XMPP.MessageType MessageType, string LocalName, string Namespace,

            string Channel, string MessageVariable, string PatternMatchingScript, string ContentScript)

        {

            return this.PushNotificationClient.AddRuleAsync(MessageType, LocalName, Namespace, Channel, MessageVariable,

                PatternMatchingScript, ContentScript);

        }


        #endregion


        #region Tokens


        public async Task<string?> GetApiToken(int Seconds)

        {

            DateTime Now = DateTime.UtcNow;


            if (!string.IsNullOrEmpty(this.token) && Now.Subtract(this.tokenCreated).TotalSeconds < Seconds - 10)

                return this.token;


            if (!this.IsOnline)

            {

                if (!await this.WaitForConnectedState(TimeSpan.FromSeconds(20)))

                    return this.token;

            }


            if (this.httpxClient is null)

                throw new Exception("Not connected to XMPP network.");


            this.token = await this.httpxClient.GetJwtTokenAsync(Seconds);

            this.tokenCreated = Now;


            return this.token;

        }


        public async Task<object> PostToProtectedApi(string LocalResource, object Data, params KeyValuePair<string, string>[] Headers)

        {

            StringBuilder Url = new();


            if (this.IsOnline)

                Url.Append("httpx://");

            else if (!string.IsNullOrEmpty(this.token))     // Token needs to be retrieved regularly when connected, if protected APIs are to be used when disconnected or during connection.

            {

                Url.Append("https://");


                KeyValuePair<string, string> Authorization = new("Authorization", "Bearer " + this.token);


                if (Headers is null)

                    Headers = [Authorization];

                else

                {

                    int c = Headers.Length;


                    Array.Resize(ref Headers, c + 1);

                    Headers[c] = Authorization;

                }

            }

            else

                throw new IOException("No connection and no token available for call to protect API.");


            Url.Append(ServiceRef.TagProfile.Domain);

            Url.Append(LocalResource);


            ContentResponse Response = await InternetContent.PostAsync(new Uri(Url.ToString()), Data, Headers);

            Response.AssertOk();


            return Response.Decoded;

        }


        #endregion


        #region HTTP File Upload


        private HttpFileUploadClient FileUploadClient

        {

            get

            {

                if (this.fileUploadClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.FileUploadServiceNotFound)]);


                return this.fileUploadClient;

            }

        }


        public bool FileUploadIsSupported

        {

            get

            {

                try

                {

                    return ServiceRef.TagProfile.FileUploadIsSupported &&

                        this.fileUploadClient is not null &&

                        this.fileUploadClient.HasSupport;

                }

                catch (Exception ex)

                {

                    ServiceRef.LogService.LogException(ex);

                    return false;

                }

            }

        }


        public Task<HttpFileUploadEventArgs> RequestUploadSlotAsync(string FileName, string ContentType, long ContentSize)

        {

            return this.FileUploadClient.RequestUploadSlotAsync(FileName, ContentType, ContentSize);

        }


        #endregion


        #region Personal Eventing Protocol (PEP)


        private readonly LinkedList<KeyValuePair<Type, EventHandlerAsync<PersonalEventNotificationEventArgs>>> pepHandlers = new();


        private PepClient PepClient

        {

            get

            {

                if (this.pepClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.PepServiceNotFound)]);


                return this.pepClient;

            }

        }


        public void RegisterPepHandler(Type PersonalEventType, EventHandlerAsync<PersonalEventNotificationEventArgs> Handler)

        {

            lock (this.pepHandlers)

            {

                this.pepHandlers.AddLast(new KeyValuePair<Type, EventHandlerAsync<PersonalEventNotificationEventArgs>>(PersonalEventType, Handler));

            }


            this.PepClient.RegisterHandler(PersonalEventType, Handler);

        }


        public bool UnregisterPepHandler(Type PersonalEventType, EventHandlerAsync<PersonalEventNotificationEventArgs> Handler)

        {

            lock (this.pepHandlers)

            {

                LinkedListNode<KeyValuePair<Type, EventHandlerAsync<PersonalEventNotificationEventArgs>>>? Node = this.pepHandlers.First;


                while (Node is not null)

                {

                    if (Node.Value.Key == PersonalEventType &&

                        (Node.Value.Value.Target?.Equals(Handler.Target) ?? Handler.Target is null) &&

                        Node.Value.Value.Method.Equals(Handler.Method))

                    {

                        this.pepHandlers.Remove(Node);

                        break;

                    }


                    Node = Node.Next;

                }

            }


            return this.PepClient.UnregisterHandler(PersonalEventType, Handler);

        }


        private void ReregisterPepEventHandlers(PepClient PepClient)

        {

            lock (this.pepHandlers)

            {

                foreach (KeyValuePair<Type, EventHandlerAsync<PersonalEventNotificationEventArgs>> P in this.pepHandlers)

                    PepClient.RegisterHandler(P.Key, P.Value);

            }

        }


        #endregion


        #region Thing Registries & Discovery


        private ThingRegistryClient ThingRegistryClient

        {

            get

            {

                if (this.thingRegistryClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.ThingRegistryServiceNotFound)]);


                return this.thingRegistryClient;

            }

        }


        public string RegistryServiceJid => this.ThingRegistryClient.ThingRegistryAddress;


        public bool IsIoTDiscoClaimURI(string DiscoUri)

        {

            return ThingRegistryClient.IsIoTDiscoClaimURI(DiscoUri);

        }


        public bool IsIoTDiscoSearchURI(string DiscoUri)

        {

            return ThingRegistryClient.IsIoTDiscoSearchURI(DiscoUri);

        }


        public bool IsIoTDiscoDirectURI(string DiscoUri)

        {

            return ThingRegistryClient.IsIoTDiscoDirectURI(DiscoUri);

        }


        public bool TryDecodeIoTDiscoClaimURI(string DiscoUri, [NotNullWhen(true)] out MetaDataTag[]? Tags)

        {

            return ThingRegistryClient.TryDecodeIoTDiscoClaimURI(DiscoUri, out Tags);

        }


        public bool TryDecodeIoTDiscoSearchURI(string DiscoUri, [NotNullWhen(true)] out SearchOperator[]? Operators,

            out string? RegistryJid)

        {

            RegistryJid = null;

            Operators = null;

            if (!ThingRegistryClient.TryDecodeIoTDiscoURI(DiscoUri, out IEnumerable<SearchOperator> Operators2))

                return false;


            List<SearchOperator> List = [];


            foreach (SearchOperator Operator in Operators2)

            {

                if (Operator.Name.Equals("R", StringComparison.OrdinalIgnoreCase))

                {

                    if (!string.IsNullOrEmpty(RegistryJid))

                        return false;


                    if (Operator is not StringTagEqualTo StrEqOp)

                        return false;


                    RegistryJid = StrEqOp.Value;

                }

                else

                    List.Add(Operator);

            }


            Operators = [.. List];


            return true;

        }


        public bool TryDecodeIoTDiscoDirectURI(string DiscoUri, [NotNullWhen(true)] out string? Jid, out string? SourceId, out string? NodeId,

            out string? PartitionId, [NotNullWhen(true)] out MetaDataTag[]? Tags)

        {

            Jid = null;

            SourceId = null;

            NodeId = null;

            PartitionId = null;


            if (!ThingRegistryClient.TryDecodeIoTDiscoURI(DiscoUri, out IEnumerable<SearchOperator> Operators2))

            {

                Tags = null;

                return false;

            }


            List<MetaDataTag> TagsFound = [];


            foreach (SearchOperator Operator in Operators2)

            {

                if (Operator is StringTagEqualTo S)

                {

                    switch (S.Name.ToUpper(CultureInfo.InvariantCulture))

                    {

                        case Constants.XmppProperties.Jid:

                            Jid = S.Value;

                            break;


                        case Constants.XmppProperties.SourceId:

                            SourceId = S.Value;

                            break;


                        case Constants.XmppProperties.NodeId:

                            NodeId = S.Value;

                            break;


                        case Constants.XmppProperties.Partition:

                            PartitionId = S.Value;

                            break;


                        default:

                            TagsFound.Add(new MetaDataStringTag(S.Name, S.Value));

                            break;

                    }

                }

                else if (Operator is NumericTagEqualTo N)

                    TagsFound.Add(new MetaDataNumericTag(N.Name, N.Value));

                else

                {

                    Tags = null;

                    return false;

                }

            }


            Tags = [.. TagsFound];


            return !string.IsNullOrEmpty(Jid);

        }


        public Task<NodeResultEventArgs> ClaimThing(string DiscoUri, bool MakePublic)

        {

            if (!this.TryDecodeIoTDiscoClaimURI(DiscoUri, out MetaDataTag[]? Tags))

                throw new ArgumentException(ServiceRef.Localizer[nameof(AppResources.InvalidIoTDiscoClaimUri)], nameof(DiscoUri));


            TaskCompletionSource<NodeResultEventArgs> Result = new();


            this.ThingRegistryClient.Mine(MakePublic, Tags, (sender, e) =>

            {

                Result.TrySetResult(e);

                return Task.CompletedTask;

            }, null);


            return Result.Task;

        }


        public Task<bool> Disown(string RegistryJid, string ThingJid, string SourceId, string Partition, string NodeId)

        {

            TaskCompletionSource<bool> Result = new();


            this.ThingRegistryClient.Disown(RegistryJid, ThingJid, NodeId, SourceId, Partition, (sender, e) =>

            {

                Result.TrySetResult(e.Ok);

                return Task.CompletedTask;

            }, null);


            return Result.Task;

        }


        public async Task<(SearchResultThing[], string?, bool)> Search(int Offset, int MaxCount, string DiscoUri)

        {

            if (!this.TryDecodeIoTDiscoSearchURI(DiscoUri, out SearchOperator[]? Operators, out string? RegistryJid))

                return (Array.Empty<SearchResultThing>(), RegistryJid, false);


            (SearchResultThing[] Things, bool More) = await this.Search(Offset, MaxCount, RegistryJid, Operators);


            return (Things, RegistryJid, More);

        }


        public Task<(SearchResultThing[], bool)> Search(int Offset, int MaxCount, string? RegistryJid, params SearchOperator[] Operators)

        {

            TaskCompletionSource<(SearchResultThing[], bool)> Result = new();


            this.ThingRegistryClient.Search(RegistryJid ?? ServiceRef.TagProfile.RegistryJid, Offset, MaxCount, Operators, (sender, e) =>

            {

                if (e.Ok)

                    Result.TrySetResult((e.Things, e.More));

                else

                    Result.TrySetException(e.StanzaError ?? new Exception("Unable to perform search."));


                return Task.CompletedTask;

            }, null);


            return Result.Task;

        }


        public async Task<(SearchResultThing[], string?)> SearchAll(string DiscoUri)

        {

            if (!this.TryDecodeIoTDiscoSearchURI(DiscoUri, out SearchOperator[]? Operators, out string? RegistryJid))

                return (Array.Empty<SearchResultThing>(), RegistryJid);


            SearchResultThing[] Things = await this.SearchAll(RegistryJid ?? ServiceRef.TagProfile.RegistryJid, Operators);


            return (Things, RegistryJid);

        }


        public async Task<SearchResultThing[]> SearchAll(string? RegistryJid, params SearchOperator[] Operators)

        {

            (SearchResultThing[] Things, bool More) = await this.Search(0, Constants.BatchSizes.DeviceBatchSize, RegistryJid, Operators);

            if (!More)

                return Things;


            List<SearchResultThing> Result = [];

            int Offset = Things.Length;


            Result.AddRange(Things);


            while (More)

            {

                (Things, More) = await this.Search(Offset, Constants.BatchSizes.DeviceBatchSize, RegistryJid, Operators);

                Result.AddRange(Things);

                Offset += Things.Length;

            }


            return [.. Result];

        }


        #endregion


        #region Legal Identities


        public async Task GenerateNewKeys()

        {

            await this.ContractsClient.GenerateNewKeys();


            if (this.ContractsClient.Client.State == XmppState.Connected)

                await this.ContractsClient.Client.SetPresenceAsync(Availability.Online);

        }


        public async Task<IdApplicationAttributesEventArgs> GetIdApplicationAttributes()

        {

            return await this.ContractsClient.GetIdApplicationAttributesAsync();

        }


        public async Task<LegalIdentity> AddLegalIdentity(RegisterIdentityModel Model, bool GenerateNewKeys,

            params LegalIdentityAttachment[] Attachments)

        {

            return await this.AddLegalIdentity(Model.ToProperties(ServiceRef.XmppService), GenerateNewKeys, Attachments);

        }


        public async Task<LegalIdentity> AddLegalIdentity(Property[] Props, bool GenerateNewKeys,

            params LegalIdentityAttachment[] Attachments)

        {

            if (GenerateNewKeys)

                await this.GenerateNewKeys();


            LegalIdentity Identity = await this.ContractsClient.ApplyAsync(Props);


            foreach (LegalIdentityAttachment Attachment in Attachments)

            {

                Identity = await this.ContractsClient.UploadLegalIdAttachmentAsync(Identity.Id,

                    Path.GetFileName(Attachment.FileName), Attachment.Data, Attachment.ContentType);

            }


            await this.ContractsClient.ReadyForApprovalAsync(Identity.Id);


            return Identity;

        }


        public async Task<LegalIdentity[]> GetLegalIdentities(XmppClient? client = null)

        {

            if (client is null)

                return await this.ContractsClient.GetLegalIdentitiesAsync();

            else

            {

                using ContractsClient cc = new(client, ServiceRef.TagProfile.LegalJid);  // No need to load keys for this operation.

                return await cc.GetLegalIdentitiesAsync();

            }

        }


        public async Task<LegalIdentity> GetLegalIdentity(CaseInsensitiveString legalIdentityId)

        {

            ContactInfo? Info = await ContactInfo.FindByLegalId(legalIdentityId);


            if (Info is not null && Info.LegalIdentity is not null)

                return Info.LegalIdentity;


            return await this.ContractsClient.GetLegalIdentityAsync(legalIdentityId);

        }


        public async Task<bool> IsContact(CaseInsensitiveString legalIdentityId)

        {

            ContactInfo? Info = await ContactInfo.FindByLegalId(legalIdentityId);

            return (Info is not null && Info.LegalIdentity is not null);

        }


        public Task<bool> HasPrivateKey(CaseInsensitiveString LegalIdentityId)

        {

            return this.ContractsClient.HasPrivateKey(LegalIdentityId);

        }


        public Task<LegalIdentity> ObsoleteLegalIdentity(CaseInsensitiveString legalIdentityId)

        {

            return this.ContractsClient.ObsoleteLegalIdentityAsync(legalIdentityId);

        }


        public Task<LegalIdentity> CompromiseLegalIdentity(CaseInsensitiveString legalIdentityId)

        {

            return this.ContractsClient.CompromisedLegalIdentityAsync(legalIdentityId);

        }


        public async Task PetitionIdentity(CaseInsensitiveString LegalId, string PetitionId, string Purpose)

        {

            if (ServiceRef.TagProfile.LegalIdentity is null)

                throw new Exception("No Legal Identity registered.");


            await this.ContractsClient.AuthorizeAccessToIdAsync(ServiceRef.TagProfile.LegalIdentity.Id, LegalId, true);


            this.StartPetition(PetitionId);

            await this.ContractsClient.PetitionIdentityAsync(LegalId, PetitionId, Purpose);

        }


        private void StartPetition(string PetitionId)

        {

            lock (this.currentPetitions)

            {

                this.currentPetitions[PetitionId] = true;

            }

        }


        private bool EndPetition(string PetitionId)

        {

            lock (this.currentPetitions)

            {

                return this.currentPetitions.Remove(PetitionId);

            }

        }


        public Task SendPetitionIdentityResponse(CaseInsensitiveString LegalId, string PetitionId, string RequestorFullJid, bool Response)

        {

            return this.ContractsClient.PetitionIdentityResponseAsync(LegalId, PetitionId, RequestorFullJid, Response);

        }


        public event EventHandlerAsync<LegalIdentityEventArgs>? LegalIdentityChanged;


        public event EventHandlerAsync<LegalIdentityEventArgs>? IdentityApplicationChanged;


        private async Task ContractsClient_IdentityUpdated(object? Sender, LegalIdentityEventArgs e)

        {

            try

            {

                KycReference? Ref = await Database.FindFirstIgnoreRest<KycReference>(new FilterFieldEqualTo(nameof(KycReference.CreatedIdentityId), e.Identity.Id));

                if (Ref is not null)

                {

                    Ref.UpdatedUtc = DateTime.UtcNow;

                    Ref.CreatedIdentityState = e.Identity.State;

                    await Database.Update(Ref);

                    await Database.Provider.Flush();

                }


                if (ServiceRef.NavigationService.CurrentPage is ApplicationsPage AppPage)

                {

                    if (AppPage.BindingContext is ApplicationsViewModel Model)

                        Model.Loader.Reload();

                }

            }

            catch (Exception Ex)

            {

                ServiceRef.LogService.LogException(Ex);

            }


            try

            {

                if (ServiceRef.TagProfile.LegalIdentity is not null && ServiceRef.TagProfile.LegalIdentity.Id == e.Identity.Id)

                {

                    if (ServiceRef.TagProfile.LegalIdentity.Created > e.Identity.Created)

                        return;


                    await ServiceRef.TagProfile.SetLegalIdentity(e.Identity, true);

                    await this.LegalIdentityChanged.Raise(this, e);


                    if (e.Identity.IsDiscarded() && !e.Identity.IsPersonal() && !e.Identity.IsOrganizational() && Shell.Current.CurrentState.Location.OriginalString != Constants.Pages.RegistrationPage)

                    {

                        MainThread.BeginInvokeOnMainThread(async () =>

                        {

                            try

                            {

                                await ServiceRef.TagProfile.ClearLegalIdentity();

                                ServiceRef.TagProfile.GoToStep(RegistrationStep.ValidatePhone, true);

                                await Shell.Current.GoToAsync(Constants.Pages.RegistrationPage);

                            }

                            catch (Exception ex)

                            {

                                ServiceRef.LogService.LogException(ex);

                                await App.StopAsync();

                            }

                        });

                    }

                }

                else if (ServiceRef.TagProfile.IdentityApplication is not null && ServiceRef.TagProfile.IdentityApplication.Id == e.Identity.Id)

                {

                    if (ServiceRef.TagProfile.IdentityApplication.Created > e.Identity.Created)

                        return;


                    if (e.Identity.IsDiscarded())

                    {

                        await ServiceRef.TagProfile.SetIdentityApplication(null, false);

                        await this.IdentityApplicationChanged.Raise(this, e);

                    }

                    else if (e.Identity.IsApproved())

                    {

                        LegalIdentity? ToObsolete = ServiceRef.TagProfile.LegalIdentity;


                        if (ToObsolete is not null)

                        {

                            INotificationServiceV2 NotificationService = ServiceRef.Provider.GetRequiredService<INotificationServiceV2>();

                            NotificationService.AddIgnoreFilter((NotificationIntent Intent) =>

                            {

                                if (!string.Equals(Intent.Channel, NeuroAccessMaui.Constants.PushChannels.Identities, StringComparison.OrdinalIgnoreCase))

                                    return NotificationFilterDecision.None;


                                if (!string.Equals(Intent.EntityId, ToObsolete.Id, StringComparison.OrdinalIgnoreCase))

                                    return NotificationFilterDecision.None;


                                return new NotificationFilterDecision(true, true, true);

                            });

                        }


                        await ServiceRef.TagProfile.SetLegalIdentity(e.Identity, true);

                        await ServiceRef.TagProfile.SetIdentityApplication(null, false);


                        await this.LegalIdentityChanged.Raise(this, e);

                        await this.IdentityApplicationChanged.Raise(this, e);


                        if (ToObsolete is not null && !ToObsolete.IsDiscarded())

                            await this.ObsoleteLegalIdentity(ToObsolete.Id);

                    }

                    else

                    {

                        await ServiceRef.TagProfile.SetIdentityApplication(e.Identity, false);

                        await this.IdentityApplicationChanged.Raise(this, e);

                    }

                }

                else if (ServiceRef.TagProfile.LegalIdentity is null)

                {

                    if (e.Identity.IsDiscarded())

                        return;


                    await ServiceRef.TagProfile.SetLegalIdentity(e.Identity, true);

                    await this.LegalIdentityChanged.Raise(this, e);

                }

            }

            catch (Exception ex)

            {

                ServiceRef.LogService.LogException(ex);

                await ServiceRef.UiService.DisplayException(ex);

            }


            try

            {

                string Title;

                string Body;


                switch (e.Identity.State)

                {

                    case IdentityState.Approved:

                        Title = ServiceRef.Localizer[nameof(AppResources.NotificationIdentityApprovedTitle)];

                        Body = ServiceRef.Localizer[nameof(AppResources.NotificationIdentityApprovedBody)];

                        break;

                    case IdentityState.Obsoleted:

                        Title = ServiceRef.Localizer[nameof(AppResources.NotificationIdentityObsoletedTitle)];

                        Body = ServiceRef.Localizer[nameof(AppResources.NotificationIdentityObsoletedBody)];

                        break;

                    case IdentityState.Rejected:

                        Title = ServiceRef.Localizer[nameof(AppResources.NotificationIdentityRejectedTitle)];

                        Body = ServiceRef.Localizer[nameof(AppResources.NotificationIdentityRejectedBody)];

                        break;

                    case IdentityState.Compromised:

                        Title = ServiceRef.Localizer[nameof(AppResources.NotificationIdentityCompromisedTitle)];

                        Body = ServiceRef.Localizer[nameof(AppResources.NotificationIdentityCompromisedBody)];

                        break;

                    default:

                        return;

                }


                NotificationIntent Intent = new()

                {

                    Channel = Constants.PushChannels.Identities,

                    Title = Title,

                    Body = Body,

                    Action = NotificationAction.OpenIdentity,

                    EntityId = e.Identity.Id,

                    CorrelationId = e.Identity.Id,

                    Presentation = NotificationPresentation.StoreOnly

                };


                Intent.Extras["state"] = e.Identity.State.ToString();


                await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            }

            catch (Exception ex)

            {

                ServiceRef.LogService.LogException(ex);

            }

        }


        public event EventHandlerAsync<LegalIdentityPetitionEventArgs>? PetitionForIdentityReceived;


        private async Task ContractsClient_PetitionForIdentityReceived(object? Sender, LegalIdentityPetitionEventArgs e)

        {

            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionIdentityTitle), ToBareJid(e.RequestorFullJid)];

            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionIdentityBody)];


            NotificationIntent Intent = new()

            {

                Channel = Constants.PushChannels.Petitions,

                Title = Title,

                Body = Body,

                Action = NotificationAction.OpenPetition,

                EntityId = e.RequestorFullJid,

                CorrelationId = e.PetitionId,

                Presentation = NotificationPresentation.StoreOnly

            };


            Intent.Extras["petitionId"] = e.PetitionId ?? string.Empty;

            Intent.Extras["requestedIdentityId"] = e.RequestedIdentityId ?? string.Empty;

            Intent.Extras["requestorIdentityId"] = e.RequestorIdentity?.Id ?? string.Empty;


            await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            await this.PetitionForIdentityReceived.Raise(this, e);

        }


        public event EventHandlerAsync<LegalIdentityPetitionResponseEventArgs>? PetitionedIdentityResponseReceived;


        private async Task ContractsClient_PetitionedIdentityResponseReceived(object? Sender, LegalIdentityPetitionResponseEventArgs e)

        {

            try

            {

                this.EndPetition(e.PetitionId);

                await this.PetitionedIdentityResponseReceived.Raise(this, e);

            }

            catch (Exception ex)

            {

                ServiceRef.LogService.LogException(ex);

                await ServiceRef.UiService.DisplayException(ex);

            }

        }


        public Task ExportSigningKeys(XmlWriter Output)

        {

            return this.ContractsClient.ExportKeys(Output);

        }


        public Task<bool> ImportSigningKeys(XmlElement Xml)

        {

            return this.ContractsClient.ImportKeys(Xml);

        }


        public async Task<IdentityStatus> ValidateIdentity(LegalIdentity Identity)

        {

            IdentityValidationEventArgs Result = await this.ContractsClient.ValidateAsync(Identity, true);

            return Result.Status;

        }


        #endregion


        #region Smart Contracts


        private readonly Dictionary<CaseInsensitiveString, DateTime> lastContractEvent = [];


        public ContractsClient ContractsClient

        {

            get

            {

                if (this.contractsClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.LegalServiceNotFound)]);


                return this.contractsClient;

            }

        }


        private void RegisterContractsEventHandlers()

        {

            this.ContractsClient.EnableE2eEncryption();


            this.ContractsClient.IdentityUpdated += this.ContractsClient_IdentityUpdated;

            this.ContractsClient.PetitionForIdentityReceived += this.ContractsClient_PetitionForIdentityReceived;

            this.ContractsClient.PetitionedIdentityResponseReceived += this.ContractsClient_PetitionedIdentityResponseReceived;

            this.ContractsClient.PetitionForContractReceived += this.ContractsClient_PetitionForContractReceived;

            this.ContractsClient.PetitionedContractResponseReceived += this.ContractsClient_PetitionedContractResponseReceived;

            this.ContractsClient.PetitionForSignatureReceived += this.ContractsClient_PetitionForSignatureReceived;

            this.ContractsClient.PetitionedSignatureResponseReceived += this.ContractsClient_PetitionedSignatureResponseReceived;

            this.ContractsClient.PetitionForPeerReviewIDReceived += this.ContractsClient_PetitionForPeerReviewIdReceived;

            this.ContractsClient.PetitionedPeerReviewIDResponseReceived += this.ContractsClient_PetitionedPeerReviewIdResponseReceived;

            this.ContractsClient.PetitionClientUrlReceived += this.ContractsClient_PetitionClientUrlReceived;

            this.ContractsClient.ContractProposalReceived += this.ContractsClient_ContractProposalReceived;

            this.ContractsClient.ContractUpdated += this.ContractsClient_ContractUpdated;

            this.ContractsClient.ContractSigned += this.ContractsClient_ContractSigned;

            this.ContractsClient.ClientMessage += this.ContractsClient_ClientMessage;

        }


        public Task<Contract> GetContract(CaseInsensitiveString ContractId)

        {

            return this.ContractsClient.GetContractAsync(ContractId);

        }


        public async Task<string[]> GetCreatedContractReferences()

        {

            List<string> Result = [];

            string[] ContractIds;

            int Offset = 0;

            int Nr;


            do

            {

                ContractIds = await this.ContractsClient.GetCreatedContractReferencesAsync(Offset, 20);

                Result.AddRange(ContractIds);

                Nr = ContractIds.Length;

                Offset += Nr;

            }

            while (Nr == 20);


            return [.. Result];

        }


        public async Task<string[]> GetSignedContractReferences()

        {

            List<string> Result = [];

            string[] ContractIds;

            int Offset = 0;

            int Nr;


            do

            {

                ContractIds = await this.ContractsClient.GetSignedContractReferencesAsync(Offset, 20);

                Result.AddRange(ContractIds);

                Nr = ContractIds.Length;

                Offset += Nr;

            }

            while (Nr == 20);


            return [.. Result];

        }


        public async Task<Contract> SignContract(Contract Contract, string Role, bool Transferable)

        {

            if (Contract.ForMachinesNamespace == Constants.ContractMachineNames.PaymentInstructionsNamespace && (

                Contract.ForMachinesLocalName == Constants.ContractMachineNames.BuyEDaler ||

                Contract.ForMachinesLocalName == Constants.ContractMachineNames.SellEDaler))

            {

                lock (this.currentTransactions)

                {

                    string TransactionId = Contract.ContractId;

                    string Currency = Contract["Currency"]?.ToString() ?? string.Empty;


                    this.currentTransactions[Contract.ContractId] = new PaymentTransaction(TransactionId, Currency);

                }

            }


            Contract Result = await this.ContractsClient.SignContractAsync(Contract, Role, Transferable);

            await UpdateContractReference(Result);

            return Result;

        }


        public async Task<Contract> ObsoleteContract(CaseInsensitiveString ContractId)

        {

            Contract Result = await this.ContractsClient.ObsoleteContractAsync(ContractId);

            await UpdateContractReference(Result);

            return Result;

        }


        public async Task<Contract> CreateContract(

            CaseInsensitiveString TemplateId,

            Part[] Parts,

            Parameter[] Parameters,

            ContractVisibility Visibility,

            ContractParts PartsMode,

            Duration Duration,

            Duration ArchiveRequired,

            Duration ArchiveOptional,

            DateTime? SignAfter,

            DateTime? SignBefore,

            bool CanActAsTemplate)

        {

            Contract Result = await this.ContractsClient.CreateContractAsync(TemplateId, Parts, Parameters, Visibility, PartsMode, Duration, ArchiveRequired, ArchiveOptional, SignAfter, SignBefore, CanActAsTemplate);

            await UpdateContractReference(Result);

            return Result;

        }


        public async Task<Contract> DeleteContract(CaseInsensitiveString ContractId)

        {

            Contract Contract = await this.ContractsClient.DeleteContractAsync(ContractId);

            await Database.FindDelete<ContractReference>(new FilterFieldEqualTo("ContractId", Contract.ContractId));

            return Contract;

        }


        public Task PetitionContract(CaseInsensitiveString ContractId, string PetitionId, string Purpose)

        {

            this.StartPetition(PetitionId);

            return this.ContractsClient.PetitionContractAsync(ContractId, PetitionId, Purpose);

        }


        public Task SendPetitionContractResponse(CaseInsensitiveString ContractId, string PetitionId, string RequestorFullJid, bool Response)

        {

            return this.ContractsClient.PetitionContractResponseAsync(ContractId, PetitionId, RequestorFullJid, Response);

        }


        public event EventHandlerAsync<ContractPetitionEventArgs>? PetitionForContractReceived;


        private async Task ContractsClient_PetitionForContractReceived(object? Sender, ContractPetitionEventArgs e)

        {

            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionContractTitle), ToBareJid(e.RequestorFullJid)];

            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionContractBody)];


            NotificationIntent Intent = new()

            {

                Channel = Constants.PushChannels.Petitions,

                Title = Title,

                Body = Body,

                Action = NotificationAction.OpenPetition,

                EntityId = e.RequestorFullJid,

                CorrelationId = e.PetitionId,

                Presentation = NotificationPresentation.StoreOnly

            };


            Intent.Extras["contractId"] = e.RequestedContractId ?? string.Empty;

            Intent.Extras["petitionId"] = e.PetitionId ?? string.Empty;


            await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            await this.PetitionForContractReceived.Raise(this, e);

        }


        public event EventHandlerAsync<ContractPetitionResponseEventArgs>? PetitionedContractResponseReceived;


        private async Task ContractsClient_PetitionedContractResponseReceived(object? Sender, ContractPetitionResponseEventArgs e)

        {

            try

            {

                this.EndPetition(e.PetitionId);

                await this.PetitionedContractResponseReceived.Raise(this, e);

            }

            catch (Exception ex)

            {

                ServiceRef.LogService.LogException(ex);

                await ServiceRef.UiService.DisplayException(ex);

            }

        }


        public DateTime GetTimeOfLastContractEvent(CaseInsensitiveString ContractId)

        {

            lock (this.lastContractEvent)

            {

                if (this.lastContractEvent.TryGetValue(ContractId, out DateTime TP))

                    return TP;

                else

                    return DateTime.MinValue;

            }

        }


        private static async Task UpdateContractReference(Contract Contract)

        {

            ContractReference Ref = await Database.FindFirstDeleteRest<ContractReference>(

                new FilterFieldEqualTo("ContractId", Contract.ContractId));


            if (Ref is null)

            {

                Ref = new ContractReference()

                {

                    ContractId = Contract.ContractId

                };


                await Ref.SetContract(Contract);

                await Database.Insert(Ref);

            }

            else

            {

                await Ref.SetContract(Contract);

                await Database.Update(Ref);

            }


            ServiceRef.TagProfile.CheckContractReference(Ref);

        }


        public event EventHandlerAsync<ContractProposalEventArgs>? ContractProposalReceived;


        private async Task ContractsClient_ContractProposalReceived(object? Sender, ContractProposalEventArgs e)

        {

            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationContractProposalTitle)];

            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationContractProposalBody)];


            NotificationIntent Intent = new()

            {

                Channel = Constants.PushChannels.Contracts,

                Title = Title,

                Body = Body,

                Action = NotificationAction.OpenContract,

                EntityId = e.ContractId,

                CorrelationId = e.ContractId,

                Presentation = NotificationPresentation.StoreOnly

            };


            Intent.Extras["role"] = e.Role ?? string.Empty;

            Intent.Extras["fromJid"] = e.FromBareJID ?? string.Empty;


            await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            await this.ContractProposalReceived.Raise(this, e);

        }


        public event EventHandlerAsync<ContractReferenceEventArgs>? ContractUpdated;


        private async Task ContractsClient_ContractUpdated(object? Sender, ContractReferenceEventArgs e)

        {

            await this.ContractUpdatedOrSigned(e);


            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationContractUpdatedTitle)];

            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationContractUpdatedBody)];


            NotificationIntent Intent = new()

            {

                Channel = Constants.PushChannels.Contracts,

                Title = Title,

                Body = Body,

                Action = NotificationAction.OpenContract,

                EntityId = e.ContractId,

                CorrelationId = e.ContractId,

                Presentation = NotificationPresentation.StoreOnly

            };


            await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            await this.ContractUpdated.Raise(this, e);

        }


        private Task ContractUpdatedOrSigned(ContractReferenceEventArgs e)

        {

            lock (this.lastContractEvent)

            {

                this.lastContractEvent[e.ContractId] = DateTime.Now;

            }


            return Task.CompletedTask;

        }


        public event EventHandlerAsync<ContractSignedEventArgs>? ContractSigned;


        private async Task ContractsClient_ContractSigned(object? Sender, ContractSignedEventArgs e)

        {

            await this.ContractUpdatedOrSigned(e);


            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationContractSignedTitle)];

            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationContractSignedBody)];


            NotificationIntent Intent = new()

            {

                Channel = Constants.PushChannels.Contracts,

                Title = Title,

                Body = Body,

                Action = NotificationAction.OpenContract,

                EntityId = e.ContractId,

                CorrelationId = e.ContractId,

                Presentation = NotificationPresentation.StoreOnly

            };


            await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            await this.ContractSigned.Raise(this, e);

        }


        public Task SendContractProposal(Contract Contract, string Role, string To, string Message)

        {

            return this.ContractsClient.SendContractProposal(Contract, Role, To, Message);

        }


        #endregion


        #region Attachments


        public Task<KeyValuePair<string, TemporaryFile>> GetAttachment(string Url, SignWith SignWith, TimeSpan Timeout)

        {

            return this.ContractsClient.GetAttachmentAsync(Url, SignWith, (int)Timeout.TotalMilliseconds);

        }


        #endregion


        #region Peer Review


        public async Task PetitionPeerReviewId(CaseInsensitiveString LegalId, LegalIdentity Identity, string PetitionId, string Purpose)

        {

            await this.ContractsClient.AuthorizeAccessToIdAsync(Identity.Id, LegalId, true);


            this.StartPetition(PetitionId);

            await this.ContractsClient.PetitionPeerReviewIDAsync(LegalId, Identity, PetitionId, Purpose);

        }


        public Task<LegalIdentity> AddPeerReviewIdAttachment(LegalIdentity Identity, LegalIdentity ReviewerLegalIdentity, byte[] PeerSignature)

        {

            return this.ContractsClient.AddPeerReviewIDAttachment(Identity, ReviewerLegalIdentity, PeerSignature);

        }


        public event EventHandlerAsync<SignaturePetitionEventArgs>? PetitionForPeerReviewIdReceived;


        private async Task ContractsClient_PetitionForPeerReviewIdReceived(object? Sender, SignaturePetitionEventArgs e)

        {

            await this.PetitionForPeerReviewIdReceived.Raise(this, e);

        }


        public event EventHandlerAsync<SignaturePetitionResponseEventArgs>? PetitionedPeerReviewIdResponseReceived;


        private async Task ContractsClient_PetitionedPeerReviewIdResponseReceived(object? Sender, SignaturePetitionResponseEventArgs e)

        {

            try

            {

                this.EndPetition(e.PetitionId);

                await this.PetitionedPeerReviewIdResponseReceived.Raise(this, e);

            }

            catch (Exception ex)

            {

                ServiceRef.LogService.LogException(ex);

                await ServiceRef.UiService.DisplayException(ex);

            }

        }


        public async Task<ServiceProviderWithLegalId[]> GetServiceProvidersForPeerReviewAsync()

        {

            try

            {

                return await this.ContractsClient.GetPeerReviewIdServiceProvidersAsync();

            }

            catch (Exception Ex)

            {

                ServiceRef.LogService.LogException(Ex);

            }


            return [];

        }


        public async Task SelectPeerReviewService(string ServiceId, string ServiceProvider)

        {

            await this.ContractsClient.SelectPeerReviewServiceAsync(ServiceProvider, ServiceId);

        }


        private readonly Dictionary<string, bool> currentPetitions = [];


        private async Task ContractsClient_PetitionClientUrlReceived(object? Sender, PetitionClientUrlEventArgs e)

        {

            lock (this.currentPetitions)

            {

                if (!this.currentPetitions.ContainsKey(e.PetitionId))

                {

                    ServiceRef.LogService.LogWarning("Client URL message for a petition is ignored. Petition ID not recognized.",

                        new KeyValuePair<string, object?>("PetitionId", e.PetitionId),

                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));

                    return;

                }

            }


            await App.OpenUrlAsync(e.ClientUrl);

        }


        #endregion


        #region Signatures


        public Task<byte[]> Sign(byte[] data, SignWith signWith)

        {

            return this.ContractsClient.SignAsync(data, signWith);

        }


        public bool? ValidateSignature(LegalIdentity legalIdentity, byte[] data, byte[] signature)

        {

            return this.ContractsClient.ValidateSignature(legalIdentity, data, signature);

        }


        public Task SendPetitionSignatureResponse(CaseInsensitiveString LegalId, byte[] Content, byte[] Signature, string PetitionId, string RequestorFullJid, bool Response)

        {

            return this.ContractsClient.PetitionSignatureResponseAsync(LegalId, Content, Signature, PetitionId, RequestorFullJid, Response);

        }


        public event EventHandlerAsync<SignaturePetitionEventArgs>? PetitionForSignatureReceived;


        private async Task ContractsClient_PetitionForSignatureReceived(object? Sender, SignaturePetitionEventArgs e)

        {

            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionSignatureTitle), ToBareJid(e.RequestorFullJid)];

            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationPetitionSignatureBody)];


            NotificationIntent Intent = new()

            {

                Channel = Constants.PushChannels.Petitions,

                Title = Title,

                Body = Body,

                Action = NotificationAction.OpenPetition,

                EntityId = e.RequestorFullJid,

                CorrelationId = e.PetitionId,

                Presentation = NotificationPresentation.StoreOnly

            };


            byte[] ContentToSign = e.ContentToSign ?? [];

            string ContentToSignBase64 = Convert.ToBase64String(ContentToSign);

            string Purpose = e.Purpose ?? string.Empty;

            string RequestorIdentityId = e.RequestorIdentity?.Id ?? string.Empty;


            Intent.Extras["signatoryId"] = e.SignatoryIdentityId ?? string.Empty;

            Intent.Extras["petitionId"] = e.PetitionId ?? string.Empty;

            Intent.Extras["requestorIdentityId"] = RequestorIdentityId;

            Intent.Extras["purpose"] = Purpose;

            Intent.Extras["contentToSign"] = ContentToSignBase64;


            await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            await this.PetitionForSignatureReceived.Raise(this, e);

        }


        public event EventHandlerAsync<SignaturePetitionResponseEventArgs>? SignaturePetitionResponseReceived;


        private async Task ContractsClient_PetitionedSignatureResponseReceived(object? Sender, SignaturePetitionResponseEventArgs e)

        {

            try

            {

                this.EndPetition(e.PetitionId);

                await this.SignaturePetitionResponseReceived.Raise(this, e);

            }

            catch (Exception ex)

            {

                ServiceRef.LogService.LogException(ex);

                await ServiceRef.UiService.DisplayException(ex);

            }

        }


        #endregion


        #region Provisioning


        private ProvisioningClient ProvisioningClient

        {

            get

            {

                if (this.provisioningClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.ProvisioningServiceNotFound)]);


                return this.provisioningClient;

            }

        }


        private async Task ProvisioningClient_IsFriendQuestion(object? Sender, IsFriendEventArgs e)

        {

            if (e.From.IndexOfAny(clientChars) < 0)

            {

                string Title = ServiceRef.Localizer[nameof(AppResources.NotificationPresenceAccessTitle), e.From];

                string Body = ServiceRef.Localizer[nameof(AppResources.NotificationPresenceAccessBody)];


                NotificationIntent Intent = new()

                {

                    Channel = Constants.PushChannels.Provisioning,

                    Title = Title,

                    Body = Body,

                    Action = NotificationAction.OpenPresenceRequest,

                    EntityId = e.From,

                    CorrelationId = e.Key

                };


                await ServiceRef.Provider.GetRequiredService<INotificationServiceV2>().AddAsync(Intent, NotificationSource.Xmpp, null, CancellationToken.None);

            }

        }


        private async Task ProvisioningClient_CanReadQuestion(object? Sender, CanReadEventArgs e)

        {

            if (e.From.IndexOfAny(clientChars) < 0)

            {

                string Title = ServiceRef.Localizer[nameof(AppResources.NotificationReadAccessTitle), e.From];

                string Body = ServiceRef.Localizer[nameof(AppResources.NotificationReadAccessBody)];


                NotificationIntent Intent = new()

                {

                    Channel = Constants.PushChannels.Provisioning,

                    Title = Title,

                    Body = Body,

                    Action = NotificationAction.OpenPresenceRequest,

                    EntityId = e.From,

                    CorrelationId = e.Key

                };


                await ServiceRef.Provider.GetRequiredService<INotificationServiceV2>().AddAsync(Intent, NotificationSource.Xmpp, null, CancellationToken.None);

            }

        }


        private async Task ProvisioningClient_CanControlQuestion(object? Sender, CanControlEventArgs e)

        {

            if (e.From.IndexOfAny(clientChars) < 0)

            {

                string Title = ServiceRef.Localizer[nameof(AppResources.NotificationControlAccessTitle), e.From];

                string Body = ServiceRef.Localizer[nameof(AppResources.NotificationControlAccessBody)];


                NotificationIntent Intent = new()

                {

                    Channel = Constants.PushChannels.Provisioning,

                    Title = Title,

                    Body = Body,

                    Action = NotificationAction.OpenPresenceRequest,

                    EntityId = e.From,

                    CorrelationId = e.Key

                };


                await ServiceRef.Provider.GetRequiredService<INotificationServiceV2>().AddAsync(Intent, NotificationSource.Xmpp, null, CancellationToken.None);

            }

        }


        private static readonly char[] clientChars = ['@', '/'];


        public string ProvisioningServiceJid => this.ProvisioningClient.ProvisioningServerAddress;


        public void IsFriendResponse(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool IsFriend,

            RuleRange Range, EventHandlerAsync<IqResultEventArgs> Callback, object? State)

        {

            this.ProvisioningClient.IsFriendResponse(ProvisioningServiceJID, JID, RemoteJID, Key, IsFriend, Range, Callback, State);

        }


        public void CanControlResponseAll(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool CanControl,

            string[]? ParameterNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State)

        {

            this.ProvisioningClient.CanControlResponseAll(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl, ParameterNames,

                Node, Callback, State);

        }


        public void CanControlResponseCaller(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanControl, string[]? ParameterNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State)

        {

            this.ProvisioningClient.CanControlResponseCaller(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,

                ParameterNames, Node, Callback, State);

        }


        public void CanControlResponseDomain(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanControl, string[]? ParameterNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State)

        {

            this.ProvisioningClient.CanControlResponseDomain(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,

                ParameterNames, Node, Callback, State);

        }


        public void CanControlResponseDevice(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanControl, string[]? ParameterNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,

            object? State)

        {

            this.ProvisioningClient.CanControlResponseDevice(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,

                ParameterNames, Token, Node, Callback, State);

        }


        public void CanControlResponseService(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanControl, string[]? ParameterNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,

            object? State)

        {

            this.ProvisioningClient.CanControlResponseService(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,

                ParameterNames, Token, Node, Callback, State);

        }


        public void CanControlResponseUser(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanControl, string[]? ParameterNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,

            object? State)

        {

            this.ProvisioningClient.CanControlResponseUser(ProvisioningServiceJID, JID, RemoteJID, Key, CanControl,

                ParameterNames, Token, Node, Callback, State);

        }


        public void CanReadResponseAll(string ProvisioningServiceJID, string JID, string RemoteJID, string Key, bool CanRead,

            FieldType FieldTypes, string[]? FieldNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State)

        {

            this.ProvisioningClient.CanReadResponseAll(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead, FieldTypes, FieldNames,

                Node, Callback, State);

        }


        public void CanReadResponseCaller(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanRead, FieldType FieldTypes, string[]? FieldNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State)

        {

            this.ProvisioningClient.CanReadResponseCaller(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,

                FieldTypes, FieldNames, Node, Callback, State);

        }


        public void CanReadResponseDomain(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanRead, FieldType FieldTypes, string[]? FieldNames, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback, object? State)

        {

            this.ProvisioningClient.CanReadResponseDomain(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,

                FieldTypes, FieldNames, Node, Callback, State);

        }


        public void CanReadResponseDevice(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanRead, FieldType FieldTypes, string[]? FieldNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,

            object? State)

        {

            this.ProvisioningClient.CanReadResponseDevice(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,

                FieldTypes, FieldNames, Token, Node, Callback, State);

        }


        public void CanReadResponseService(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanRead, FieldType FieldTypes, string[]? FieldNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,

            object? State)

        {

            this.ProvisioningClient.CanReadResponseService(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,

                FieldTypes, FieldNames, Token, Node, Callback, State);

        }


        public void CanReadResponseUser(string ProvisioningServiceJID, string JID, string RemoteJID, string Key,

            bool CanRead, FieldType FieldTypes, string[]? FieldNames, string Token, IThingReference Node, EventHandlerAsync<IqResultEventArgs> Callback,

            object? State)

        {

            this.ProvisioningClient.CanReadResponseUser(ProvisioningServiceJID, JID, RemoteJID, Key, CanRead,

                FieldTypes, FieldNames, Token, Node, Callback, State);

        }


        public void DeleteDeviceRules(string ServiceJID, string DeviceJID, string NodeId, string SourceId, string Partition,

            EventHandlerAsync<IqResultEventArgs> Callback, object? State)

        {

            this.ProvisioningClient.DeleteDeviceRules(ServiceJID, DeviceJID, NodeId, SourceId, Partition, Callback, State);

        }


        #endregion


        #region IoT


        private SensorClient SensorClient

        {

            get

            {

                if (this.sensorClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.SensorServiceNotFound)]);


                return this.sensorClient;

            }

        }


        private ControlClient ControlClient

        {

            get

            {

                if (this.controlClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.ControlServiceNotFound)]);


                return this.controlClient;

            }

        }


        private ConcentratorClient ConcentratorClient

        {

            get

            {

                if (this.concentratorClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.ConcentratorServiceNotFound)]);


                return this.concentratorClient;

            }

        }


        public Task<(SearchResultThing[], bool)> GetMyDevices(int Offset, int MaxCount)

        {

            TaskCompletionSource<(SearchResultThing[], bool)> Result = new();


            this.ProvisioningClient.GetDevices(Offset, MaxCount, (sender, e) =>

            {

                if (e.Ok)

                    Result.TrySetResult((e.Things, e.More));

                else

                    Result.TrySetException(e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetListOfMyDevices)]));


                return Task.CompletedTask;

            }, null);


            return Result.Task;

        }


        public async Task<SearchResultThing[]> GetAllMyDevices()

        {

            (SearchResultThing[] Things, bool More) = await this.GetMyDevices(0, Constants.BatchSizes.DeviceBatchSize);

            if (!More)

                return Things;


            List<SearchResultThing> Result = [];

            int Offset = Things.Length;


            Result.AddRange(Things);


            while (More)

            {

                (Things, More) = await this.GetMyDevices(Offset, Constants.BatchSizes.DeviceBatchSize);

                Result.AddRange(Things);

                Offset += Things.Length;

            }


            return [.. Result];

        }


        public void GetCertificate(string Token, EventHandlerAsync<CertificateEventArgs> Callback, object? State)

        {

            this.ProvisioningClient.GetCertificate(Token, Callback, State);

        }


        public void GetControlForm(string To, string Language, EventHandlerAsync<DataFormEventArgs> Callback, object? State,

            params ThingReference[] Nodes)

        {

            this.ControlClient.GetForm(To, Language, Callback, State, Nodes);

        }


        public Task<SensorDataClientRequest> RequestSensorReadout(string Destination, FieldType Types)

        {

            return this.SensorClient.RequestReadout(Destination, Types);

        }


        public Task<SensorDataClientRequest> RequestSensorReadout(string Destination, ThingReference[] Nodes, FieldType Types)

        {

            return this.SensorClient.RequestReadout(Destination, Nodes, Types);

        }


        #endregion


        #region e-Daler


        private readonly Dictionary<string, Wallet.Transaction> currentTransactions = [];

        private Balance? lastBalance = null;

        private DateTime lastEDalerEvent = DateTime.MinValue;


        private EDalerClient EDalerClient

        {

            get

            {

                if (this.eDalerClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.EDalerServiceNotFound)]);


                return this.eDalerClient;

            }

        }


        private void RegisterEDalerEventHandlers(EDalerClient Client)

        {

            Client.BalanceUpdated += this.EDalerClient_BalanceUpdated;

            Client.BuyEDalerOptionsClientUrlReceived += this.NeuroWallet_BuyEDalerOptionsClientUrlReceived;

            Client.BuyEDalerOptionsCompleted += this.NeuroWallet_BuyEDalerOptionsCompleted;

            Client.BuyEDalerOptionsError += this.NeuroWallet_BuyEDalerOptionsError;

            Client.BuyEDalerClientUrlReceived += this.NeuroWallet_BuyEDalerClientUrlReceived;

            Client.BuyEDalerCompleted += this.NeuroWallet_BuyEDalerCompleted;

            Client.BuyEDalerError += this.NeuroWallet_BuyEDalerError;

            Client.SellEDalerOptionsClientUrlReceived += this.NeuroWallet_SellEDalerOptionsClientUrlReceived;

            Client.SellEDalerOptionsCompleted += this.NeuroWallet_SellEDalerOptionsCompleted;

            Client.SellEDalerOptionsError += this.NeuroWallet_SellEDalerOptionsError;

            Client.SellEDalerClientUrlReceived += this.NeuroWallet_SellEDalerClientUrlReceived;

            Client.SellEDalerCompleted += this.NeuroWallet_SellEDalerCompleted;

            Client.SellEDalerError += this.NeuroWallet_SellEDalerError;

        }


        private async Task EDalerClient_BalanceUpdated(object? _, BalanceEventArgs e)

        {

            this.lastBalance = e.Balance;

            this.lastEDalerEvent = DateTime.Now;


            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationBalanceUpdatedTitle)];

            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationBalanceUpdatedBody)];


            NotificationIntent Intent = new()

            {

                Channel = Constants.PushChannels.EDaler,

                Title = Title,

                Body = Body,

                Action = NotificationAction.OpenBalance,

                EntityId = e.Balance?.Currency,

                CorrelationId = e.Balance?.Currency,

                Presentation = NotificationPresentation.StoreOnly

            };


            await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            await this.EDalerBalanceUpdated.Raise(this, e);

        }


        public event EventHandlerAsync<BalanceEventArgs>? EDalerBalanceUpdated;


        public Balance? LastEDalerBalance => this.lastBalance;


        public DateTime LastEDalerEvent => this.lastEDalerEvent;


        public bool TryParseEDalerUri(string Uri, out EDalerUri Parsed, out string Reason)

        {

            return EDalerUri.TryParse(Uri, out Parsed, out Reason);

        }


        public async Task<string> TryDecryptMessage(byte[] EncryptedMessage, byte[] PublicKey, Guid TransactionId, string RemoteEndpoint, bool LocalIsRecipient)

        {

            try

            {

                return await this.EDalerClient.DecryptMessage(EncryptedMessage, PublicKey, TransactionId, RemoteEndpoint, LocalIsRecipient);

            }

            catch (Exception ex)

            {

                ServiceRef.LogService.LogException(ex);

                return string.Empty;

            }

        }


        public Task<EDaler.Transaction> SendEDalerUri(string Uri)

        {

            return this.EDalerClient.SendEDalerUriAsync(Uri);

        }


        public Task<(AccountEvent[], bool)> GetEDalerAccountEvents(int MaxCount)

        {

            return this.EDalerClient.GetAccountEventsAsync(MaxCount);

        }


        public Task<(AccountEvent[], bool)> GetEDalerAccountEvents(int MaxCount, DateTime From)

        {

            return this.EDalerClient.GetAccountEventsAsync(MaxCount, From);

        }


        public Task<Balance> GetEDalerBalance()

        {

            return this.EDalerClient.GetBalanceAsync();

        }


        public Task<(decimal, string, PendingPayment[])> GetPendingEDalerPayments()

        {

            return this.EDalerClient.GetPendingPayments();

        }


        public Task<string> CreateFullEDalerPaymentUri(string ToBareJid, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays)

        {

            this.lastEDalerEvent = DateTime.Now;

            return this.EDalerClient.CreateFullPaymentUri(ToBareJid, Amount, AmountExtra, Currency, ValidNrDays);

        }


        public Task<string> CreateFullEDalerPaymentUri(string ToBareJid, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays, string Message)

        {

            this.lastEDalerEvent = DateTime.Now;

            return this.EDalerClient.CreateFullPaymentUri(ToBareJid, Amount, AmountExtra, Currency, ValidNrDays, Message);

        }


        public Task<string> CreateFullEDalerPaymentUri(LegalIdentity To, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays)

        {

            this.lastEDalerEvent = DateTime.Now;

            return this.EDalerClient.CreateFullPaymentUri(To, Amount, AmountExtra, Currency, ValidNrDays);

        }


        public Task<string> CreateFullEDalerPaymentUri(LegalIdentity To, decimal Amount, decimal? AmountExtra, string Currency, int ValidNrDays, string PrivateMessage)

        {

            this.lastEDalerEvent = DateTime.Now;

            return this.EDalerClient.CreateFullPaymentUri(To, Amount, AmountExtra, Currency, ValidNrDays, PrivateMessage);

        }


        public string CreateIncompleteEDalerPayMeUri(string BareJid, decimal? Amount, decimal? AmountExtra, string Currency, string Message)

        {

            return this.EDalerClient.CreateIncompletePayMeUri(BareJid, Amount, AmountExtra, Currency, Message);

        }


        public string CreateIncompleteEDalerPayMeUri(LegalIdentity To, decimal? Amount, decimal? AmountExtra, string Currency, string PrivateMessage)

        {

            return this.EDalerClient.CreateIncompletePayMeUri(To, Amount, AmountExtra, Currency, PrivateMessage);

        }


        public async Task<IBuyEDalerServiceProvider[]> GetServiceProvidersForBuyingEDalerAsync()

        {

            return await this.EDalerClient.GetServiceProvidersForBuyingEDalerAsync();

        }


        public async Task<OptionsTransaction> InitiateBuyEDalerGetOptions(string ServiceId, string ServiceProvider)

        {

            string TransactionId = Guid.NewGuid().ToString();

            string SuccessUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "beos"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));

            string FailureUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "beof"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));

            string CancelUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "beoc"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));


            TransactionId = await this.EDalerClient.InitiateGetOptionsBuyEDalerAsync(ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl);

            OptionsTransaction Result = new(TransactionId);


            lock (this.currentTransactions)

            {

                this.currentTransactions[TransactionId] = Result;

            }


            return Result;

        }


        private async Task NeuroWallet_BuyEDalerOptionsClientUrlReceived(object? Sender, BuyEDalerClientUrlEventArgs e)

        {

            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.ContainsKey(e.TransactionId))

                {

                    ServiceRef.LogService.LogWarning("Client URL message for getting options for buying eDaler ignored. Transaction ID not recognized.",

                        new KeyValuePair<string, object?>("TransactionId", e.TransactionId),

                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));

                    return;

                }

            }


            await Wallet.Transaction.OpenUrl(e.ClientUrl);

        }


        private Task NeuroWallet_BuyEDalerOptionsCompleted(object? _, PaymentOptionsEventArgs e)

        {

            this.BuyEDalerGetOptionsCompleted(e.TransactionId, e.Options);

            return Task.CompletedTask;

        }


        public void BuyEDalerGetOptionsCompleted(string TransactionId, IDictionary<CaseInsensitiveString, object>[] Options)

        {

            Wallet.Transaction? Transaction;


            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))

                    return;


                this.currentTransactions.Remove(TransactionId);

            }


            if (Transaction is OptionsTransaction OptionsTransaction)

                OptionsTransaction.Completed(Options);

        }


        private Task NeuroWallet_BuyEDalerOptionsError(object? _, PaymentErrorEventArgs e)

        {

            this.BuyEDalerGetOptionsFailed(e.TransactionId, e.Message);

            return Task.CompletedTask;

        }


        public void BuyEDalerGetOptionsFailed(string TransactionId, string Message)

        {

            Wallet.Transaction? Transaction;


            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))

                    return;


                this.currentTransactions.Remove(TransactionId);

            }


            Transaction.ErrorReported(Message);

        }


        public async Task<PaymentTransaction> InitiateBuyEDaler(string ServiceId, string ServiceProvider, decimal Amount, string Currency)

        {

            string TransactionId = Guid.NewGuid().ToString();

            string SuccessUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "bes"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>("amt", Amount),

                new KeyValuePair<string, object?>("cur", Currency),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));

            string FailureUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "bef"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));

            string CancelUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "bec"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));


            TransactionId = await this.EDalerClient.InitiateBuyEDalerAsync(ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl);

            PaymentTransaction Result = new(TransactionId, Currency);


            lock (this.currentTransactions)

            {

                this.currentTransactions[TransactionId] = Result;

            }


            return Result;

        }


        private static async Task<string> GenerateNeuroAccessUrl(params KeyValuePair<string, object?>[] Claims)

        {

            string Token = await ServiceRef.CryptoService.GenerateJwtToken(Claims);

            return Constants.UriSchemes.NeuroAccess + ":" + Token;

        }


        private async Task NeuroWallet_BuyEDalerClientUrlReceived(object? Sender, BuyEDalerClientUrlEventArgs e)

        {

            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.ContainsKey(e.TransactionId))

                {

                    ServiceRef.LogService.LogWarning("Client URL message for buying eDaler ignored. Transaction ID not recognized.",

                        new KeyValuePair<string, object?>("TransactionId", e.TransactionId),

                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));

                    return;

                }

            }


            await Wallet.Transaction.OpenUrl(e.ClientUrl);

        }


        private Task NeuroWallet_BuyEDalerCompleted(object? _, PaymentCompletedEventArgs e)

        {

            this.BuyEDalerCompleted(e.TransactionId, e.Amount, e.Currency);

            return Task.CompletedTask;

        }


        public void BuyEDalerCompleted(string TransactionId, decimal Amount, string Currency)

        {

            Wallet.Transaction? Transaction;


            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))

                    return;


                this.currentTransactions.Remove(TransactionId);

            }


            if (Transaction is PaymentTransaction PaymentTransaction)

                PaymentTransaction.Completed(Amount, Currency);

        }


        private Task NeuroWallet_BuyEDalerError(object? _, PaymentErrorEventArgs e)

        {

            this.BuyEDalerFailed(e.TransactionId, e.Message);

            return Task.CompletedTask;

        }


        public void BuyEDalerFailed(string TransactionId, string Message)

        {

            Wallet.Transaction? Transaction;


            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))

                    return;


                this.currentTransactions.Remove(TransactionId);

            }


            Transaction.ErrorReported(Message);

        }


        public async Task<ISellEDalerServiceProvider[]> GetServiceProvidersForSellingEDalerAsync()

        {

            return await this.EDalerClient.GetServiceProvidersForSellingEDalerAsync();

        }


        public async Task<OptionsTransaction> InitiateSellEDalerGetOptions(string ServiceId, string ServiceProvider)

        {

            string TransactionId = Guid.NewGuid().ToString();

            string SuccessUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "seos"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));

            string FailureUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "seof"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));

            string CancelUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "seoc"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));


            TransactionId = await this.EDalerClient.InitiateGetOptionsSellEDalerAsync(ServiceId, ServiceProvider, TransactionId, SuccessUrl, FailureUrl, CancelUrl);

            OptionsTransaction Result = new(TransactionId);


            lock (this.currentTransactions)

            {

                this.currentTransactions[TransactionId] = Result;

            }


            return Result;

        }


        private async Task NeuroWallet_SellEDalerOptionsClientUrlReceived(object? Sender, SellEDalerClientUrlEventArgs e)

        {

            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.ContainsKey(e.TransactionId))

                {

                    ServiceRef.LogService.LogWarning("Client URL message for getting options for selling eDaler ignored. Transaction ID not recognized.",

                        new KeyValuePair<string, object?>("TransactionId", e.TransactionId),

                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));

                    return;

                }

            }


            await Wallet.Transaction.OpenUrl(e.ClientUrl);

        }


        private Task NeuroWallet_SellEDalerOptionsCompleted(object? _, PaymentOptionsEventArgs e)

        {

            this.SellEDalerGetOptionsCompleted(e.TransactionId, e.Options);

            return Task.CompletedTask;

        }


        public void SellEDalerGetOptionsCompleted(string TransactionId, IDictionary<CaseInsensitiveString, object>[] Options)

        {

            Wallet.Transaction? Transaction;


            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))

                    return;


                this.currentTransactions.Remove(TransactionId);

            }


            if (Transaction is OptionsTransaction OptionsTransaction)

                OptionsTransaction.Completed(Options);

        }


        private Task NeuroWallet_SellEDalerOptionsError(object? _, PaymentErrorEventArgs e)

        {

            this.SellEDalerGetOptionsFailed(e.TransactionId, e.Message);

            return Task.CompletedTask;

        }


        public void SellEDalerGetOptionsFailed(string TransactionId, string Message)

        {

            Wallet.Transaction? Transaction;


            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))

                    return;


                this.currentTransactions.Remove(TransactionId);

            }


            Transaction.ErrorReported(Message);

        }


        public async Task<PaymentTransaction> InitiateSellEDaler(string ServiceId, string ServiceProvider, decimal Amount, string Currency)

        {

            string TransactionId = Guid.NewGuid().ToString();

            string SuccessUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "ses"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>("amt", Amount),

                new KeyValuePair<string, object?>("cur", Currency),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));

            string FailureUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "sef"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));

            string CancelUrl = await GenerateNeuroAccessUrl(

                new KeyValuePair<string, object?>("cmd", "sec"),

                new KeyValuePair<string, object?>("tid", TransactionId),

                new KeyValuePair<string, object?>(JwtClaims.ClientId, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Issuer, ServiceRef.CryptoService.DeviceID),

                new KeyValuePair<string, object?>(JwtClaims.Subject, ServiceRef.XmppService.BareJid),

                new KeyValuePair<string, object?>(JwtClaims.ExpirationTime, (int)DateTime.UtcNow.AddHours(1).Subtract(JSON.UnixEpoch).TotalSeconds));


            TransactionId = await this.EDalerClient.InitiateSellEDalerAsync(ServiceId, ServiceProvider, Amount, Currency, TransactionId, SuccessUrl, FailureUrl, CancelUrl);

            PaymentTransaction Result = new(TransactionId, Currency);


            lock (this.currentTransactions)

            {

                this.currentTransactions[TransactionId] = Result;

            }


            return Result;

        }


        private async Task NeuroWallet_SellEDalerClientUrlReceived(object? Sender, SellEDalerClientUrlEventArgs e)

        {

            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.ContainsKey(e.TransactionId))

                {

                    ServiceRef.LogService.LogWarning("Client URL message ignored. Transaction ID not recognized.",

                        new KeyValuePair<string, object?>("TransactionId", e.TransactionId),

                        new KeyValuePair<string, object?>("ClientUrl", e.ClientUrl));

                    return;

                }

            }


            await Wallet.Transaction.OpenUrl(e.ClientUrl);

        }


        private Task NeuroWallet_SellEDalerError(object? _, PaymentErrorEventArgs e)

        {

            this.SellEDalerFailed(e.TransactionId, e.Message);

            return Task.CompletedTask;

        }


        public void SellEDalerFailed(string TransactionId, string Message)

        {

            Wallet.Transaction? Transaction;


            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))

                    return;


                this.currentTransactions.Remove(TransactionId);

            }


            Transaction.ErrorReported(Message);

        }


        private Task NeuroWallet_SellEDalerCompleted(object? _, PaymentCompletedEventArgs e)

        {

            this.SellEDalerCompleted(e.TransactionId, e.Amount, e.Currency);

            return Task.CompletedTask;

        }


        public void SellEDalerCompleted(string TransactionId, decimal Amount, string Currency)

        {

            Wallet.Transaction? Transaction;


            lock (this.currentTransactions)

            {

                if (!this.currentTransactions.TryGetValue(TransactionId, out Transaction))

                    return;


                this.currentTransactions.Remove(TransactionId);

            }


            if (Transaction is PaymentTransaction PaymentTransaction)

                PaymentTransaction.Completed(Amount, Currency);

        }


        #endregion


        #region Neuro-Features


        private DateTime lastTokenEvent = DateTime.MinValue;


        private NeuroFeaturesClient NeuroFeaturesClient

        {

            get

            {

                if (this.neuroFeaturesClient is null)

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.NeuroFeaturesServiceNotFound)]);


                return this.neuroFeaturesClient;

            }

        }


        private void RegisterNeuroFeatureEventHandlers(NeuroFeaturesClient Client)

        {

            Client.TokenAdded += this.NeuroFeaturesClient_TokenAdded;

            Client.TokenRemoved += this.NeuroFeaturesClient_TokenRemoved;


            Client.StateUpdated += this.NeuroFeaturesClient_StateUpdated;

            Client.VariablesUpdated += this.NeuroFeaturesClient_VariablesUpdated;

        }


        public DateTime LastNeuroFeatureEvent => this.lastTokenEvent;


        private async Task NeuroFeaturesClient_TokenRemoved(object _, NeuroFeatures.EventArguments.TokenEventArgs e)

        {

            this.lastTokenEvent = DateTime.Now;


            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationTokenRemovedTitle)];

            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationTokenRemovedBody)];


            NotificationIntent Intent = new()

            {

                Channel = Constants.PushChannels.Tokens,

                Title = Title,

                Body = Body,

                Action = NotificationAction.OpenToken,

                EntityId = e.Token?.TokenId,

                CorrelationId = e.Token?.TokenId,

                Presentation = NotificationPresentation.StoreOnly

            };


            await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            await this.NeuroFeatureRemoved.Raise(this, e);

        }


        public event EventHandlerAsync<NeuroFeatures.EventArguments.TokenEventArgs>? NeuroFeatureRemoved;


        private async Task NeuroFeaturesClient_TokenAdded(object _, NeuroFeatures.EventArguments.TokenEventArgs e)

        {

            this.lastTokenEvent = DateTime.Now;


            string Title = ServiceRef.Localizer[nameof(AppResources.NotificationTokenAddedTitle)];

            string Body = ServiceRef.Localizer[nameof(AppResources.NotificationTokenAddedBody)];


            NotificationIntent Intent = new()

            {

                Channel = Constants.PushChannels.Tokens,

                Title = Title,

                Body = Body,

                Action = NotificationAction.OpenToken,

                EntityId = e.Token?.TokenId,

                CorrelationId = e.Token?.TokenId,

                Presentation = NotificationPresentation.StoreOnly

            };


            await AddNotificationAsync(Intent, NotificationSource.Xmpp, null);

            await this.NeuroFeatureAdded.Raise(this, e);

        }


        public event EventHandlerAsync<NeuroFeatures.EventArguments.TokenEventArgs>? NeuroFeatureAdded;


        private async Task NeuroFeaturesClient_VariablesUpdated(object? _, VariablesUpdatedEventArgs e)

        {

            await this.NeuroFeatureVariablesUpdated.Raise(this, e);

        }


        public event EventHandlerAsync<VariablesUpdatedEventArgs>? NeuroFeatureVariablesUpdated;


        private async Task NeuroFeaturesClient_StateUpdated(object? _, NewStateEventArgs e)

        {

            await this.NeuroFeatureStateUpdated.Raise(this, e);

        }


        public event EventHandlerAsync<NewStateEventArgs>? NeuroFeatureStateUpdated;


        public Task<TokensEventArgs> GetNeuroFeatures()

        {

            return this.GetNeuroFeatures(0, int.MaxValue);

        }


        public Task<TokensEventArgs> GetNeuroFeatures(int Offset, int MaxCount)

        {

            return this.NeuroFeaturesClient.GetTokensAsync(Offset, MaxCount);

        }


        public Task<string[]> GetNeuroFeatureReferences()

        {

            return this.GetNeuroFeatureReferences(0, int.MaxValue);

        }


        public Task<string[]> GetNeuroFeatureReferences(int Offset, int MaxCount)

        {

            return this.NeuroFeaturesClient.GetTokenReferencesAsync(Offset, MaxCount);

        }


        public Task<TokenTotalsEventArgs> GetNeuroFeatureTotals()

        {

            return this.NeuroFeaturesClient.GetTotalsAsync();

        }


        public Task<TokensEventArgs> GetNeuroFeaturesForContract(string ContractId)

        {

            return this.NeuroFeaturesClient.GetContractTokensAsync(ContractId);

        }


        public Task<TokensEventArgs> GetNeuroFeaturesForContract(string ContractId, int Offset, int MaxCount)

        {

            return this.NeuroFeaturesClient.GetContractTokensAsync(ContractId, Offset, MaxCount);

        }


        public Task<string[]> GetNeuroFeatureReferencesForContract(string ContractId)

        {

            return this.NeuroFeaturesClient.GetContractTokenReferencesAsync(ContractId);

        }


        public Task<string[]> GetNeuroFeatureReferencesForContract(string ContractId, int Offset, int MaxCount)

        {

            return this.NeuroFeaturesClient.GetContractTokenReferencesAsync(ContractId, Offset, MaxCount);

        }


        public Task<Token> GetNeuroFeature(string TokenId)

        {

            return this.NeuroFeaturesClient.GetTokenAsync(TokenId);

        }


        public Task<TokenEvent[]> GetNeuroFeatureEvents(string TokenId)

        {

            return this.GetNeuroFeatureEvents(TokenId, 0, int.MaxValue);

        }


        public Task<TokenEvent[]> GetNeuroFeatureEvents(string TokenId, int Offset, int MaxCount)

        {

            return this.NeuroFeaturesClient.GetEventsAsync(TokenId, Offset, MaxCount);

        }


        public Task AddNeuroFeatureTextNote(string TokenId, string TextNote)

        {

            return this.AddNeuroFeatureTextNote(TokenId, TextNote, false);

        }


        public Task AddNeuroFeatureTextNote(string TokenId, string TextNote, bool Personal)

        {

            this.lastTokenEvent = DateTime.Now;


            return this.NeuroFeaturesClient.AddTextNoteAsync(TokenId, TextNote, Personal);

        }


        public Task AddNeuroFeatureXmlNote(string TokenId, string XmlNote)

        {

            return this.AddNeuroFeatureXmlNote(TokenId, XmlNote, false);

        }


        public Task AddNeuroFeatureXmlNote(string TokenId, string XmlNote, bool Personal)

        {

            this.lastTokenEvent = DateTime.Now;


            return this.NeuroFeaturesClient.AddXmlNoteAsync(TokenId, XmlNote, Personal);

        }


        public Task<CreationAttributesEventArgs> GetNeuroFeatureCreationAttributes()

        {

            return this.NeuroFeaturesClient.GetCreationAttributesAsync();

        }


        public async Task<string> GenerateNeuroFeatureStateDiagramReport(string TokenId)

        {

            ReportEventArgs e = await this.NeuroFeaturesClient.GenerateStateDiagramAsync(TokenId, ReportFormat.Markdown);

            if (!e.Ok)

                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetStateDiagram)]);


            return await e.ReportText.MarkdownToXaml();

        }


        public async Task<VerticalStackLayout> GenerateNeuroFeatureStateDiagramReportMaui(string TokenId)

        {

            ReportEventArgs e = await this.NeuroFeaturesClient.GenerateStateDiagramAsync(TokenId, ReportFormat.Markdown);

            if (!e.Ok)

                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetStateDiagram)]);


            return await e.ReportText.MarkdownToMaui();

        }


        public async Task<string> GenerateNeuroFeatureProfilingReport(string TokenId)

        {

            ReportEventArgs e = await this.NeuroFeaturesClient.GenerateProfilingReportAsync(TokenId, ReportFormat.Markdown);

            if (!e.Ok)

                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetProfiling)]);


            return await e.ReportText.MarkdownToXaml();

        }


        public async Task<VerticalStackLayout> GenerateNeuroFeatureProfilingReportMaui(string TokenId)

        {

            ReportEventArgs e = await this.NeuroFeaturesClient.GenerateProfilingReportAsync(TokenId, ReportFormat.Markdown);

            if (!e.Ok)

                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetProfiling)]);


            return await e.ReportText.MarkdownToMaui();

        }


        public async Task<string> GenerateNeuroFeaturePresentReport(string TokenId)

        {

            ReportEventArgs e = await this.NeuroFeaturesClient.GeneratePresentReportAsync(TokenId, ReportFormat.Markdown);

            if (!e.Ok)

                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetPresent)]);


            return await e.ReportText.MarkdownToXaml();

        }


        public async Task<VerticalStackLayout> GenerateNeuroFeaturePresentReportMaui(string TokenId)

        {

            ReportEventArgs e = await this.NeuroFeaturesClient.GeneratePresentReportAsync(TokenId, ReportFormat.Markdown);

            if (!e.Ok)

                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetPresent)]);


            return await e.ReportText.MarkdownToMaui();

        }


        public async Task<string> GenerateNeuroFeatureHistoryReport(string TokenId)

        {

            ReportEventArgs e = await this.NeuroFeaturesClient.GenerateHistoryReportAsync(TokenId, ReportFormat.Markdown);

            if (!e.Ok)

                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetHistory)]);


            return await e.ReportText.MarkdownToXaml();

        }


        public async Task<VerticalStackLayout> GenerateNeuroFeatureHistoryReportMaui(string TokenId)

        {

            ReportEventArgs e = await this.NeuroFeaturesClient.GenerateHistoryReportAsync(TokenId, ReportFormat.Markdown);

            if (!e.Ok)

                throw e.StanzaError ?? new Exception(ServiceRef.Localizer[nameof(AppResources.UnableToGetHistory)]);


            return await e.ReportText.MarkdownToMaui();

        }


        public Task<CurrentStateEventArgs> GetNeuroFeatureCurrentState(string TokenId)

        {

            return this.NeuroFeaturesClient.GetCurrentStateAsync(TokenId);

        }


        #endregion


        #region Private XML


        public Task SavePrivateXml(string Xml)

        {

            return this.xmppClient?.SetPrivateXmlElementAsync(Xml)

                ?? throw new Exception("Not connected to XMPP network.");

        }


        public Task SavePrivateXml(XmlElement Xml)

        {

            return this.xmppClient?.SetPrivateXmlElementAsync(Xml)

                ?? throw new Exception("Not connected to XMPP network.");

        }


        public async Task<XmlElement?> LoadPrivateXml(string LocalName, string Namespace)

        {

            return await this.XmppClient.GetPrivateXmlElementAsync(LocalName, Namespace);

        }


        public Task DeletePrivateXml(string LocalName, string Namespace)

        {

            StringBuilder Xml = new();


            Xml.Append('<');

            Xml.Append(XML.Encode(LocalName));

            Xml.Append(" xmlns='");

            Xml.Append(XML.Encode(Namespace));

            Xml.Append("'/>");

            return this.SavePrivateXml(Xml.ToString());

        }


        #endregion


        #region PubSub


        private PubSubClient PubSubClient

        {

            get

            {

                if (this.pepClient is null)

                {

                    throw new InvalidOperationException(ServiceRef.Localizer[nameof(AppResources.PubSubServiceNotFound)]);

                }


                return this.pepClient.PubSubClient;

            }

        }


        public async Task<Item[]?> GetAllNodeIdsAsync()

        {

            try

            {

                TaskCompletionSource<ServiceItemsDiscoveryEventArgs> Tcs = new();

                await this.XmppClient.SendServiceItemsDiscoveryRequest(

                    this.PubSubClient.ComponentAddress,

                    (s, e) => { Tcs.TrySetResult(e); return Task.CompletedTask; },

                    null);

                ServiceItemsDiscoveryEventArgs Result = await Tcs.Task;

                return Result.Items;

            }

            catch

            {

                return null;

            }

        }


        public async Task<PubSubItem[]?> GetItemsAsync(string NodeId)

        {

            try

            {

                TaskCompletionSource<ItemsEventArgs> Tcs = new();

                await this.PubSubClient.GetItems(NodeId, (s, e) => HandleResult(e, Tcs), null);

                ItemsEventArgs Result = await Tcs.Task;

                return Result.Items;

            }

            catch

            {

                return null;

            }

        }


        public async Task<PubSubItem[]?> GetItemsAsync(string NodeId, string[] ItemIds)

        {

            try

            {

                TaskCompletionSource<ItemsEventArgs> Tcs = new();

                await this.PubSubClient.GetItems(NodeId, ItemIds, (s, e) => HandleResult(e, Tcs), null);

                ItemsEventArgs Result = await Tcs.Task;

                return Result.Items;

            }

            catch

            {

                return null;

            }

        }


        public async Task<PubSubItem?> GetItemAsync(string NodeId, string ItemId)

        {

            try

            {

                TaskCompletionSource<ItemsEventArgs> Tcs = new();

                await this.PubSubClient.GetItems(NodeId, [ItemId], (s, e) => HandleResult(e, Tcs), null);

                ItemsEventArgs Result = await Tcs.Task;

                return Result.Items.FirstOrDefault();

            }

            catch

            {

                return null;

            }

        }


        public async Task<PubSubItem[]?> GetLatestItemsAsync(string NodeId, int Count)

        {

            try

            {

                TaskCompletionSource<ItemsEventArgs> Tcs = new();

                await this.PubSubClient.GetLatestItems(NodeId, Count, (s, e) => HandleResult(e, Tcs), null);

                ItemsEventArgs Result = await Tcs.Task;

                return Result.Items;

            }

            catch

            {

                return null;

            }

        }


        public async Task<PubSubPageResult?> GetItemsPageAsync(string NodeId, string? ServiceAddress = null, string? After = null, string? Before = null, int? Index = null, int? Max = null)

        {

            try

            {

                RestrictedQuery? Query = null;

                bool HasCursor = !string.IsNullOrWhiteSpace(After) || !string.IsNullOrWhiteSpace(Before) || Index.HasValue || Max.HasValue;

                if (HasCursor)

                {

                    Query = new RestrictedQuery(After, Before, Index, Max);

                }


                TaskCompletionSource<ItemsEventArgs> Tcs = new();

                string? EffectiveServiceAddress = ServiceAddress ?? this.PubSubClient.ComponentAddress;


                if (Query is null)

                {

                    if (string.IsNullOrWhiteSpace(EffectiveServiceAddress))

                    {

                        await this.PubSubClient.GetItems(NodeId, (s, e) => HandleResult(e, Tcs), null);

                    }

                    else

                    {

                        await this.PubSubClient.GetItems(EffectiveServiceAddress, NodeId, (s, e) => HandleResult(e, Tcs), null);

                    }

                }

                else

                {

                    if (string.IsNullOrWhiteSpace(EffectiveServiceAddress))

                    {

                        await this.PubSubClient.GetItems(NodeId, Query, (s, e) => HandleResult(e, Tcs), null);

                    }

                    else

                    {

                        await this.PubSubClient.GetItems(EffectiveServiceAddress, NodeId, Query, (s, e) => HandleResult(e, Tcs), null);

                    }

                }


                ItemsEventArgs Result = await Tcs.Task;

                PubSubItem[] Items = Result.Items ?? [];

                ResultPage? Page = Result.Page;

                return new PubSubPageResult(NodeId, Items, Page);

            }

            catch

            {

                return null;

            }

        }


        public async Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> CreateNodeAsync(string NodeId, NodeConfiguration? Config = null)

        {

            TaskCompletionSource<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs> Tcs = new();

            if (Config is null)

                await this.PubSubClient.CreateNode(NodeId, (s, e) => HandleResult(e, Tcs), null);

            else

                await this.PubSubClient.CreateNode(NodeId, Config, (s, e) => HandleResult(e, Tcs), null);

            return await Tcs.Task;

        }


        public async Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> TryCreateNodeAsync(string NodeId, NodeConfiguration? Config = null)

        {

            try { return await this.CreateNodeAsync(NodeId, Config); }

            catch { return null; }

        }


        public async Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> DeleteNodeAsync(string NodeId, string? RedirectUri = null)

        {

            TaskCompletionSource<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs> Tcs = new();

            await this.PubSubClient.DeleteNode(NodeId, RedirectUri, (s, e) => HandleResult(e, Tcs), null);

            return await Tcs.Task;

        }


        public async Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> TryDeleteNodeAsync(string NodeId, string? RedirectUri = null)

        {

            try { return await this.DeleteNodeAsync(NodeId, RedirectUri); }

            catch { return null; }

        }


        public async Task<SubscriptionEventArgs> SubscribeAsync(string NodeId, string? Jid = null, SubscriptionOptions? Options = null)

        {

            TaskCompletionSource<SubscriptionEventArgs> Tcs = new();

            if (Options is null)

                await this.PubSubClient.Subscribe(NodeId, Jid, (s, e) => HandleResult(e, Tcs), null);

            else

                await this.PubSubClient.Subscribe(NodeId, Jid, Options, (s, e) => HandleResult(e, Tcs), null);

            return await Tcs.Task;

        }


        public async Task<SubscriptionEventArgs?> TrySubscribeAsync(string NodeId, string? Jid = null, SubscriptionOptions? Options = null)

        {

            try { return await this.SubscribeAsync(NodeId, Jid, Options); }

            catch { return null; }

        }


        public async Task<SubscriptionEventArgs> UnsubscribeAsync(string NodeId, string? Jid = null, string? SubscriptionId = null)

        {

            TaskCompletionSource<SubscriptionEventArgs> Tcs = new();

            await this.PubSubClient.Unsubscribe(NodeId, Jid, SubscriptionId, (s, e) => HandleResult(e, Tcs), null);

            return await Tcs.Task;

        }


        public async Task<SubscriptionEventArgs?> TryUnsubscribeAsync(string NodeId, string? Jid = null, string? SubscriptionId = null)

        {

            try { return await this.UnsubscribeAsync(NodeId, Jid, SubscriptionId); }

            catch { return null; }

        }


        public async Task<ItemResultEventArgs> PublishAsync(string NodeId, string? ItemId = null, string PayloadXml = "")

        {

            TaskCompletionSource<ItemResultEventArgs> Tcs = new();

            await this.PubSubClient.Publish(NodeId, ItemId ?? string.Empty, PayloadXml, (s, e) => HandleResult(e, Tcs), null);

            return await Tcs.Task;

        }


        public async Task<ItemResultEventArgs?> TryPublishAsync(string NodeId, string? ItemId = null, string PayloadXml = "")

        {

            try { return await this.PublishAsync(NodeId, ItemId, PayloadXml); }

            catch { return null; }

        }


        public async Task<IqResultEventArgs> RetractAsync(string NodeId, string ItemId)

        {

            TaskCompletionSource<IqResultEventArgs> Tcs = new();

            await this.PubSubClient.Retract(NodeId, ItemId, (s, e) => HandleResult(e, Tcs), null);

            return await Tcs.Task;

        }


        public async Task<IqResultEventArgs?> TryRetractAsync(string NodeId, string ItemId)

        {

            try { return await this.RetractAsync(NodeId, ItemId); }

            catch { return null; }

        }


        public async Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs> PurgeNodeAsync(string NodeId)

        {

            TaskCompletionSource<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs> Tcs = new();

            await this.PubSubClient.PurgeNode(NodeId, (s, e) => HandleResult(e, Tcs), null);

            return await Tcs.Task;

        }


        public async Task<Waher.Networking.XMPP.PubSub.Events.NodeEventArgs?> TryPurgeNodeAsync(string NodeId)

        {

            try { return await this.PurgeNodeAsync(NodeId); }

            catch { return null; }

        }


        private static Task HandleResult<T>(T e, TaskCompletionSource<T> Tcs) where T : IqResultEventArgs

        {

            if (e.Ok)

                Tcs.TrySetResult(e);

            else

                Tcs.TrySetException(e.StanzaError ?? new Exception());

            return Task.CompletedTask;

        }

        #endregion


        #region Helpers

        private static async Task AddNotificationAsync(NotificationIntent Intent, NotificationSource Source, string? RawPayload)

        {

            try

            {

                INotificationServiceV2 NotificationService = ServiceRef.Provider.GetRequiredService<INotificationServiceV2>();

                await NotificationService.AddAsync(Intent, Source, RawPayload, CancellationToken.None);

            }

            catch (Exception Ex)

            {

                ServiceRef.LogService.LogException(Ex);

            }

        }


        private static string ToBareJid(string Jid)

        {

            if (string.IsNullOrWhiteSpace(Jid))

                return Jid;


            int SlashIndex = Jid.IndexOf('/');

            return SlashIndex > -1 ? Jid.Substring(0, SlashIndex) : Jid;

        }

        #endregion

    }

}

EDaler.AccountEvent
Account event
Definition: AccountEvent.cs:16

EDaler.Balance
Contains information about a balance.
Definition: Balance.cs:11

EDaler.Balance.Currency
CaseInsensitiveString Currency
Currency of amount.
Definition: Balance.cs:54

EDaler.EDalerClient
eDaler XMPP client.
Definition: EDalerClient.cs:23

EDaler.EDalerClient.GetAccountEventsAsync
Task<(AccountEvent[], bool)> GetAccountEventsAsync(int MaxEvents)
Gets account events associated with the wallet of the account.
Definition: EDalerClient.cs:505

EDaler.EDalerClient.NamespaceEDaler
const string NamespaceEDaler
Namespace of eDaler component.
Definition: EDalerClient.cs:27

EDaler.EDalerClient.GetBalanceAsync
Task< Balance > GetBalanceAsync()
Gets the current balance of the eDaler wallet associated with the account.
Definition: EDalerClient.cs:207

EDaler.EDalerClient.Dispose
override void Dispose()
IDisposable.Dispose
Definition: EDalerClient.cs:66

EDaler.EDalerClient.DecryptMessage
string DecryptMessage(byte[] EncryptedMessage, byte[] PublicKey, Guid TransactionId, bool LocalIsRecipient)
Decrypts a message that was aimed at the client using the current keys.
Definition: EDalerClient.cs:966

EDaler.EDalerClient.CreateIncompletePayMeUri
string CreateIncompletePayMeUri(string BareJid, decimal? Amount, decimal? AmountExtra, string Currency, string Message)
Generates an incomplete eDaler PayMe URI.
Definition: EDalerClient.cs:902

EDaler.EDalerClient.GetPendingPayments
async Task<(decimal, string, PendingPayment[])> GetPendingPayments()
Gets the amount of payments pending to be processed.
Definition: EDalerClient.cs:1040

EDaler.EDalerClient.InitiateBuyEDalerAsync
Task< string > InitiateBuyEDalerAsync(string ServiceId, string ServiceProvider, decimal Amount, string Currency)
Initiates a process for buying eDaler.
Definition: EDalerClient.cs:2105

EDaler.EDalerClient.SendEDalerUriAsync
Task< Transaction > SendEDalerUriAsync(string Uri)
Sends an eDaler URI to the server
Definition: EDalerClient.cs:367

EDaler.EDalerClient.CreateFullPaymentUri
Task< string > CreateFullPaymentUri(decimal Amount, decimal? AmountExtra, CaseInsensitiveString Currency, int ValidNrDays)
Creates a full payment URI to anyone who is the first in claiming the URI.
Definition: EDalerClient.cs:611

EDaler.EDalerClient.GetServiceProvidersForBuyingEDalerAsync
Task< IBuyEDalerServiceProvider[]> GetServiceProvidersForBuyingEDalerAsync()
Gets available service providers who can help the user buy eDaler.
Definition: EDalerClient.cs:1209

EDaler.EDalerClient.GetServiceProvidersForSellingEDalerAsync
Task< ISellEDalerServiceProvider[]> GetServiceProvidersForSellingEDalerAsync()
Gets available service providers who can help the user sell eDaler.
Definition: EDalerClient.cs:1301

EDaler.EDalerClient.InitiateGetOptionsSellEDalerAsync
Task< string > InitiateGetOptionsSellEDalerAsync(string ServiceId, string ServiceProvider)
Initiates a process for getting payment options for selling eDaler.
Definition: EDalerClient.cs:1835

EDaler.EDalerClient.InitiateGetOptionsBuyEDalerAsync
Task< string > InitiateGetOptionsBuyEDalerAsync(string ServiceId, string ServiceProvider)
Initiates a process for getting payment options for buying eDaler.
Definition: EDalerClient.cs:1463

EDaler.EDalerClient.InitiateSellEDalerAsync
Task< string > InitiateSellEDalerAsync(string ServiceId, string ServiceProvider, decimal Amount, string Currency)
Initiates a process for selling eDaler.
Definition: EDalerClient.cs:2376

EDaler.Events.BalanceEventArgs
Wallet balance event arguments.
Definition: BalanceEventArgs.cs:9

EDaler.Events.BalanceEventArgs.Balance
Balance Balance
Balance.
Definition: BalanceEventArgs.cs:21

EDaler.Events.BuyEDalerClientUrlEventArgs
Event arguments for events where a client URL needs to be displayed when buying eDaler.
Definition: BuyEDalerClientUrlEventArgs.cs:10

EDaler.Events.BuyEDalerClientUrlEventArgs.ClientUrl
string ClientUrl
URL client needs to open to complete the transaction of buying eDaler.
Definition: BuyEDalerClientUrlEventArgs.cs:36

EDaler.Events.BuyEDalerClientUrlEventArgs.TransactionId
string TransactionId
Transaction ID, if available in the response.
Definition: BuyEDalerClientUrlEventArgs.cs:31

EDaler.Events.PaymentCompletedEventArgs
Event arguments for event signalling the completion of a payment operation.
Definition: PaymentCompletedEventArgs.cs:9

EDaler.Events.PaymentCompletedEventArgs.Amount
decimal Amount
Amount paid
Definition: PaymentCompletedEventArgs.cs:38

EDaler.Events.PaymentCompletedEventArgs.Currency
string Currency
Currency paid
Definition: PaymentCompletedEventArgs.cs:43

EDaler.Events.PaymentCompletedEventArgs.TransactionId
string TransactionId
Transaction ID, if available in the response.
Definition: PaymentCompletedEventArgs.cs:33

EDaler.Events.PaymentErrorEventArgs
Event arguments for event signalling an error of a payment operation.
Definition: PaymentErrorEventArgs.cs:9

EDaler.Events.PaymentErrorEventArgs.TransactionId
string TransactionId
Transaction ID, if available in the response.
Definition: PaymentErrorEventArgs.cs:29

EDaler.Events.PaymentErrorEventArgs.Message
new string Message
Error message.
Definition: PaymentErrorEventArgs.cs:34

EDaler.Events.PaymentOptionsEventArgs
Event arguments for operations returning payment options.
Definition: PaymentOptionsEventArgs.cs:11

EDaler.Events.PaymentOptionsEventArgs.Options
IDictionary< CaseInsensitiveString, object >[] Options
Payment options.
Definition: PaymentOptionsEventArgs.cs:37

EDaler.Events.PaymentOptionsEventArgs.TransactionId
string TransactionId
Transaction ID, if available in the response.
Definition: PaymentOptionsEventArgs.cs:32

EDaler.Events.SellEDalerClientUrlEventArgs
Event arguments for events where a client URL needs to be displayed when selling eDaler.
Definition: SellEDalerClientUrlEventArgs.cs:10

EDaler.Events.SellEDalerClientUrlEventArgs.TransactionId
string TransactionId
Transaction ID, if available in the response.
Definition: SellEDalerClientUrlEventArgs.cs:31

EDaler.Events.SellEDalerClientUrlEventArgs.ClientUrl
string ClientUrl
URL client needs to open to complete the transaction of selling eDaler.
Definition: SellEDalerClientUrlEventArgs.cs:36

EDaler.PendingPayment
Contains information about a pending payment.
Definition: PendingPayment.cs:12

EDaler.Transaction
Represents a transaction in the eDaler network.
Definition: Transaction.cs:36

EDaler.Uris.EDalerUri
Abstract base class for eDaler URIs
Definition: EDalerUri.cs:14

EDaler.Uris.EDalerUri.TryParse
static bool TryParse(string Uri, out EDalerUri Result)
Tries to parse an eDaler URI
Definition: EDalerUri.cs:192

NeuroAccessMaui.App
Represents an instance of the Neuro-Access app.
Definition: App.xaml.cs:125

NeuroAccessMaui.App.Current
static new? App Current
Gets the current application instance.
Definition: App.xaml.cs:169

NeuroAccessMaui.Constants.BatchSizes
Size constants.
Definition: Constants.cs:912

NeuroAccessMaui.Constants.BatchSizes.DeviceBatchSize
const int DeviceBatchSize
Number of devices to load in a single batch.
Definition: Constants.cs:931

NeuroAccessMaui.Constants.ContractMachineNames
Machine-readable names in contracts.
Definition: Constants.cs:938

NeuroAccessMaui.Constants.ContractMachineNames.PaymentInstructionsNamespace
const string PaymentInstructionsNamespace
Namespace for payment instructions
Definition: Constants.cs:942

NeuroAccessMaui.Constants.ContractMachineNames.BuyEDaler
const string BuyEDaler
Local name for contracts for buying eDaler.
Definition: Constants.cs:947

NeuroAccessMaui.Constants.ContractMachineNames.SellEDaler
const string SellEDaler
Local name for contracts for selling eDaler.
Definition: Constants.cs:952

NeuroAccessMaui.Constants.Domains
Domain names.
Definition: Constants.cs:303

NeuroAccessMaui.Constants.Domains.OnboardingDomain
const string OnboardingDomain
Neuro-Access onboarding domain.
Definition: Constants.cs:312

NeuroAccessMaui.Constants.Intervals
Timer Intervals
Definition: Constants.cs:662

NeuroAccessMaui.Constants.Intervals.Reconnect
static readonly TimeSpan Reconnect
Reconnect interval
Definition: Constants.cs:671

NeuroAccessMaui.Constants.LanguageCodes
Language Codes
Definition: Constants.cs:101

NeuroAccessMaui.Constants.LanguageCodes.Default
const string Default
The default language code.
Definition: Constants.cs:105

NeuroAccessMaui.Constants.Pages
Absolute paths to important pages.
Definition: Constants.cs:875

NeuroAccessMaui.Constants.Pages.RegistrationPage
const string RegistrationPage
Path to registration page.
Definition: Constants.cs:884

NeuroAccessMaui.Constants.PushChannels
Push chennels
Definition: Constants.cs:735

NeuroAccessMaui.Constants.PushChannels.Provisioning
const string Provisioning
Provisioning channel
Definition: Constants.cs:769

NeuroAccessMaui.Constants.PushChannels.Petitions
const string Petitions
Petitions channel
Definition: Constants.cs:744

NeuroAccessMaui.Constants.PushChannels.Identities
const string Identities
Identities channel
Definition: Constants.cs:749

NeuroAccessMaui.Constants.PushChannels.Messages
const string Messages
Messages channel
Definition: Constants.cs:739

NeuroAccessMaui.Constants.PushChannels.EDaler
const string EDaler
eDaler channel
Definition: Constants.cs:759

NeuroAccessMaui.Constants.PushChannels.Tokens
const string Tokens
Tokens channel
Definition: Constants.cs:764

NeuroAccessMaui.Constants.PushChannels.Contracts
const string Contracts
Contracts channel
Definition: Constants.cs:754

NeuroAccessMaui.Constants.QrCode
QR Code constants.
Definition: Constants.cs:1005

NeuroAccessMaui.Constants.QrCode.DefaultImageHeight
const int DefaultImageHeight
The default height to use when generating QR Code images.
Definition: Constants.cs:1013

NeuroAccessMaui.Constants.QrCode.DefaultImageWidth
const int DefaultImageWidth
The default width to use when generating QR Code images.
Definition: Constants.cs:1009

NeuroAccessMaui.Constants.Settings
Runtime setting key names.
Definition: Constants.cs:1024

NeuroAccessMaui.Constants.Settings.TransferIdCodeSent
const string TransferIdCodeSent
Transfer ID code
Definition: Constants.cs:1053

NeuroAccessMaui.Constants.Timeouts
Timer Timeout Values
Definition: Constants.cs:688

NeuroAccessMaui.Constants.Timeouts.XmppConnect
static readonly TimeSpan XmppConnect
XMPP Connect timeout
Definition: Constants.cs:702

NeuroAccessMaui.Constants.XmppProperties
XMPP Protocol Properties.
Definition: Constants.cs:370

NeuroAccessMaui.Constants.XmppProperties.Partition
const string Partition
Partition
Definition: Constants.cs:639

NeuroAccessMaui.Constants.XmppProperties.SourceId
const string SourceId
Source ID
Definition: Constants.cs:634

NeuroAccessMaui.Constants.XmppProperties.NodeId
const string NodeId
Node ID
Definition: Constants.cs:644

NeuroAccessMaui.Constants.XmppProperties.Jid
const string Jid
Jabber ID
Definition: Constants.cs:519

NeuroAccessMaui.Constants
A set of never changing property constants and helpful values.
Definition: Constants.cs:24

NeuroAccessMaui.Resources.Languages.AppResources
A strongly-typed resource class, for looking up localized strings, etc.
Definition: AppResources.Designer.cs:25

NeuroAccessMaui.Resources.Languages.AppResources.UsernameNameAlreadyTaken
static string UsernameNameAlreadyTaken
Looks up a localized string similar to Username already exists. Please try another....
Definition: AppResources.Designer.cs:10002

NeuroAccessMaui.Resources.Languages.AppResources.InvalidUsernameOrPassword
static string InvalidUsernameOrPassword
Looks up a localized string similar to Invalid username or password.
Definition: AppResources.Designer.cs:3945

NeuroAccessMaui.Resources.Languages.AppResources.NotificationPetitionContractTitle
static string NotificationPetitionContractTitle
Looks up a localized string similar to Contract request from {0}.
Definition: AppResources.Designer.cs:5187

NeuroAccessMaui.Resources.Languages.AppResources.ControlServiceNotFound
static string ControlServiceNotFound
Looks up a localized string similar to No control service found..
Definition: AppResources.Designer.cs:2415

NeuroAccessMaui.Resources.Languages.AppResources.NeuroFeaturesServiceNotFound
static string NeuroFeaturesServiceNotFound
Looks up a localized string similar to No Neuro-Features service found on the Service Provider....
Definition: AppResources.Designer.cs:4782

NeuroAccessMaui.Resources.Languages.AppResources.NotificationIdentityRejectedBody
static string NotificationIdentityRejectedBody
Looks up a localized string similar to Your identity was rejected..
Definition: AppResources.Designer.cs:5160

NeuroAccessMaui.Resources.Languages.AppResources.NotificationPetitionSignatureBody
static string NotificationPetitionSignatureBody
Looks up a localized string similar to A new signature request is waiting..
Definition: AppResources.Designer.cs:5214

NeuroAccessMaui.Resources.Languages.AppResources.NotificationReadAccessBody
static string NotificationReadAccessBody
Looks up a localized string similar to Requested read access..
Definition: AppResources.Designer.cs:5268

NeuroAccessMaui.Resources.Languages.AppResources.NotificationContractProposalTitle
static string NotificationContractProposalTitle
Looks up a localized string similar to Contract proposal.
Definition: AppResources.Designer.cs:5043

NeuroAccessMaui.Resources.Languages.AppResources.NotificationTokenRemovedBody
static string NotificationTokenRemovedBody
Looks up a localized string similar to Your wallet was updated..
Definition: AppResources.Designer.cs:5385

NeuroAccessMaui.Resources.Languages.AppResources.DomainIsNotAValidOperator
static string DomainIsNotAValidOperator
Looks up a localized string similar to {0} is not a valid operator.
Definition: AppResources.Designer.cs:2802

NeuroAccessMaui.Resources.Languages.AppResources.NotificationReadAccessTitle
static string NotificationReadAccessTitle
Looks up a localized string similar to Read access request from {0}.
Definition: AppResources.Designer.cs:5277

NeuroAccessMaui.Resources.Languages.AppResources.NotificationIdentityRejectedTitle
static string NotificationIdentityRejectedTitle
Looks up a localized string similar to Identity status updated.
Definition: AppResources.Designer.cs:5169

NeuroAccessMaui.Resources.Languages.AppResources.NotificationContractProposalBody
static string NotificationContractProposalBody
Looks up a localized string similar to A contract proposal is available..
Definition: AppResources.Designer.cs:5034

NeuroAccessMaui.Resources.Languages.AppResources.UnableToGetPresent
static string UnableToGetPresent
Looks up a localized string similar to Unable to get present report..
Definition: AppResources.Designer.cs:9795

NeuroAccessMaui.Resources.Languages.AppResources.NotificationIdentityCompromisedBody
static string NotificationIdentityCompromisedBody
Looks up a localized string similar to Your identity may be compromised..
Definition: AppResources.Designer.cs:5124

NeuroAccessMaui.Resources.Languages.AppResources.FileUploadServiceNotFound
static string FileUploadServiceNotFound
Looks up a localized string similar to No file upload service found on the Service Provider....
Definition: AppResources.Designer.cs:3252

NeuroAccessMaui.Resources.Languages.AppResources.PushNotificationServiceNotFound
static string PushNotificationServiceNotFound
Looks up a localized string similar to No push-notification service found..
Definition: AppResources.Designer.cs:7275

NeuroAccessMaui.Resources.Languages.AppResources.UnableToGetListOfMyDevices
static string UnableToGetListOfMyDevices
Looks up a localized string similar to Unable to get list of my devices..
Definition: AppResources.Designer.cs:9777

NeuroAccessMaui.Resources.Languages.AppResources.NotificationTokenRemovedTitle
static string NotificationTokenRemovedTitle
Looks up a localized string similar to Token removed.
Definition: AppResources.Designer.cs:5394

NeuroAccessMaui.Resources.Languages.AppResources.NotificationIdentityObsoletedBody
static string NotificationIdentityObsoletedBody
Looks up a localized string similar to Your identity has been obsoleted..
Definition: AppResources.Designer.cs:5142

NeuroAccessMaui.Resources.Languages.AppResources.PepServiceNotFound
static string PepServiceNotFound
Looks up a localized string similar to No personal eventing service found..
Definition: AppResources.Designer.cs:6663

NeuroAccessMaui.Resources.Languages.AppResources.ProvisioningServiceNotFound
static string ProvisioningServiceNotFound
Looks up a localized string similar to No provisioning service found on the Service Provider....
Definition: AppResources.Designer.cs:7221

NeuroAccessMaui.Resources.Languages.AppResources.NotificationBalanceUpdatedTitle
static string NotificationBalanceUpdatedTitle
Looks up a localized string similar to Balance updated.
Definition: AppResources.Designer.cs:4971

NeuroAccessMaui.Resources.Languages.AppResources.UnableToConnectTo
static string UnableToConnectTo
Looks up a localized string similar to Unable to connect to {0}.
Definition: AppResources.Designer.cs:9750

NeuroAccessMaui.Resources.Languages.AppResources.NotificationPetitionIdentityBody
static string NotificationPetitionIdentityBody
Looks up a localized string similar to A new identity request is waiting..
Definition: AppResources.Designer.cs:5196

NeuroAccessMaui.Resources.Languages.AppResources.NotificationIdentityApprovedBody
static string NotificationIdentityApprovedBody
Looks up a localized string similar to Your identity was approved..
Definition: AppResources.Designer.cs:5106

NeuroAccessMaui.Resources.Languages.AppResources.UnableToGetStateDiagram
static string UnableToGetStateDiagram
Looks up a localized string similar to Unable to get state diagram report..
Definition: AppResources.Designer.cs:9813

NeuroAccessMaui.Resources.Languages.AppResources.NotificationControlAccessBody
static string NotificationControlAccessBody
Looks up a localized string similar to Requested control access..
Definition: AppResources.Designer.cs:5088

NeuroAccessMaui.Resources.Languages.AppResources.NotificationContractUpdatedTitle
static string NotificationContractUpdatedTitle
Looks up a localized string similar to Contract updated.
Definition: AppResources.Designer.cs:5079

NeuroAccessMaui.Resources.Languages.AppResources.NotificationPetitionIdentityTitle
static string NotificationPetitionIdentityTitle
Looks up a localized string similar to Identity request from {0}.
Definition: AppResources.Designer.cs:5205

NeuroAccessMaui.Resources.Languages.AppResources.OperatorDoesNotSupportRegisteringNewAccounts
static string OperatorDoesNotSupportRegisteringNewAccounts
Looks up a localized string similar to The operator {0} does not support registration of new accounts...
Definition: AppResources.Designer.cs:5790

NeuroAccessMaui.Resources.Languages.AppResources.ThingRegistryServiceNotFound
static string ThingRegistryServiceNotFound
Looks up a localized string similar to No thing registry service found on the Service Provider....
Definition: AppResources.Designer.cs:9246

NeuroAccessMaui.Resources.Languages.AppResources.NotificationContractUpdatedBody
static string NotificationContractUpdatedBody
Looks up a localized string similar to A contract was updated..
Definition: AppResources.Designer.cs:5070

NeuroAccessMaui.Resources.Languages.AppResources.ConcentratorServiceNotFound
static string ConcentratorServiceNotFound
Looks up a localized string similar to No concentrator service found..
Definition: AppResources.Designer.cs:1965

NeuroAccessMaui.Resources.Languages.AppResources.NotificationContractSignedTitle
static string NotificationContractSignedTitle
Looks up a localized string similar to Contract signed.
Definition: AppResources.Designer.cs:5061

NeuroAccessMaui.Resources.Languages.AppResources.NotificationTokenAddedBody
static string NotificationTokenAddedBody
Looks up a localized string similar to Your wallet was updated..
Definition: AppResources.Designer.cs:5367

NeuroAccessMaui.Resources.Languages.AppResources.PubSubServiceNotFound
static string PubSubServiceNotFound
Looks up a localized string similar to Messaging service not available.
Definition: AppResources.Designer.cs:7239

NeuroAccessMaui.Resources.Languages.AppResources.NotificationBalanceUpdatedBody
static string NotificationBalanceUpdatedBody
Looks up a localized string similar to Your balance was updated..
Definition: AppResources.Designer.cs:4962

NeuroAccessMaui.Resources.Languages.AppResources.NotificationControlAccessTitle
static string NotificationControlAccessTitle
Looks up a localized string similar to Control request from {0}.
Definition: AppResources.Designer.cs:5097

NeuroAccessMaui.Resources.Languages.AppResources.NotificationIdentityApprovedTitle
static string NotificationIdentityApprovedTitle
Looks up a localized string similar to Identity status updated.
Definition: AppResources.Designer.cs:5115

NeuroAccessMaui.Resources.Languages.AppResources.LegalServiceNotFound
static string LegalServiceNotFound
Looks up a localized string similar to No legal service found on the Service Provider....
Definition: AppResources.Designer.cs:4377

NeuroAccessMaui.Resources.Languages.AppResources.NotificationChatTitle
static string NotificationChatTitle
Looks up a localized string similar to {0}.
Definition: AppResources.Designer.cs:4989

NeuroAccessMaui.Resources.Languages.AppResources.NotificationIdentityCompromisedTitle
static string NotificationIdentityCompromisedTitle
Looks up a localized string similar to Identity status updated.
Definition: AppResources.Designer.cs:5133

NeuroAccessMaui.Resources.Languages.AppResources.NotificationTokenAddedTitle
static string NotificationTokenAddedTitle
Looks up a localized string similar to Token added.
Definition: AppResources.Designer.cs:5376

NeuroAccessMaui.Resources.Languages.AppResources.Ok
static string Ok
Looks up a localized string similar to OK.
Definition: AppResources.Designer.cs:5493

NeuroAccessMaui.Resources.Languages.AppResources.UnableToGetProfiling
static string UnableToGetProfiling
Looks up a localized string similar to Unable to get profiling report..
Definition: AppResources.Designer.cs:9804

NeuroAccessMaui.Resources.Languages.AppResources.NotificationChatBody
static string NotificationChatBody
Looks up a localized string similar to Has sent you a message..
Definition: AppResources.Designer.cs:4980

NeuroAccessMaui.Resources.Languages.AppResources.UnableToAuthenticateWith
static string UnableToAuthenticateWith
Looks up a localized string similar to Unable to authenticate with {0}.
Definition: AppResources.Designer.cs:9714

NeuroAccessMaui.Resources.Languages.AppResources.SomethingWentWrong
static string SomethingWentWrong
Looks up a localized string similar to Something went wrong.
Definition: AppResources.Designer.cs:8841

NeuroAccessMaui.Resources.Languages.AppResources.NotificationPresenceAccessBody
static string NotificationPresenceAccessBody
Looks up a localized string similar to Requested access to your identity..
Definition: AppResources.Designer.cs:5250

NeuroAccessMaui.Resources.Languages.AppResources.EDalerServiceNotFound
static string EDalerServiceNotFound
Looks up a localized string similar to No eDaler service found on the Service Provider....
Definition: AppResources.Designer.cs:2865

NeuroAccessMaui.Resources.Languages.AppResources.NotificationPetitionSignatureTitle
static string NotificationPetitionSignatureTitle
Looks up a localized string similar to Signature request from {0}.
Definition: AppResources.Designer.cs:5223

NeuroAccessMaui.Resources.Languages.AppResources.UnableToGetHistory
static string UnableToGetHistory
Looks up a localized string similar to Unable to get history report..
Definition: AppResources.Designer.cs:9768

NeuroAccessMaui.Resources.Languages.AppResources.NotificationPetitionContractBody
static string NotificationPetitionContractBody
Looks up a localized string similar to A new contract request is waiting..
Definition: AppResources.Designer.cs:5178

NeuroAccessMaui.Resources.Languages.AppResources.SensorServiceNotFound
static string SensorServiceNotFound
Looks up a localized string similar to No sensor service found..
Definition: AppResources.Designer.cs:8508

NeuroAccessMaui.Resources.Languages.AppResources.DomainDoesNotFollowEncryptionPolicy
static string DomainDoesNotFollowEncryptionPolicy
Looks up a localized string similar to {0} does not follow the ubiquitous encryption policy.
Definition: AppResources.Designer.cs:2793

NeuroAccessMaui.Resources.Languages.AppResources.NotificationPresenceAccessTitle
static string NotificationPresenceAccessTitle
Looks up a localized string similar to Access request from {0}.
Definition: AppResources.Designer.cs:5259

NeuroAccessMaui.Resources.Languages.AppResources.UnableToConnect
static string UnableToConnect
Looks up a localized string similar to Unable to connect..
Definition: AppResources.Designer.cs:9741

NeuroAccessMaui.Resources.Languages.AppResources.NotificationIdentityObsoletedTitle
static string NotificationIdentityObsoletedTitle
Looks up a localized string similar to Identity status updated.
Definition: AppResources.Designer.cs:5151

NeuroAccessMaui.Resources.Languages.AppResources.ErrorTitle
static string ErrorTitle
Looks up a localized string similar to An error has occurred.
Definition: AppResources.Designer.cs:3063

NeuroAccessMaui.Resources.Languages.AppResources.NotificationContractSignedBody
static string NotificationContractSignedBody
Looks up a localized string similar to A contract was signed..
Definition: AppResources.Designer.cs:5052

NeuroAccessMaui.Resources.Languages.AppResources.CantConnectTo
static string CantConnectTo
Looks up a localized string similar to Can't connect to {0}.
Definition: AppResources.Designer.cs:1074

NeuroAccessMaui.Resources.Languages.AppResources.InvalidIoTDiscoClaimUri
static string InvalidIoTDiscoClaimUri
Looks up a localized string similar to Not a valid iotdisco claim URI..
Definition: AppResources.Designer.cs:3900

NeuroAccessMaui.Services.Contacts.ContactInfo
Contains information about a contact.
Definition: ContactInfo.cs:22

NeuroAccessMaui.Services.Contacts.ContactInfo.FriendlyName
string FriendlyName
Friendly name.
Definition: ContactInfo.cs:92

NeuroAccessMaui.Services.Contacts.ContactInfo.GetFriendlyName
static async Task< string > GetFriendlyName(CaseInsensitiveString RemoteId)
Gets the friendly name of a remote identity (Legal ID or Bare JID).
Definition: ContactInfo.cs:258

NeuroAccessMaui.Services.Contacts.ContactInfo.FindByLegalId
static async Task< ContactInfo?> FindByLegalId(string LegalId)
Finds information about a contact, given its Legal ID.
Definition: ContactInfo.cs:248

NeuroAccessMaui.Services.Contacts.ContactInfo.LegalIdentity
LegalIdentity? LegalIdentity
Legal Identity object.
Definition: ContactInfo.cs:82

NeuroAccessMaui.Services.Contacts.ContactInfo.AllowSubscriptionFrom
bool? AllowSubscriptionFrom
Allow subscriptions from this contact
Definition: ContactInfo.cs:146

NeuroAccessMaui.Services.Contacts.ContactInfo.FindByBareJid
static Task< ContactInfo > FindByBareJid(string BareJid)
Finds information about a contact, given its Bare JID.
Definition: ContactInfo.cs:221

NeuroAccessMaui.Services.Contacts.ContactInfo.LegalId
CaseInsensitiveString LegalId
Legal ID of contact.
Definition: ContactInfo.cs:72

NeuroAccessMaui.Services.Contracts.ContractReference
Contains a local reference to a contract that the user has created or signed.
Definition: ContractReference.cs:18

NeuroAccessMaui.Services.Contracts.ContractReference.SetContract
async Task SetContract(Contract Contract)
Sets a parsed contract.
Definition: ContractReference.cs:116

NeuroAccessMaui.Services.Identity.ApplicationReviewClaimDetail
Contains additional data about an invalid claim.
Definition: ApplicationReview.cs:60

NeuroAccessMaui.Services.Identity.ApplicationReview
Captures the result of an application review returned from backend services.
Definition: ApplicationReview.cs:9

NeuroAccessMaui.Services.Identity.ApplicationReview.Code
string? Code
Optional machine readable code identifying the review reason.
Definition: ApplicationReview.cs:18

NeuroAccessMaui.Services.Identity.ApplicationReview.Message
string Message
The localized or raw message describing the review result.
Definition: ApplicationReview.cs:13

NeuroAccessMaui.Services.Identity.ApplicationReviewPhotoDetail
Contains additional data about an invalid photo.
Definition: ApplicationReview.cs:121

NeuroAccessMaui.Services.Kyc.KycReference
Contains a local reference to a KYC process.
Definition: KycReference.cs:22

NeuroAccessMaui.Services.Kyc.KycReference.CreatedIdentityId
string? CreatedIdentityId
The legal ID of the created identity (if any).
Definition: KycReference.cs:75

NeuroAccessMaui.Services.LegalIdentityAttachment
Represent an attachment to a LegalIdentity.
Definition: LegalIdentityAttachment.cs:10

NeuroAccessMaui.Services.LoadableService
Definition: LoadableService.cs:7

NeuroAccessMaui.Services.LoadableService.IsUnloading
bool IsUnloading
Gets whether the service is being unloaded.
Definition: LoadableService.cs:23

NeuroAccessMaui.Services.LoadableService.BeginLoad
bool BeginLoad(bool IsResuming, CancellationToken CancellationToken)
Sets the IsLoading flag if the service isn't already loading.
Definition: LoadableService.cs:36

NeuroAccessMaui.Services.LoadableService.EndLoad
void EndLoad(bool isLoaded)
Sets the IsLoading and IsLoaded flags and fires an event representing the current load state of the s...
Definition: LoadableService.cs:59

NeuroAccessMaui.Services.LoadableService.IsResuming
bool IsResuming
If App is resuming service.
Definition: LoadableService.cs:28

NeuroAccessMaui.Services.LoadableService.BeginUnload
bool BeginUnload()
Sets the IsLoading flag if the service isn't already unloading.
Definition: LoadableService.cs:73

NeuroAccessMaui.Services.LoadableService.EndUnload
void EndUnload()
Sets the IsLoading and IsLoaded flags and fires an event representing the current load state of the s...
Definition: LoadableService.cs:92

NeuroAccessMaui.Services.LoadableService.IsLoaded
bool IsLoaded
Gets whether the service is loaded.
Definition: LoadableService.cs:13

NeuroAccessMaui.Services.Notification.NotificationFilterDecision
Represents a filter decision for notification handling.
Definition: NotificationFilterDecision.cs:7

NeuroAccessMaui.Services.Notification.NotificationFilterDecision.None
static NotificationFilterDecision None
Gets a decision that does not ignore any operation.
Definition: NotificationFilterDecision.cs:11

NeuroAccessMaui.Services.Notification.NotificationIntent
Platform-neutral intent describing how to route a notification.
Definition: NotificationIntent.cs:9

NeuroAccessMaui.Services.Notification.NotificationIntent.EntityId
string? EntityId
Gets or sets an entity identifier associated with the action.
Definition: NotificationIntent.cs:28

NeuroAccessMaui.Services.Notification.NotificationIntent.Channel
string? Channel
Gets or sets the push channel identifier.
Definition: NotificationIntent.cs:33

NeuroAccessMaui.Services.Notification.NotificationIntent.Extras
Dictionary< string, string > Extras
Gets or sets extra data used for routing.
Definition: NotificationIntent.cs:43

NeuroAccessMaui.Services.Notification.NotificationService
Notification service
Definition: NotificationService.cs:14

NeuroAccessMaui.Services.Push.TokenInformation
Contains information about a push notification token.
Definition: TokenInformation.cs:9

NeuroAccessMaui.Services.Push.TokenInformation.ClientType
ClientType ClientType
Type of client
Definition: TokenInformation.cs:23

NeuroAccessMaui.Services.Push.TokenInformation.Service
PushMessagingService Service
Service issuing the token
Definition: TokenInformation.cs:18

NeuroAccessMaui.Services.Push.TokenInformation.Token
string? Token
Token string
Definition: TokenInformation.cs:13

NeuroAccessMaui.Services.ServiceRef
Base class that references services in the app.
Definition: ServiceRef.cs:43

NeuroAccessMaui.Services.ServiceRef.Provider
static IServiceProvider Provider
The service provider for the app. This is set before the app is started, and will be used to resolve ...
Definition: ServiceRef.cs:48

NeuroAccessMaui.Services.ServiceRef.LogService
static ILogService LogService
Log service.
Definition: ServiceRef.cs:214

NeuroAccessMaui.Services.ServiceRef.NetworkService
static INetworkService NetworkService
Network service.
Definition: ServiceRef.cs:226

NeuroAccessMaui.Services.ServiceRef.UiService
static IUiService UiService
Service serializing and managing UI-related tasks.
Definition: ServiceRef.cs:130

NeuroAccessMaui.Services.ServiceRef.NavigationService
static INavigationService NavigationService
The navigation service for navigating between pages.
Definition: ServiceRef.cs:178

NeuroAccessMaui.Services.ServiceRef.PopupService
static IPopupService PopupService
Popup service for presenting application popups.
Definition: ServiceRef.cs:142

NeuroAccessMaui.Services.ServiceRef.TagProfile
static ITagProfile TagProfile
TAG Profile service.
Definition: ServiceRef.cs:202

NeuroAccessMaui.Services.ServiceRef.CryptoService
static ICryptoService CryptoService
Crypto service.
Definition: ServiceRef.cs:286

NeuroAccessMaui.Services.ServiceRef.Localizer
static IReportingStringLocalizer Localizer
Localization service
Definition: ServiceRef.cs:370

NeuroAccessMaui.Services.ServiceRef.XmppService
static IXmppService XmppService
The XMPP service for XMPP communication.
Definition: ServiceRef.cs:190

NeuroAccessMaui.UI.Pages.Applications.Applications.ApplicationsPage
Main applications page.
Definition: ApplicationsPage.xaml.cs:7

NeuroAccessMaui.UI.Pages.Applications.Applications.ApplicationsViewModel
The view model to bind to for when displaying the applications page.
Definition: ApplicationsViewModel.cs:48

NeuroAccessMaui.UI.Pages.Contacts.Chat.ChatMessage
Chat Messages
Definition: ChatMessage.cs:33

NeuroAccessMaui.UI.Pages.Contacts.Chat.ChatMessage.Created
DateTime Created
When message was created
Definition: ChatMessage.cs:90

NeuroAccessMaui.UI.Pages.Contacts.Chat.ChatMessage.Html
string Html
HTML of message
Definition: ChatMessage.cs:145

NeuroAccessMaui.UI.Pages.Contacts.Chat.ChatMessage.PlainText
string PlainText
Plain text of message
Definition: ChatMessage.cs:127

NeuroAccessMaui.UI.Pages.Contacts.Chat.ChatMessage.Markdown
string Markdown
Markdown of message
Definition: ChatMessage.cs:136

NeuroAccessMaui.UI.Pages.Contacts.Chat.ChatPage
A page that displays a list of the current user's contacts.
Definition: ChatPage.xaml.cs:10

NeuroAccessMaui.UI.Pages.Contacts.Chat.ChatViewModel
The view model to bind to when displaying the list of contacts.
Definition: ChatViewModel.cs:47

NeuroAccessMaui.UI.Pages.Contacts.Chat.ChatViewModel.MessageAddedAsync
async Task MessageAddedAsync(ChatMessage Message)
External message has been received
Definition: ChatViewModel.cs:311

NeuroAccessMaui.UI.Pages.Contacts.Chat.ChatViewModel.MessageUpdatedAsync
async Task MessageUpdatedAsync(ChatMessage Message)
External message has been updated
Definition: ChatViewModel.cs:456

NeuroAccessMaui.UI.Pages.Kyc.KycProcessPage
Definition: KycProcessPage.xaml.cs:10

NeuroAccessMaui.UI.Pages.Kyc.KycProcessViewModel
Orchestrates the interactive KYC flow, covering navigation, validation, summary projection,...
Definition: KycProcessViewModel.cs:42

NeuroAccessMaui.UI.Pages.Onboarding.OnboardingNavigationArgs
Navigation arguments for onboarding flow. Scenario determines dynamic starting step.
Definition: OnboardingNavigationArgs.cs:9

NeuroAccessMaui.UI.Pages.Onboarding.OnboardingPage
Definition: OnboardingPage.xaml.cs:7

NeuroAccessMaui.UI.Pages.Onboarding.RegisterIdentityModel
The data model for registering an identity.
Definition: RegisterIdentityModel.cs:19

NeuroAccessMaui.UI.Pages.Onboarding.RegisterIdentityModel.ToProperties
Property[] ToProperties(IXmppService XmppService)
Converts the RegisterIdentityModel to an array of .
Definition: RegisterIdentityModel.cs:728

NeuroAccessMaui.UI.Popups.Xmpp.ReportOrBlock.ReportOrBlockPopup
Prompts the user for a response of a presence subscription request.
Definition: ReportOrBlockPopup.cs:9

NeuroAccessMaui.UI.Popups.Xmpp.ReportOrBlock.ReportOrBlockViewModel
View model for ReportOrBlockPopup
Definition: ReportOrBlockViewModel.cs:33

NeuroAccessMaui.UI.Popups.Xmpp.ReportOrBlock.ReportOrBlockViewModel.Result
Task< ReportOrBlockAction > Result
Result will be provided here.
Definition: ReportOrBlockViewModel.cs:49

NeuroAccessMaui.UI.Popups.Xmpp.ReportType.ReportTypePopup
Prompts the user for a response of a presence subscription request.
Definition: ReportTypePopup.cs:9

NeuroAccessMaui.UI.Popups.Xmpp.ReportType.ReportTypeViewModel
View model for ReportTypePopup
Definition: ReportTypeViewModel.cs:13

NeuroAccessMaui.UI.Popups.Xmpp.ReportType.ReportTypeViewModel.Result
Task< ReportingReason?> Result
Result will be provided here.
Definition: ReportTypeViewModel.cs:29

NeuroAccessMaui.UI.Popups.Xmpp.SubscribeTo.SubscribeToPopup
Asks the user if it wants to remove an existing presence subscription request as well.
Definition: SubscribeToPopup.cs:9

NeuroAccessMaui.UI.Popups.Xmpp.SubscribeTo.SubscribeToViewModel
View model for SubscribeToPopup
Definition: SubscribeToViewModel.cs:12

NeuroAccessMaui.UI.Popups.Xmpp.SubscribeTo.SubscribeToViewModel.Result
Task< bool?> Result
Result will be provided here. If dialog is cancelled, null is returned.
Definition: SubscribeToViewModel.cs:34

NeuroAccessMaui.UI.Popups.Xmpp.SubscriptionRequest.SubscriptionRequestPopup
Prompts the user for a response of a presence subscription request.
Definition: SubscriptionRequestPopup.cs:9

NeuroAccessMaui.UI.Popups.Xmpp.SubscriptionRequest.SubscriptionRequestViewModel
View model for SubscriptionRequestPopup
Definition: SubscriptionRequestViewModel.cs:33

NeuroAccessMaui.UI.Popups.Xmpp.SubscriptionRequest.SubscriptionRequestViewModel.Result
Task< PresenceRequestAction > Result
Result will be provided here.
Definition: SubscriptionRequestViewModel.cs:124

NeuroFeatures.EventArguments.NewStateEventArgs
Event arguments events when the current state of a state-machine has changed.
Definition: NewStateEventArgs.cs:9

NeuroFeatures.EventArguments.ReportEventArgs
Event arguments for report callback methods.
Definition: ReportEventArgs.cs:9

NeuroFeatures.EventArguments.ReportEventArgs.ReportText
string ReportText
Markdown report.
Definition: ReportEventArgs.cs:24

NeuroFeatures.EventArguments.TokenEventArgs
Event arguments for token events.
Definition: TokenEventArgs.cs:9

NeuroFeatures.EventArguments.VariablesUpdatedEventArgs
Event arguments events when the variables of a state-machine has changed.
Definition: VariablesUpdatedEventArgs.cs:10

NeuroFeatures.Events.Created
Event raised when a token has been created.
Definition: Created.cs:10

NeuroFeatures.NeuroFeaturesClient
eDaler XMPP client.
Definition: NeuroFeaturesClient.cs:23

NeuroFeatures.NeuroFeaturesClient.GenerateHistoryReportAsync
async Task< ReportEventArgs > GenerateHistoryReportAsync(string TokenId, ReportFormat Format)
Generates a history report of a state-machine belonging to a token.
Definition: NeuroFeaturesClient.cs:1635

NeuroFeatures.NeuroFeaturesClient.GetTokensAsync
Task< TokensEventArgs > GetTokensAsync()
Get tokens the account owns.
Definition: NeuroFeaturesClient.cs:441

NeuroFeatures.NeuroFeaturesClient.GetContractTokensAsync
Task< TokensEventArgs > GetContractTokensAsync(string ContractId)
Get tokens created by a contract the account has access to.
Definition: NeuroFeaturesClient.cs:720

NeuroFeatures.NeuroFeaturesClient.GetContractTokenReferencesAsync
Task< string[]> GetContractTokenReferencesAsync(string ContractId)
Get references to tokens created by a contract the account has access to.
Definition: NeuroFeaturesClient.cs:576

NeuroFeatures.NeuroFeaturesClient.Dispose
override void Dispose()
IDisposable.Dispose
Definition: NeuroFeaturesClient.cs:71

NeuroFeatures.NeuroFeaturesClient.GeneratePresentReportAsync
async Task< ReportEventArgs > GeneratePresentReportAsync(string TokenId, ReportFormat Format)
Generates a present report of a state-machine belonging to a token.
Definition: NeuroFeaturesClient.cs:1585

NeuroFeatures.NeuroFeaturesClient.GetCurrentStateAsync
async Task< CurrentStateEventArgs > GetCurrentStateAsync(string TokenId)
Gets the current state of a state-machine belonging to a token.
Definition: NeuroFeaturesClient.cs:1485

NeuroFeatures.NeuroFeaturesClient.GetCreationAttributesAsync
async Task< CreationAttributesEventArgs > GetCreationAttributesAsync()
Gets attributes relevant for creating tokens on the broker.
Definition: NeuroFeaturesClient.cs:1197

NeuroFeatures.NeuroFeaturesClient.GenerateProfilingReportAsync
async Task< ReportEventArgs > GenerateProfilingReportAsync(string TokenId, ReportFormat Format)
Generates a profiling report of a state-machine belonging to a token.
Definition: NeuroFeaturesClient.cs:1535

NeuroFeatures.NeuroFeaturesClient.AddTextNoteAsync
Task AddTextNoteAsync(string TokenId, string Note)
Adds a text note to a token. Notes attached to a token can be retrieved by calling GetEvents.
Definition: NeuroFeaturesClient.cs:958

NeuroFeatures.NeuroFeaturesClient.NamespaceNeuroFeatures
const string NamespaceNeuroFeatures
Namespace for Neuro-Features.
Definition: NeuroFeaturesClient.cs:27

NeuroFeatures.NeuroFeaturesClient.GetTotalsAsync
Task< TokenTotalsEventArgs > GetTotalsAsync()
Get totals of tokens the sender owns.
Definition: NeuroFeaturesClient.cs:886

NeuroFeatures.NeuroFeaturesClient.GetTokenReferencesAsync
Task< string[]> GetTokenReferencesAsync()
Get references to tokens the account owns.
Definition: NeuroFeaturesClient.cs:273

NeuroFeatures.NeuroFeaturesClient.GetEventsAsync
Task< TokenEvent[]> GetEventsAsync(string TokenId)
Get events registered for a token the account owns.
Definition: NeuroFeaturesClient.cs:1148

NeuroFeatures.NeuroFeaturesClient.GenerateStateDiagramAsync
async Task< ReportEventArgs > GenerateStateDiagramAsync(string TokenId, ReportFormat Format)
Generates a state diagram of a state-machine belonging to a token.
Definition: NeuroFeaturesClient.cs:1685

NeuroFeatures.NeuroFeaturesClient.GetTokenAsync
async Task< Token > GetTokenAsync(string TokenId)
Gets a token, given its full ID.
Definition: NeuroFeaturesClient.cs:152

NeuroFeatures.NeuroFeaturesClient.AddXmlNoteAsync
Task AddXmlNoteAsync(string TokenId, string Note)
Adds a xml note to a token. Notes attached to a token can be retrieved by calling GetEvents.
Definition: NeuroFeaturesClient.cs:1038

NeuroFeatures.Token
Neuro-Feature Token
Definition: Token.cs:46

Waher.Content.CommonTypes
Helps with parsing of commong data types.
Definition: CommonTypes.cs:15

Waher.Content.CommonTypes.CRLF
static readonly char[] CRLF
Contains the CR LF character sequence.
Definition: CommonTypes.cs:19

Waher.Content.ContentResponse
Contains information about a response to a content request.
Definition: ContentResponse.cs:11

Waher.Content.ContentResponse.Decoded
object Decoded
Decoded object.
Definition: ContentResponse.cs:54

Waher.Content.ContentResponse.AssertOk
void AssertOk()
Asserts response is OK.
Definition: ContentResponse.cs:102

Waher.Content.Html.HtmlDocument
HTML document.
Definition: HtmlDocument.cs:15

Waher.Content.Html.HtmlDocument.GetBody
static string GetBody(string Html)
Extracts the contents of the BODY element in a HTML string.
Definition: HtmlDocument.cs:2059

Waher.Content.InternetContent
Static class managing encoding and decoding of internet content.
Definition: InternetContent.cs:19

Waher.Content.InternetContent.PostAsync
static Task< ContentResponse > PostAsync(Uri Uri, object Data, params KeyValuePair< string, string >[] Headers)
Posts to a resource, using a Uniform Resource Identifier (or Locator).
Definition: InternetContent.cs:1641

Waher.Content.JSON
Helps with common JSON-related tasks.
Definition: JSON.cs:16

Waher.Content.JSON.UnixEpoch
static readonly DateTime UnixEpoch
Unix Date and Time epoch, starting at 1970-01-01T00:00:00Z
Definition: JSON.cs:20

Waher.Content.Markdown.MarkdownDocument
Contains a markdown document. This markdown document class supports original markdown,...
Definition: MarkdownDocument.cs:52

Waher.Content.Markdown.MarkdownDocument.GeneratePlainText
async Task< string > GeneratePlainText()
Generates Plain Text from the markdown text.
Definition: MarkdownDocument.cs:5633

Waher.Content.Markdown.MarkdownDocument.GenerateHTML
async Task< string > GenerateHTML()
Generates HTML from the markdown text.
Definition: MarkdownDocument.cs:5588

Waher.Content.Markdown.MarkdownDocument.CreateAsync
static Task< MarkdownDocument > CreateAsync(string MarkdownText, params Type[] TransparentExceptionTypes)
Contains a markdown document. This markdown document class supports original markdown,...
Definition: MarkdownDocument.cs:92

Waher.Content.Markdown.MarkdownSettings
Contains settings that the Markdown parser uses to customize its behavior.
Definition: MarkdownSettings.cs:22

Waher.Content.Xml.XML
Helps with common XML-related tasks.
Definition: XML.cs:21

Waher.Content.Xml.XML.Attribute
static string Attribute(XmlElement E, string Name)
Gets the value of an XML attribute.
Definition: XML.cs:1062

Waher.Content.Xml.XML.Encode
static string Encode(string s)
Encodes a string for use in XML.
Definition: XML.cs:29

Waher.Content.Xml.XML.TryParse
static bool TryParse(string s, out DateTime Value)
Tries to decode a string encoded DateTime.
Definition: XML.cs:892

Waher.Events.Event
Class representing an event.
Definition: Event.cs:11

Waher.Events.Filter.EventFilter
Filters incoming events and passes remaining events to a secondary event sink.
Definition: EventFilter.cs:11

Waher.Events.Filter.EventFilter.SecondarySink
IEventSink SecondarySink
Secondary event sink receiving the events passing the filter.
Definition: EventFilter.cs:243

Waher.Events.Log
Static class managing the application event log. Applications and services log events on this static ...
Definition: Log.cs:14

Waher.Events.Log.Register
static void Register(IEventSink EventSink)
Registers an event sink with the event log. Call Unregister(IEventSink) to unregister it,...
Definition: Log.cs:30

Waher.Events.Log.Warning
static void Warning(string Message, string Object, string Actor, string EventId, EventLevel Level, string Facility, string Module, string StackTrace, params KeyValuePair< string, object >[] Tags)
Logs a warning event.
Definition: Log.cs:576

Waher.Events.Log.UnnestException
static Exception UnnestException(Exception Exception)
Unnests an exception, to extract the relevant inner exception.
Definition: Log.cs:828

Waher.Events.Log.Unregister
static bool Unregister(IEventSink EventSink)
Unregisters an event sink from the event log.
Definition: Log.cs:47

Waher.Events.LogObject.Dispose
void Dispose()
IDisposable.Dispose()
Definition: LogObject.cs:1136

Waher.Events.LogObject.DisposeAsync
virtual Task DisposeAsync()
IDisposableAsync.DisposeAsync()
Definition: LogObject.cs:1144

Waher.Events.XMPP.XmppEventSink
Event sink sending events to a destination over the XMPP network.
Definition: XmppEventSink.cs:20

Waher.Events.XMPP.XmppEventSink.NamespaceEventLogging
const string NamespaceEventLogging
urn:xmpp:eventlog
Definition: XmppEventSink.cs:24

Waher.Networking.Sniffers.DebugSniffer
Outputs sniffed data to Debug.
Definition: DebugSniffer.cs:10

Waher.Networking.Sniffers.InMemorySniffer
Sniffer that stores events in memory.
Definition: InMemorySniffer.cs:15

Waher.Networking.Sniffers.SnifferBase.Warning
void Warning(string Warning)
Called to inform the viewer of a warning state.
Definition: SnifferBase.cs:324

Waher.Networking.Sniffers.SnifferBase.Error
void Error(string Error)
Called to inform the viewer of an error state.
Definition: SnifferBase.cs:343

Waher.Networking.Sniffers.SnifferBase.TransmitText
void TransmitText(string Text)
Called when text has been transmitted.
Definition: SnifferBase.cs:286

Waher.Networking.Sniffers.SnifferBase.Information
void Information(string Comment)
Called to inform the viewer of something.
Definition: SnifferBase.cs:305

Waher.Networking.Sniffers.SnifferBase.ReceiveText
void ReceiveText(string Text)
Called when text has been received.
Definition: SnifferBase.cs:267

Waher.Networking.XMPP.Abuse.AbuseClient
Class implementing blocking (XEP-0191) and spam reporting (XEP-0377).
Definition: AbuseClient.cs:37

Waher.Networking.XMPP.Abuse.AbuseClient.Dispose
override void Dispose()
IDisposable.Dispose
Definition: AbuseClient.cs:118

Waher.Networking.XMPP.Abuse.AbuseClient.BlockJID
async Task BlockJID(string JID, ReportingReason Reason, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Blocks a JID
Definition: AbuseClient.cs:303

Waher.Networking.XMPP.AuthenticationErrors.NotAuthorizedException
The authentication failed because the initiating entity did not provide proper credentials,...
Definition: NotAuthorizedException.cs:11

Waher.Networking.XMPP.Concentrator.ConcentratorClient
Implements an XMPP concentrator client interface.
Definition: ConcentratorClient.cs:28

Waher.Networking.XMPP.Concentrator.ConcentratorClient.Dispose
override void Dispose()
Disposes of the extension.
Definition: ConcentratorClient.cs:72

Waher.Networking.XMPP.Concentrator.ConcentratorServer
Implements an XMPP concentrator server interface.
Definition: ConcentratorServer.cs:42

Waher.Networking.XMPP.Concentrator.ConcentratorServer.NamespaceConcentratorCurrent
const string NamespaceConcentratorCurrent
Neuro-Foundation v1 namespace
Definition: ConcentratorServer.cs:56

Waher.Networking.XMPP.Concentrator.Parameters
Static class managing editable parameters in objects. Editable parameters are defined by using the at...
Definition: Parameters.cs:26

Waher.Networking.XMPP.Contracts.Attachment
Contains a reference to an attachment assigned to a legal object.
Definition: Attachment.cs:10

Waher.Networking.XMPP.Contracts.Attachment.FileName
string FileName
Filename of attachment.
Definition: Attachment.cs:57

Waher.Networking.XMPP.Contracts.Attachment.ContentType
string ContentType
Internet Content Type of binary attachment.
Definition: Attachment.cs:48

Waher.Networking.XMPP.Contracts.Contract
Contains the definition of a contract
Definition: Contract.cs:22

Waher.Networking.XMPP.Contracts.Contract.ForMachinesLocalName
string ForMachinesLocalName
Local name used by the root node of the machine-readable contents of the contract (ForMachines).
Definition: Contract.cs:294

Waher.Networking.XMPP.Contracts.Contract.ContractId
string ContractId
Contract identity
Definition: Contract.cs:65

Waher.Networking.XMPP.Contracts.Contract.ForMachinesNamespace
string ForMachinesNamespace
Namespace used by the root node of the machine-readable contents of the contract (ForMachines).
Definition: Contract.cs:289

Waher.Networking.XMPP.Contracts.ContractsClient
Adds support for legal identities, smart contracts and signatures to an XMPP client.
Definition: ContractsClient.cs:51

Waher.Networking.XMPP.Contracts.ContractsClient.ImportKeys
Task< bool > ImportKeys(string Xml)
Imports keys
Definition: ContractsClient.cs:1194

Waher.Networking.XMPP.Contracts.ContractsClient.GenerateNewKeys
async Task GenerateNewKeys()
Generates new keys for the contracts clients.
Definition: ContractsClient.cs:649

Waher.Networking.XMPP.Contracts.ContractsClient.ApplyAsync
Task< LegalIdentity > ApplyAsync(Property[] Properties)
Applies for a legal identity to be registered.
Definition: ContractsClient.cs:2063

Waher.Networking.XMPP.Contracts.ContractsClient.SelectPeerReviewServiceAsync
Task SelectPeerReviewServiceAsync(string Provider, string ServiceId)
Selects a service provider for peer review. This needs to be done before requesting the trust provide...
Definition: ContractsClient.cs:9646

Waher.Networking.XMPP.Contracts.ContractsClient.PetitionIdentityResponseAsync
Task PetitionIdentityResponseAsync(string LegalId, string PetitionId, string RequestorFullJid, bool Response)
Sends a response to a petition for information about a legal identity. When a petition is received,...
Definition: ContractsClient.cs:7392

Waher.Networking.XMPP.Contracts.ContractsClient.ValidateSignature
bool? ValidateSignature(LegalIdentity Identity, byte[] Data, byte[] Signature)
Validates a signature of binary data.
Definition: ContractsClient.cs:2659

Waher.Networking.XMPP.Contracts.ContractsClient.GetAttachmentAsync
Task< KeyValuePair< string, TemporaryFile > > GetAttachmentAsync(string Url, SignWith SignWith)
Gets an attachment from a Trust Provider
Definition: ContractsClient.cs:8732

Waher.Networking.XMPP.Contracts.ContractsClient.ObsoleteLegalIdentityAsync
Task< LegalIdentity > ObsoleteLegalIdentityAsync(string LegalIdentityId)
Obsoletes one of the legal identities of the account, given its ID.
Definition: ContractsClient.cs:3243

Waher.Networking.XMPP.Contracts.ContractsClient.SendContractProposal
Task SendContractProposal(Contract Contract, string Role, string To)
Sends a contract proposal to a recipient. If the contract contains encrypted parameters,...
Definition: ContractsClient.cs:6315

Waher.Networking.XMPP.Contracts.ContractsClient.GetPeerReviewIdServiceProvidersAsync
Task< ServiceProviderWithLegalId[]> GetPeerReviewIdServiceProvidersAsync()
Gets available service providers who can help review an ID application.
Definition: ContractsClient.cs:9567

Waher.Networking.XMPP.Contracts.ContractsClient.PetitionIdentityAsync
Task PetitionIdentityAsync(string LegalId, string PetitionId, string Purpose)
Sends a petition to the owner of a legal identity, to access the information in the identity....
Definition: ContractsClient.cs:7218

Waher.Networking.XMPP.Contracts.ContractsClient.GetIdApplicationAttributesAsync
async Task< IdApplicationAttributesEventArgs > GetIdApplicationAttributesAsync()
Gets attributes relevant for application for legal identities on the broker.
Definition: ContractsClient.cs:1922

Waher.Networking.XMPP.Contracts.ContractsClient.LoadKeys
Task< bool > LoadKeys(bool CreateIfNone)
Loads keys from the underlying persistence layer.
Definition: ContractsClient.cs:438

Waher.Networking.XMPP.Contracts.ContractsClient.GetLegalIdentityAsync
Task< LegalIdentity > GetLegalIdentityAsync(string LegalIdentityId)
Gets legal identity registered with the account.
Definition: ContractsClient.cs:3165

Waher.Networking.XMPP.Contracts.ContractsClient.AuthorizeAccessToIdAsync
Task AuthorizeAccessToIdAsync(string LegalId, string RemoteId, bool Authorized)
Authorizes access to (or revokes access to) a Legal ID of the caller.
Definition: ContractsClient.cs:9329

Waher.Networking.XMPP.Contracts.ContractsClient.PetitionSignatureResponseAsync
Task PetitionSignatureResponseAsync(string LegalId, byte[] Content, byte[] Signature, string PetitionId, string RequestorFullJid, bool Response)
Sends a response to a petition for a signature by the client. When a petition is received,...
Definition: ContractsClient.cs:7827

Waher.Networking.XMPP.Contracts.ContractsClient.HasPrivateKey
Task< bool > HasPrivateKey(LegalIdentity Identity)
Checks if the private key of a legal identity is available. Private keys are required to be able to s...
Definition: ContractsClient.cs:2819

Waher.Networking.XMPP.Contracts.ContractsClient.PetitionContractAsync
Task PetitionContractAsync(string ContractId, string PetitionId, string Purpose)
Sends a petition to the parts of a smart contract, to access the information in the contract....
Definition: ContractsClient.cs:8212

Waher.Networking.XMPP.Contracts.ContractsClient.CompromisedLegalIdentityAsync
Task< LegalIdentity > CompromisedLegalIdentityAsync(string LegalIdentityId)
Reports as Compromised one of the legal identities of the account, given its ID.
Definition: ContractsClient.cs:3321

Waher.Networking.XMPP.Contracts.ContractsClient.GetContractAsync
Task< Contract > GetContractAsync(string ContractId)
Gets a contract
Definition: ContractsClient.cs:5097

Waher.Networking.XMPP.Contracts.ContractsClient.ValidateAsync
Task< IdentityValidationEventArgs > ValidateAsync(LegalIdentity Identity)
Validates a legal identity.
Definition: ContractsClient.cs:2717

Waher.Networking.XMPP.Contracts.ContractsClient.SignAsync
Task< byte[]> SignAsync(byte[] Data, SignWith SignWith)
Signs binary data with the corresponding private key.
Definition: ContractsClient.cs:3418

Waher.Networking.XMPP.Contracts.ContractsClient.NamespaceOnboarding
const string NamespaceOnboarding
http://waher.se/schema/Onboarding/v1.xsd
Definition: ContractsClient.cs:134

Waher.Networking.XMPP.Contracts.ContractsClient.PetitionContractResponseAsync
Task PetitionContractResponseAsync(string ContractId, string PetitionId, string RequestorFullJid, bool Response)
Sends a response to a petition to access a smart contract. When a petition for a contract is received...
Definition: ContractsClient.cs:8289

Waher.Networking.XMPP.Contracts.ContractsClient.ReadyForApprovalAsync
Task ReadyForApprovalAsync(string LegalIdentityId)
Marks an Identity as Ready for Approval. Call this after necessary attachments have been added....
Definition: ContractsClient.cs:2164

Waher.Networking.XMPP.Contracts.ContractsClient.AddPeerReviewIDAttachment
async Task< LegalIdentity > AddPeerReviewIDAttachment(LegalIdentity Identity, LegalIdentity ReviewerLegalIdentity, byte[] PeerSignature)
Adds an attachment to a legal identity with information about a peer review of the identity.
Definition: ContractsClient.cs:8174

Waher.Networking.XMPP.Contracts.ContractsClient.GetLegalIdentitiesAsync
Task< LegalIdentity[]> GetLegalIdentitiesAsync()
Gets legal identities registered with the account.
Definition: ContractsClient.cs:3079

Waher.Networking.XMPP.Contracts.ContractsClient.ExportKeys
async Task< string > ExportKeys()
Exports Keys to XML.
Definition: ContractsClient.cs:1105

Waher.Networking.XMPP.Contracts.ContractsClient.SignContractAsync
Task< Contract > SignContractAsync(Contract Contract, string Role, bool Transferable)
Signs a contract
Definition: ContractsClient.cs:4755

Waher.Networking.XMPP.Contracts.ContractsClient.Dispose
override void Dispose()
Disposes of the extension.
Definition: ContractsClient.cs:324

Waher.Networking.XMPP.Contracts.ContractsClient.GetSignedContractReferencesAsync
Task< string[]> GetSignedContractReferencesAsync()
Get references to contracts the account has signed.
Definition: ContractsClient.cs:4855

Waher.Networking.XMPP.Contracts.ContractsClient.PetitionPeerReviewIDAsync
Task PetitionPeerReviewIDAsync(string LegalId, LegalIdentity Identity, string PetitionId, string Purpose)
Sends a petition to a third party to peer review a new legal identity. The petition is not guaranteed...
Definition: ContractsClient.cs:8125

Waher.Networking.XMPP.Contracts.ContractsClient.EnableE2eEncryption
async Task EnableE2eEncryption()
Enables the keys of the Contracts Client to be used for End-to-End Encrypted communication over the X...
Definition: ContractsClient.cs:1401

Waher.Networking.XMPP.Contracts.ContractsClient.CreateContractAsync
Task< Contract > CreateContractAsync(XmlElement ForMachines, HumanReadableText[] ForHumans, Role[] Roles, Part[] Parts, Parameter[] Parameters, ContractVisibility Visibility, ContractParts PartsMode, Duration? Duration, Duration? ArchiveRequired, Duration? ArchiveOptional, DateTime? SignAfter, DateTime? SignBefore, bool CanActAsTemplate)
Creates a new contract.
Definition: ContractsClient.cs:4025

Waher.Networking.XMPP.Contracts.ContractsClient.DeleteContractAsync
Task< Contract > DeleteContractAsync(string ContractId)
Deletes a contract
Definition: ContractsClient.cs:5372

Waher.Networking.XMPP.Contracts.ContractsClient.GetCreatedContractReferencesAsync
Task< string[]> GetCreatedContractReferencesAsync()
Get references to contracts the account has created.
Definition: ContractsClient.cs:4456

Waher.Networking.XMPP.Contracts.ContractsClient.UploadLegalIdAttachmentAsync
async Task< LegalIdentity > UploadLegalIdAttachmentAsync(string LegalId, string FileName, byte[] Data, string ContentType)
Uploads an attachment to a Legal Identity application.
Definition: ContractsClient.cs:8537

Waher.Networking.XMPP.Contracts.ContractsClient.ObsoleteContractAsync
Task< Contract > ObsoleteContractAsync(string ContractId)
Obsoletes a contract
Definition: ContractsClient.cs:5302

Waher.Networking.XMPP.Contracts.ContractsClient.NamespacesLegalIdentities
static readonly string[] NamespacesLegalIdentities
Namespaces supported for legal identities.
Definition: ContractsClient.cs:81

Waher.Networking.XMPP.Contracts.ContractsClient.NamespaceLegalIdentitiesCurrent
const string NamespaceLegalIdentitiesCurrent
Current namespace for legal identities.
Definition: ContractsClient.cs:65

Waher.Networking.XMPP.Contracts.EventArguments.ClientMessageEventArgs
Identity Review event arguments.
Definition: ClientMessageEventArgs.cs:9

Waher.Networking.XMPP.Contracts.EventArguments.ClientMessageEventArgs.Code
string Code
Machine-readable code corresponding to the first error message.
Definition: ClientMessageEventArgs.cs:31

Waher.Networking.XMPP.Contracts.EventArguments.ContractPetitionEventArgs
Event arguments for smart contract petitions
Definition: ContractPetitionEventArgs.cs:10

Waher.Networking.XMPP.Contracts.EventArguments.ContractPetitionResponseEventArgs
Event arguments for smart contract petition responses
Definition: ContractPetitionResponseEventArgs.cs:10

Waher.Networking.XMPP.Contracts.EventArguments.ContractPetitionResponseEventArgs.PetitionId
string PetitionId
Petition ID
Definition: ContractPetitionResponseEventArgs.cs:45

Waher.Networking.XMPP.Contracts.EventArguments.ContractProposalEventArgs
Event arguments for smart contract proposals
Definition: ContractProposalEventArgs.cs:10

Waher.Networking.XMPP.Contracts.EventArguments.ContractProposalEventArgs.ContractId
string ContractId
ID of proposed contract.
Definition: ContractProposalEventArgs.cs:40

Waher.Networking.XMPP.Contracts.EventArguments.ContractReferenceEventArgs
Event arguments for events referencing a contract.
Definition: ContractReferenceEventArgs.cs:9

Waher.Networking.XMPP.Contracts.EventArguments.ContractReferenceEventArgs.ContractId
string ContractId
ID of contract being signed.
Definition: ContractReferenceEventArgs.cs:24

Waher.Networking.XMPP.Contracts.EventArguments.ContractSignedEventArgs
Event arguments for contract signature events
Definition: ContractSignedEventArgs.cs:9

Waher.Networking.XMPP.Contracts.EventArguments.IdentityValidationEventArgs
Event arguments for identity validation responses
Definition: IdentityValidationEventArgs.cs:10

Waher.Networking.XMPP.Contracts.EventArguments.IdentityValidationEventArgs.Status
IdentityStatus Status
Validation status of legal identity.
Definition: IdentityValidationEventArgs.cs:33

Waher.Networking.XMPP.Contracts.EventArguments.LegalIdentityEventArgs
Event arguments for legal identity responses
Definition: LegalIdentityEventArgs.cs:9

Waher.Networking.XMPP.Contracts.EventArguments.LegalIdentityEventArgs.Identity
LegalIdentity Identity
Legal Identity
Definition: LegalIdentityEventArgs.cs:26

Waher.Networking.XMPP.Contracts.EventArguments.LegalIdentityPetitionEventArgs
Event arguments for legal identity petitions
Definition: LegalIdentityPetitionEventArgs.cs:10

Waher.Networking.XMPP.Contracts.EventArguments.LegalIdentityPetitionResponseEventArgs
Event arguments for legal identity petition responses
Definition: LegalIdentityPetitionResponseEventArgs.cs:10

Waher.Networking.XMPP.Contracts.EventArguments.LegalIdentityPetitionResponseEventArgs.PetitionId
string PetitionId
Petition ID
Definition: LegalIdentityPetitionResponseEventArgs.cs:45

Waher.Networking.XMPP.Contracts.EventArguments.PetitionClientUrlEventArgs
Event arguments for events where a client URL needs to be displayed when performing a petition.
Definition: PetitionClientUrlEventArgs.cs:10

Waher.Networking.XMPP.Contracts.EventArguments.PetitionClientUrlEventArgs.ClientUrl
string ClientUrl
URL client needs to open to complete the peer review.
Definition: PetitionClientUrlEventArgs.cs:36

Waher.Networking.XMPP.Contracts.EventArguments.PetitionClientUrlEventArgs.PetitionId
string PetitionId
ID of peer review petition.
Definition: PetitionClientUrlEventArgs.cs:31

Waher.Networking.XMPP.Contracts.EventArguments.PetitionEventArgs.RequestorIdentity
LegalIdentity RequestorIdentity
Legal Identity of requesting entity.
Definition: PetitionEventArgs.cs:52

Waher.Networking.XMPP.Contracts.EventArguments.PetitionEventArgs.RequestorFullJid
string RequestorFullJid
Full JID of requestor.
Definition: PetitionEventArgs.cs:57

Waher.Networking.XMPP.Contracts.EventArguments.PetitionEventArgs.PetitionId
string PetitionId
Petition ID
Definition: PetitionEventArgs.cs:62

Waher.Networking.XMPP.Contracts.EventArguments.SignaturePetitionEventArgs
Event arguments for digital signature petitions
Definition: SignaturePetitionEventArgs.cs:10

Waher.Networking.XMPP.Contracts.EventArguments.SignaturePetitionResponseEventArgs
Event arguments for signature petition responses
Definition: SignaturePetitionResponseEventArgs.cs:10

Waher.Networking.XMPP.Contracts.EventArguments.SignaturePetitionResponseEventArgs.PetitionId
string PetitionId
Petition ID
Definition: SignaturePetitionResponseEventArgs.cs:58

Waher.Networking.XMPP.Contracts.InvalidClaim
Represents an invalidated claim.
Definition: InvalidClaim.cs:7

Waher.Networking.XMPP.Contracts.InvalidClaim.ReasonCode
string ReasonCode
A machine-readable code for the reason for invalidating the claim. (Each service can define its own r...
Definition: InvalidClaim.cs:51

Waher.Networking.XMPP.Contracts.InvalidClaim.ReasonLanguage
string ReasonLanguage
ISO code of language used for Reason.
Definition: InvalidClaim.cs:45

Waher.Networking.XMPP.Contracts.InvalidClaim.Claim
string Claim
Identifier of claim
Definition: InvalidClaim.cs:30

Waher.Networking.XMPP.Contracts.InvalidPhoto
Represents an invalidated photo.
Definition: InvalidPhoto.cs:7

Waher.Networking.XMPP.Contracts.InvalidPhoto.ReasonCode
string ReasonCode
A machine-readable code for the reason for invalidating the photo. (Each service can define its own r...
Definition: InvalidPhoto.cs:51

Waher.Networking.XMPP.Contracts.InvalidPhoto.FileName
string FileName
File name of Invalidated photo.
Definition: InvalidPhoto.cs:30

Waher.Networking.XMPP.Contracts.InvalidPhoto.ReasonLanguage
string ReasonLanguage
ISO code of language used for Reason.
Definition: InvalidPhoto.cs:45

Waher.Networking.XMPP.Contracts.LegalIdentity
Legal identity
Definition: LegalIdentity.cs:48

Waher.Networking.XMPP.Contracts.LegalIdentity.Created
DateTime Created
When the identity object was created
Definition: LegalIdentity.cs:121

Waher.Networking.XMPP.Contracts.LegalIdentity.State
IdentityState State
Current state of identity
Definition: LegalIdentity.cs:112

Waher.Networking.XMPP.Contracts.LegalIdentity.Id
string Id
ID of the legal identity
Definition: LegalIdentity.cs:75

Waher.Networking.XMPP.Contracts.LegalIdentity.Serialize
void Serialize(StringBuilder Xml, bool IncludeNamespace, bool IncludeIdAttribute, bool IncludeClientSignature, bool IncludeAttachments, bool IncludeStatus, bool IncludeServerSignature, bool IncludeAttachmentReferences)
Serializes the identity to XML
Definition: LegalIdentity.cs:394

Waher.Networking.XMPP.Contracts.LegalIdentity.Parse
static LegalIdentity Parse(string Xml)
Parses an identity from its XML representation
Definition: LegalIdentity.cs:227

Waher.Networking.XMPP.Contracts.LegalIdentity.Attachments
Attachment[] Attachments
Attachments assigned to the legal identity.
Definition: LegalIdentity.cs:166

Waher.Networking.XMPP.Contracts.Parameter
Abstract base class for contractual parameters
Definition: Parameter.cs:17

Waher.Networking.XMPP.Contracts.Part
Class defining a part in a contract
Definition: Part.cs:30

Waher.Networking.XMPP.Contracts.Property
Named property
Definition: Property.cs:9

Waher.Networking.XMPP.Contracts.Role
Class defining a role
Definition: Role.cs:7

Waher.Networking.XMPP.Contracts.ServiceProvider
Contains information about a service provider.
Definition: ServiceProvider.cs:7

Waher.Networking.XMPP.Contracts.Signature
Abstract base class of signatures
Definition: Signature.cs:10

Waher.Networking.XMPP.Control.ControlClient
Implements an XMPP control client interface.
Definition: ControlClient.cs:22

Waher.Networking.XMPP.Control.ControlClient.GetForm
Task GetForm(string To, string Language, params ThingReference[] Nodes)
Gets a control form.
Definition: ControlClient.cs:728

Waher.Networking.XMPP.Events.IqResultEventArgs
Event arguments for responses to IQ queries.
Definition: IqResultEventArgs.cs:11

Waher.Networking.XMPP.Events.IqResultEventArgs.Ok
bool Ok
If the response is an OK result response (true), or an error response (false).
Definition: IqResultEventArgs.cs:189

Waher.Networking.XMPP.Events.IqResultEventArgs.StanzaError
XmppException StanzaError
Any stanza error returned.
Definition: IqResultEventArgs.cs:217

Waher.Networking.XMPP.Events.MessageEventArgs
Event arguments for message events.
Definition: MessageEventArgs.cs:12

Waher.Networking.XMPP.Events.MessageEventArgs.Id
string Id
ID attribute of message stanza.
Definition: MessageEventArgs.cs:262

Waher.Networking.XMPP.Events.MessageEventArgs.From
string From
From where the message was received.
Definition: MessageEventArgs.cs:235

Waher.Networking.XMPP.Events.MessageEventArgs.Message
XmlElement Message
The message stanza.
Definition: MessageEventArgs.cs:213

Waher.Networking.XMPP.Events.MessageEventArgs.Body
string Body
Human readable body.
Definition: MessageEventArgs.cs:275

Waher.Networking.XMPP.Events.MessageEventArgs.FromBareJID
string FromBareJID
Bare JID of resource sending the message.
Definition: MessageEventArgs.cs:247

Waher.Networking.XMPP.Events.MessageEventArgs.Ok
bool Ok
If the response is an OK result response (true), or an error response (false).
Definition: MessageEventArgs.cs:290

Waher.Networking.XMPP.Events.MessageEventArgs.To
string To
To whom the message was sent.
Definition: MessageEventArgs.cs:253

Waher.Networking.XMPP.Events.MessageEventArgs.Content
XmlElement Content
Content of the message. For messages that are processed by registered message handlers,...
Definition: MessageEventArgs.cs:221

Waher.Networking.XMPP.Events.MessageEventArgs.StanzaError
XmppException StanzaError
Any stanza error returned.
Definition: MessageEventArgs.cs:315

Waher.Networking.XMPP.Events.PresenceEventArgs
Event arguments for presence events.
Definition: PresenceEventArgs.cs:13

Waher.Networking.XMPP.Events.PresenceEventArgs.Ok
bool Ok
If the response is an OK result response (true), or an error response (false).
Definition: PresenceEventArgs.cs:341

Waher.Networking.XMPP.Events.PresenceEventArgs.Presence
XmlElement Presence
Presence element.
Definition: PresenceEventArgs.cs:279

Waher.Networking.XMPP.Events.PresenceEventArgs.FromBareJID
string FromBareJID
Bare JID of resource sending the presence.
Definition: PresenceEventArgs.cs:259

Waher.Networking.XMPP.Events.PresenceEventArgs.NickName
virtual string NickName
NickName, if available, as defined in XEP-0172. Can be sent in presence subscription requests,...
Definition: PresenceEventArgs.cs:463

Waher.Networking.XMPP.Events.PresenceEventArgs.Decline
async Task Decline()
Declines a subscription or unsubscription request.
Definition: PresenceEventArgs.cs:438

Waher.Networking.XMPP.Events.PresenceEventArgs.Accept
async Task Accept()
Accepts a subscription or unsubscription request.
Definition: PresenceEventArgs.cs:414

Waher.Networking.XMPP.Events.PresenceEventArgs.Client
XmppClient Client
XMPP Client. Is null if event raised by a component.
Definition: PresenceEventArgs.cs:284

Waher.Networking.XMPP.HTTPX.HttpxClient
HTTPX client.
Definition: HttpxClient.cs:27

Waher.Networking.XMPP.HTTPX.HttpxClient.GetJwtTokenAsync
Task< string > GetJwtTokenAsync(int Seconds)
Gets a JWT token from the server to which the client is connceted. The JWT token encodes the current ...
Definition: HttpxClient.cs:1110

Waher.Networking.XMPP.HttpFileUpload.HttpFileUploadClient
Class managing HTTP File uploads, as defined in XEP-0363.
Definition: HttpFileUploadClient.cs:17

Waher.Networking.XMPP.HttpFileUpload.HttpFileUploadClient.FindMaxFileSize
static ? long FindMaxFileSize(XmppClient Client, ServiceDiscoveryEventArgs e)
Finds the maximum file size supported by the file upload service.
Definition: HttpFileUploadClient.cs:159

Waher.Networking.XMPP.HttpFileUpload.HttpFileUploadClient.HasSupport
bool HasSupport
If support has been found.
Definition: HttpFileUploadClient.cs:184

Waher.Networking.XMPP.HttpFileUpload.HttpFileUploadClient.Namespace
const string Namespace
urn:xmpp:http:upload:0
Definition: HttpFileUploadClient.cs:21

Waher.Networking.XMPP.PEP.PepClient
Client managing the Personal Eventing Protocol (XEP-0163). https://xmpp.org/extensions/xep-0163....
Definition: PepClient.cs:19

Waher.Networking.XMPP.PEP.PepClient.RegisterHandler
void RegisterHandler(Type PersonalEventType, EventHandlerAsync< PersonalEventNotificationEventArgs > Handler)
Registers an event handler of a specific type of personal events.
Definition: PepClient.cs:345

Waher.Networking.XMPP.PEP.PepClient.Dispose
override void Dispose()
Disposes of the extension.
Definition: PepClient.cs:55

Waher.Networking.XMPP.PEP.PepClient.PubSubClient
PubSubClient PubSubClient
PubSubClient used for the Personal Eventing Protocol. Use this client to perform administrative tasks...
Definition: PepClient.cs:95

Waher.Networking.XMPP.PEP.PepClient.UnregisterHandler
bool UnregisterHandler(Type PersonalEventType, EventHandlerAsync< PersonalEventNotificationEventArgs > Handler)
Unregisters an event handler of a specific type of personal events.
Definition: PepClient.cs:380

Waher.Networking.XMPP.Provisioning.Events.CanControlEventArgs
Event arguments for CanControl events.
Definition: CanControlEventArgs.cs:16

Waher.Networking.XMPP.Provisioning.Events.CanReadEventArgs
Event arguments for CanRead events.
Definition: CanReadEventArgs.cs:17

Waher.Networking.XMPP.Provisioning.Events.IsFriendEventArgs
Event arguments for IsFriend events.
Definition: IsFriendEventArgs.cs:11

Waher.Networking.XMPP.Provisioning.MetaDataNumericTag
Meta-data numeric tag.
Definition: MetaDataNumericTag.cs:10

Waher.Networking.XMPP.Provisioning.MetaDataStringTag
Meta-data string tag.
Definition: MetaDataStringTag.cs:9

Waher.Networking.XMPP.Provisioning.MetaDataTag
Abstract base class for all meta-data tags.
Definition: MetaDataTag.cs:10

Waher.Networking.XMPP.Provisioning.ProvisioningClient
Implements an XMPP provisioning client interface.
Definition: ProvisioningClient.cs:37

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanControlResponseDevice
Task CanControlResponseDevice(string JID, string RemoteJID, string Key, bool CanControl, string[] ParameterNames, string Token, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Control" question, based on a device token.
Definition: ProvisioningClient.cs:1805

Waher.Networking.XMPP.Provisioning.ProvisioningClient.GetDevices
Task GetDevices(int Offset, int MaxCount, EventHandlerAsync< SearchResultEventArgs > Callback, object State)
Gets devices owned by the caller.
Definition: ProvisioningClient.cs:2090

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanReadResponseService
Task CanReadResponseService(string JID, string RemoteJID, string Key, bool CanRead, FieldType FieldTypes, string[] FieldNames, string Token, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Read" question, based on a service token.
Definition: ProvisioningClient.cs:1429

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanReadResponseUser
Task CanReadResponseUser(string JID, string RemoteJID, string Key, bool CanRead, FieldType FieldTypes, string[] FieldNames, string Token, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Read" question, based on a user token.
Definition: ProvisioningClient.cs:1507

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanReadResponseAll
Task CanReadResponseAll(string JID, string RemoteJID, string Key, bool CanRead, FieldType FieldTypes, string[] FieldNames, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Read" question, for all future requests.
Definition: ProvisioningClient.cs:1545

Waher.Networking.XMPP.Provisioning.ProvisioningClient.NamespacesProvisioningDevice
static readonly string[] NamespacesProvisioningDevice
Namespaces supported for provisioning devices.
Definition: ProvisioningClient.cs:87

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanControlResponseCaller
Task CanControlResponseCaller(string JID, string RemoteJID, string Key, bool CanControl, string[] ParameterNames, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Control" question, based on the JID of the caller.
Definition: ProvisioningClient.cs:1697

Waher.Networking.XMPP.Provisioning.ProvisioningClient.NamespacesProvisioningOwner
static readonly string[] NamespacesProvisioningOwner
Namespaces supported for provisioning owners.
Definition: ProvisioningClient.cs:111

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanControlResponseService
Task CanControlResponseService(string JID, string RemoteJID, string Key, bool CanControl, string[] ParameterNames, string Token, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Control" question, based on a service token.
Definition: ProvisioningClient.cs:1768

Waher.Networking.XMPP.Provisioning.ProvisioningClient.DeleteDeviceRules
Task DeleteDeviceRules()
Deletes te device rules of all owned devices.
Definition: ProvisioningClient.cs:2160

Waher.Networking.XMPP.Provisioning.ProvisioningClient.ProvisioningServerAddress
string ProvisioningServerAddress
Provisioning server XMPP address.
Definition: ProvisioningClient.cs:222

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanReadResponseCaller
Task CanReadResponseCaller(string JID, string RemoteJID, string Key, bool CanRead, FieldType FieldTypes, string[] FieldNames, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Read" question, based on the JID of the caller.
Definition: ProvisioningClient.cs:1354

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanReadResponseDomain
Task CanReadResponseDomain(string JID, string RemoteJID, string Key, bool CanRead, FieldType FieldTypes, string[] FieldNames, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Read" question, based on the domain of the caller.
Definition: ProvisioningClient.cs:1391

Waher.Networking.XMPP.Provisioning.ProvisioningClient.Dispose
override void Dispose()
Disposes of the extension.
Definition: ProvisioningClient.cs:178

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanControlResponseUser
Task CanControlResponseUser(string JID, string RemoteJID, string Key, bool CanControl, string[] ParameterNames, string Token, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Control" question, based on a user token.
Definition: ProvisioningClient.cs:1842

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanControlResponseDomain
Task CanControlResponseDomain(string JID, string RemoteJID, string Key, bool CanControl, string[] ParameterNames, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Control" question, based on the domain of the caller.
Definition: ProvisioningClient.cs:1732

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanReadResponseDevice
Task CanReadResponseDevice(string JID, string RemoteJID, string Key, bool CanRead, FieldType FieldTypes, string[] FieldNames, string Token, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Read" question, based on a device token.
Definition: ProvisioningClient.cs:1468

Waher.Networking.XMPP.Provisioning.ProvisioningClient.CanControlResponseAll
Task CanControlResponseAll(string JID, string RemoteJID, string Key, bool CanControl, string[] ParameterNames, IThingReference Node, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Can Control" question, for all future requests.
Definition: ProvisioningClient.cs:1878

Waher.Networking.XMPP.Provisioning.ProvisioningClient.GetCertificate
Task GetCertificate(string Token, EventHandlerAsync< CertificateEventArgs > Callback, object State)
Gets the certificate the corresponds to a token. This certificate can be used to identify services,...
Definition: ProvisioningClient.cs:474

Waher.Networking.XMPP.Provisioning.ProvisioningClient.IsFriendResponse
Task IsFriendResponse(string JID, string RemoteJID, string Key, bool IsFriend, RuleRange Range, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Sends a response to a previous "Is Friend" question.
Definition: ProvisioningClient.cs:1289

Waher.Networking.XMPP.Provisioning.ProvisioningClient.NamespacesProvisioningToken
static readonly string[] NamespacesProvisioningToken
Namespaces supported for provisioning tokens.
Definition: ProvisioningClient.cs:63

Waher.Networking.XMPP.Provisioning.SearchOperators.NumericTagEqualTo
Filters things with a named numeric-valued tag equal to a given value.
Definition: NumericTagEqualTo.cs:7

Waher.Networking.XMPP.Provisioning.SearchOperators.SearchOperator
Abstract base class for all search operators.
Definition: SearchOperator.cs:10

Waher.Networking.XMPP.Provisioning.SearchOperators.StringTagEqualTo
Filters things with a named string-valued tag equal to a given value.
Definition: StringTagEqualTo.cs:7

Waher.Networking.XMPP.Provisioning.SearchResultThing
Contains information about a thing in a search result.
Definition: SearchResultThing.cs:9

Waher.Networking.XMPP.Provisioning.ThingRegistryClient
Implements an XMPP thing registry client interface.
Definition: ThingRegistryClient.cs:24

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.TryDecodeIoTDiscoURI
static bool TryDecodeIoTDiscoURI(string DiscoUri, out IEnumerable< SearchOperator > Operators)
Decodes an IoTDisco URI.
Definition: ThingRegistryClient.cs:1065

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.TryDecodeIoTDiscoClaimURI
static bool TryDecodeIoTDiscoClaimURI(string DiscoUri, out MetaDataTag[] Tags)
Tries to decode an IoTDisco Claim URI (subset of all possible IoTDisco URIs).
Definition: ThingRegistryClient.cs:1024

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.IsIoTDiscoDirectURI
static bool IsIoTDiscoDirectURI(string DiscoUri)
Checks if a URI is a direct reference URI.
Definition: ThingRegistryClient.cs:1693

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.IsIoTDiscoClaimURI
static bool IsIoTDiscoClaimURI(string DiscoUri)
Checks if a URI is a claim URI.
Definition: ThingRegistryClient.cs:1592

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.Dispose
override void Dispose()
Disposes of the extension.
Definition: ThingRegistryClient.cs:82

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.Disown
Task Disown(string ThingJid, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Disowns a thing, so that it can be claimed by another.
Definition: ThingRegistryClient.cs:712

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.ThingRegistryAddress
string ThingRegistryAddress
Thing Registry XMPP address.
Definition: ThingRegistryClient.cs:111

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.IsIoTDiscoSearchURI
static bool IsIoTDiscoSearchURI(string DiscoUri)
Checks if a URI is a search URI.
Definition: ThingRegistryClient.cs:1637

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.Mine
Task Mine(MetaDataTag[] MetaDataTags, EventHandlerAsync< NodeResultEventArgs > Callback, object State)
Claims a thing.
Definition: ThingRegistryClient.cs:330

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.NamespacesDiscovery
static readonly string[] NamespacesDiscovery
Namespaces supported for discovery.
Definition: ThingRegistryClient.cs:45

Waher.Networking.XMPP.Provisioning.ThingRegistryClient.Search
Task Search(int Offset, int MaxCount, SearchOperator[] SearchOperators, EventHandlerAsync< SearchResultEventArgs > Callback, object State)
Searches for publically available things in the thing registry.
Definition: ThingRegistryClient.cs:820

Waher.Networking.XMPP.PubSub.Events.ItemsEventArgs
Event arguments for items callback events.
Definition: ItemsEventArgs.cs:10

Waher.Networking.XMPP.PubSub.Events.ItemsEventArgs.Items
PubSubItem[] Items
Items found.
Definition: ItemsEventArgs.cs:42

Waher.Networking.XMPP.PubSub.Events.ItemsEventArgs.Page
ResultPage Page
Pagination information, if available, null otherwise.
Definition: ItemsEventArgs.cs:47

Waher.Networking.XMPP.PubSub.Events.NodeEventArgs
Event arguments for node callback events.
Definition: NodeEventArgs.cs:9

Waher.Networking.XMPP.PubSub.NodeConfiguration
Contains information about the configuration of a node.
Definition: NodeConfiguration.cs:15

Waher.Networking.XMPP.PubSub.PubSubClient
Client managing communication with a Publish/Subscribe component. https://xmpp.org/extensions/xep-006...
Definition: PubSubClient.cs:20

Waher.Networking.XMPP.PubSub.PubSubClient.DeleteNode
Task DeleteNode(string Name, EventHandlerAsync< NodeEventArgs > Callback, object State)
Deletes a node.
Definition: PubSubClient.cs:613

Waher.Networking.XMPP.PubSub.PubSubClient.GetLatestItems
Task GetLatestItems(string NodeName, int Count, EventHandlerAsync< ItemsEventArgs > Callback, object State)
Gets the latest items from a node.
Definition: PubSubClient.cs:1823

Waher.Networking.XMPP.PubSub.PubSubClient.PurgeNode
Task PurgeNode(string Name, EventHandlerAsync< NodeEventArgs > Callback, object State)
Purges a node (deletes all items persisted on the node).
Definition: PubSubClient.cs:1851

Waher.Networking.XMPP.PubSub.PubSubClient.GetItems
Task GetItems(string NodeName, EventHandlerAsync< ItemsEventArgs > Callback, object State)
Gets items from a node.
Definition: PubSubClient.cs:1665

Waher.Networking.XMPP.PubSub.PubSubClient.CreateNode
Task CreateNode(string Name, EventHandlerAsync< NodeEventArgs > Callback, object State)
Creates a node on the server.
Definition: PubSubClient.cs:292

Waher.Networking.XMPP.PubSub.PubSubClient.Retract
Task Retract(string Node, string ItemId, EventHandlerAsync< IqResultEventArgs > Callback, object State)
Retracts an item from a node.
Definition: PubSubClient.cs:1621

Waher.Networking.XMPP.PubSub.PubSubClient.NamespaceDelayedDelivery
const string NamespaceDelayedDelivery
urn:xmpp:delay (XEP-0203)
Definition: PubSubClient.cs:44

Waher.Networking.XMPP.PubSub.PubSubClient.NamespacePubSub
const string NamespacePubSub
http://jabber.org/protocol/pubsub
Definition: PubSubClient.cs:24

Waher.Networking.XMPP.PubSub.PubSubClient.ComponentAddress
string ComponentAddress
Publish/Subscribe component address.
Definition: PubSubClient.cs:277

Waher.Networking.XMPP.PubSub.PubSubClient.Subscribe
Task Subscribe(string NodeName, EventHandlerAsync< SubscriptionEventArgs > Callback, object State)
Subscribes to a node.
Definition: PubSubClient.cs:670

Waher.Networking.XMPP.PubSub.PubSubClient.Unsubscribe
Task Unsubscribe(string NodeName, EventHandlerAsync< SubscriptionEventArgs > Callback, object State)
Unsubscribes from a node.
Definition: PubSubClient.cs:1223

Waher.Networking.XMPP.PubSub.PubSubClient.Publish
Task Publish(string Node, EventHandlerAsync< ItemResultEventArgs > Callback, object State)
Publishes an item on a node.
Definition: PubSubClient.cs:1348

Waher.Networking.XMPP.PubSub.PubSubItem
Represents a published item.
Definition: PubSubItem.cs:12

Waher.Networking.XMPP.PubSub.SubscriptionOptions
Contains options for a node subscription
Definition: SubscriptionOptions.cs:15

Waher.Networking.XMPP.Push.PushNotificationClient
Push Notification Client
Definition: PushNotificationClient.cs:14

Waher.Networking.XMPP.Push.PushNotificationClient.NewTokenAsync
async Task NewTokenAsync(string Token, PushMessagingService Service, ClientType ClientType)
Reports a new push token to the server.
Definition: PushNotificationClient.cs:67

Waher.Networking.XMPP.Push.PushNotificationClient.MessagePushNamespace
const string MessagePushNamespace
http://waher.se/Schema/PushNotification.xsd
Definition: PushNotificationClient.cs:18

Waher.Networking.XMPP.Push.PushNotificationClient.AddRuleAsync
async Task AddRuleAsync(MessageType MessageType, string LocalName, string Namespace, string Channel, string MessageVariable, string PatternMatchingScript, string ContentScript)
Adds a push notification rule to the client account.
Definition: PushNotificationClient.cs:249

Waher.Networking.XMPP.Push.PushNotificationClient.ClearRulesAsync
async Task ClearRulesAsync()
Clears available push notification rules for the client.
Definition: PushNotificationClient.cs:147

Waher.Networking.XMPP.RemoteSniffer
Class redirecting sniffer output to a remote client.
Definition: RemoteSniffer.cs:15

Waher.Networking.XMPP.ResultSetManagement.RestrictedQuery
Contains information about a restricted query, as deinfed in XEP-0059: Result Set Management
Definition: RestrictedQuery.cs:11

Waher.Networking.XMPP.ResultSetManagement.ResultPage
Contains information about a result page, as deinfed in XEP-0059: Result Set Management
Definition: ResultPage.cs:11

Waher.Networking.XMPP.RosterItem
Maintains information about an item in the roster.
Definition: RosterItem.cs:75

Waher.Networking.XMPP.Sensor.SensorClient
Implements an XMPP sensor client interface.
Definition: SensorClient.cs:21

Waher.Networking.XMPP.Sensor.SensorClient.RequestReadout
Task< SensorDataClientRequest > RequestReadout(string Destination, FieldType Types)
Requests a sensor data readout.
Definition: SensorClient.cs:133

Waher.Networking.XMPP.Sensor.SensorClient.Dispose
override void Dispose()
Disposes of the extension.
Definition: SensorClient.cs:101

Waher.Networking.XMPP.ServiceDiscovery.Identity
Contains information about an identity of an entity.
Definition: Identity.cs:11

Waher.Networking.XMPP.ServiceDiscovery.Item
Contains information about an item of an entity.
Definition: Item.cs:11

Waher.Networking.XMPP.ServiceDiscovery.Item.Node
string Node
Node
Definition: Item.cs:44

Waher.Networking.XMPP.ServiceDiscovery.Item.JID
string JID
JID of item
Definition: Item.cs:39

Waher.Networking.XMPP.ServiceDiscovery.ServiceDiscoveryEventArgs
Event arguments for service discovery responses.
Definition: ServiceDiscoveryEventArgs.cs:11

Waher.Networking.XMPP.ServiceDiscovery.ServiceDiscoveryEventArgs.HasFeature
bool HasFeature(string Feature)
Checks if the remote entity supports a specific feature.
Definition: ServiceDiscoveryEventArgs.cs:57

Waher.Networking.XMPP.ServiceDiscovery.ServiceDiscoveryEventArgs.HasAnyFeature
bool HasAnyFeature(params string[] Features)
Checks if the remote entity supports any of a set of features.
Definition: ServiceDiscoveryEventArgs.cs:83

Waher.Networking.XMPP.ServiceDiscovery.ServiceItemsDiscoveryEventArgs
Event arguments for service items discovery responses.
Definition: ServiceItemsDiscoveryEventArgs.cs:9

Waher.Networking.XMPP.ServiceDiscovery.ServiceItemsDiscoveryEventArgs.Items
Item[] Items
Items
Definition: ServiceItemsDiscoveryEventArgs.cs:21

Waher.Networking.XMPP.StanzaErrors.ConflictException
Access cannot be granted because an existing resource exists with the same name or address; the assoc...
Definition: ConflictException.cs:9

Waher.Networking.XMPP.StanzaErrors.ConflictException.Alternatives
string[] Alternatives
Alternatives
Definition: ConflictException.cs:37

Waher.Networking.XMPP.StreamErrors.NotAuthorizedException
The entity has attempted to send XML stanzas or other outbound data before the stream has been authen...
Definition: NotAuthorizedException.cs:11

Waher.Networking.XMPP.XmppClient
Manages an XMPP client connection. Implements XMPP, as defined in https://tools.ietf....
Definition: XmppClient.cs:58

Waher.Networking.XMPP.XmppClient.RequestRevokePresenceSubscription
Task RequestRevokePresenceSubscription(string BareJid)
Requests a previous presence subscription request revoked.
Definition: XmppClient.cs:5060

Waher.Networking.XMPP.XmppClient.ChangePassword
Task ChangePassword(string NewPassword)
Changes the password of the current user.
Definition: XmppClient.cs:4299

Waher.Networking.XMPP.XmppClient.ServiceItemsDiscoveryAsync
Task< ServiceItemsDiscoveryEventArgs > ServiceItemsDiscoveryAsync(string To)
Performs an asynchronous service items discovery request
Definition: XmppClient.cs:6298

Waher.Networking.XMPP.XmppClient.State
XmppState State
Current state of connection.
Definition: XmppClient.cs:985

Waher.Networking.XMPP.XmppClient.RemoveRosterItem
Task RemoveRosterItem(string BareJID)
Removes an item from the roster.
Definition: XmppClient.cs:4680

Waher.Networking.XMPP.XmppClient.SendMessage
Task SendMessage(MessageType Type, string To, string CustomXml, string Body, string Subject, string Language, string ThreadId, string ParentThreadId)
Sends a simple chat message
Definition: XmppClient.cs:5447

Waher.Networking.XMPP.XmppClient.DisposeAsync
async Task DisposeAsync()
Closes the connection and disposes of all resources.
Definition: XmppClient.cs:1145

Waher.Networking.XMPP.XmppClient.ServiceDiscoveryAsync
Task< ServiceDiscoveryEventArgs > ServiceDiscoveryAsync(string To)
Performs an asynchronous service discovery request
Definition: XmppClient.cs:6060

Waher.Networking.XMPP.XmppClient.RequestPresenceSubscription
Task RequestPresenceSubscription(string BareJid)
Requests subscription of presence information from a contact.
Definition: XmppClient.cs:4969

Waher.Networking.XMPP.XmppClient.GetPrivateXmlElementAsync
async Task< XmlElement > GetPrivateXmlElementAsync(string LocalName, string Namespace)
Gets an XML element from the Private XML Storage for the current account.
Definition: XmppClient.cs:7500

Waher.Networking.XMPP.XmppClient.AddRosterItem
Task AddRosterItem(RosterItem Item)
Adds an item to the roster. If an item with the same Bare JID is found in the roster,...
Definition: XmppClient.cs:4591

Waher.Networking.XMPP.XmppClient.IqSetAsync
async Task< XmlElement > IqSetAsync(string To, string Xml)
Performs an asynchronous IQ Set request/response operation.
Definition: XmppClient.cs:4101

Waher.Networking.XMPP.XmppClient.RequestPresenceUnsubscription
Task RequestPresenceUnsubscription(string BareJid)
Requests unssubscription of presence information from a contact.
Definition: XmppClient.cs:5033

Waher.Networking.XMPP.XmppClient.SendServiceDiscoveryRequest
Task SendServiceDiscoveryRequest(string To, EventHandlerAsync< ServiceDiscoveryEventArgs > Callback, object State)
Sends a service discovery request
Definition: XmppClient.cs:5863

Waher.Networking.XMPP.XmppClient.NamespaceQuickLogin
const string NamespaceQuickLogin
http://waher.se/Schema/QL.xsd
Definition: XmppClient.cs:172

Waher.Networking.XMPP.XmppClient.Connect
Task Connect()
Connects the client.
Definition: XmppClient.cs:641

Waher.Networking.XMPP.XmppClient.SetPresenceAsync
async Task SetPresenceAsync(Availability Availability, params KeyValuePair< string, string >[] Status)
Sets the presence of the connection. Add a CustomPresenceXml event handler to add custom presence XML...
Definition: XmppClient.cs:4936

Waher.Networking.XMPP.XmppClient.AllowRegistration
void AllowRegistration()
If registration of a new account is allowed. Requires a password. Having a password hash is not suffi...
Definition: XmppClient.cs:3572

Waher.Networking.XMPP.XmppClient.SendServiceItemsDiscoveryRequest
Task SendServiceItemsDiscoveryRequest(string To, EventHandlerAsync< ServiceItemsDiscoveryEventArgs > Callback, object State)
Sends a service items discovery request
Definition: XmppClient.cs:6118

Waher.Networking.XMPP.XmppClient.GetRosterItem
RosterItem GetRosterItem(string BareJID)
Gets a roster item.
Definition: XmppClient.cs:4571

Waher.Networking.XMPP.XmppCredentials
Class containing credentials for an XMPP client connection.
Definition: XmppCredentials.cs:15

Waher.Networking.XMPP.XmppCredentials.DefaultPort
const int DefaultPort
Default XMPP Server port.
Definition: XmppCredentials.cs:19

Waher.Networking.XMPP.XmppExtension.Dispose
virtual void Dispose()
Disposes of the extension.
Definition: XmppExtension.cs:51

Waher.Networking.XMPP.XmppExtension.Client
XmppClient Client
XMPP Client.
Definition: XmppExtension.cs:41

Waher.Persistence.CaseInsensitiveString
Represents a case-insensitive string.
Definition: CaseInsensitiveString.cs:11

Waher.Persistence.Database
Static interface for database persistence. In order to work, a database provider has to be assigned t...
Definition: Database.cs:21

Waher.Persistence.Database.FindDelete
static Task< IEnumerable< object > > FindDelete(string Collection, params string[] SortOrder)
Finds objects in a given collection and deletes them in the same atomic operation.
Definition: Database.cs:1442

Waher.Persistence.Database.Provider
static IDatabaseProvider Provider
Registered database provider.
Definition: Database.cs:59

Waher.Persistence.Database.Update
static async Task Update(object Object)
Updates an object in the database.
Definition: Database.cs:1211

Waher.Persistence.Database.Find
static Task< IEnumerable< object > > Find(string Collection, params string[] SortOrder)
Finds objects in a given collection.
Definition: Database.cs:238

Waher.Persistence.Database.Insert
static async Task Insert(object Object)
Inserts an object into the default collection of the database.
Definition: Database.cs:97

Waher.Persistence.Filters.FilterAnd
This filter selects objects that conform to all child-filters provided.
Definition: FilterAnd.cs:10

Waher.Persistence.Filters.FilterFieldEqualTo
This filter selects objects that have a named field equal to a given value.
Definition: FilterFieldEqualTo.cs:7

Waher.Persistence.Ledger
Static interface for ledger persistence. In order to work, a ledger provider has to be assigned to it...
Definition: Ledger.cs:14

Waher.Persistence.Ledger.Register
static void Register(ILedgerProvider LedgerProvider)
Registers a ledger provider for use from the static Ledger class, throughout the lifetime of the appl...
Definition: Ledger.cs:25

Waher.Persistence.Ledger.HasProvider
static bool HasProvider
If a ledger provider is registered.
Definition: Ledger.cs:105

Waher.Persistence.Ledger.StartListeningToDatabaseEvents
static void StartListeningToDatabaseEvents()
Makes the ledger listen on database events. Each call to StartListeningToDatabaseEvents must be follo...
Definition: Ledger.cs:273

Waher.Runtime.Inventory.Types
Static class that dynamically manages types and interfaces available in the runtime environment.
Definition: Types.cs:15

Waher.Runtime.Inventory.Types.SetModuleParameter
static void SetModuleParameter(string Name, object Value)
Sets a module parameter. This parameter value will be accessible to modules when they are loaded.
Definition: Types.cs:584

Waher.Runtime.Settings.RuntimeSettings
Static class managing persistent settings.
Definition: RuntimeSettings.cs:17

Waher.Runtime.Settings.RuntimeSettings.GetAsync
static async Task< string > GetAsync(string Key, string DefaultValue)
Gets a string-valued setting.
Definition: RuntimeSettings.cs:37

Waher.Runtime.Settings.RuntimeSettings.SetAsync
static async Task< bool > SetAsync(string Key, string Value)
Sets a string-valued setting.
Definition: RuntimeSettings.cs:70

Waher.Script.Constants.E
Euler's number.
Definition: E.cs:12

Waher.Script.Constants.Now
Current date and time.
Definition: Now.cs:12

Waher.Security.JWT.JwtClaims
Static class containing predefined JWT claim names.
Definition: JwtClaims.cs:10

Waher.Security.JWT.JwtClaims.Issuer
const string Issuer
Issuer of the JWT
Definition: JwtClaims.cs:14

Waher.Security.JWT.JwtClaims.Subject
const string Subject
Subject of the JWT (the user)
Definition: JwtClaims.cs:19

Waher.Security.JWT.JwtClaims.ClientId
const string ClientId
Client identifier
Definition: JwtClaims.cs:154

Waher.Security.JWT.JwtClaims.ExpirationTime
const string ExpirationTime
Time after which the JWT expires
Definition: JwtClaims.cs:29

Waher.Things.ThingReference
Contains a reference to a thing
Definition: ThingReference.cs:13

NeuroAccessMaui.Services.Kyc.IKycService.ApplyApplicationReviewAsync
Task ApplyApplicationReviewAsync(KycReference Reference, ApplicationReview Review)
Persists review metadata from the provider.

NeuroAccessMaui.Services.Notification.INotificationServiceV2
Interface for the redesigned notification service.
Definition: INotificationServiceV2.cs:13

NeuroAccessMaui.Services.Tag.ITagProfile
The TAG Profile is the heart of the digital identity for a specific user/device. Use this instance to...
Definition: ITagProfile.cs:18

NeuroAccessMaui.Services.Tag.ITagProfile.NeuroFeaturesJid
string? NeuroFeaturesJid
The XMPP server's Neuro-Features service JID.
Definition: ITagProfile.cs:152

NeuroAccessMaui.Services.Tag.ITagProfile.Step
RegistrationStep Step
This profile's current registration step.
Definition: ITagProfile.cs:172

NeuroAccessMaui.Services.Tag.ITagProfile.IsCompleteOrWaitingForValidation
bool IsCompleteOrWaitingForValidation()
Returns true if the registration process for this ITagProfile is either fully complete or is just awa...

NeuroAccessMaui.Services.Tag.ITagProfile.HttpFileUploadJid
string? HttpFileUploadJid
The XMPP server's file upload Jid.
Definition: ITagProfile.cs:132

NeuroAccessMaui.Services.Tag.ITagProfile.SetLegalIdentity
Task SetLegalIdentity(LegalIdentity? Identity, bool RemoveOldAttachments)
Sets the legal identity of the profile.

NeuroAccessMaui.Services.Tag.ITagProfile.GoToStep
void GoToStep(RegistrationStep NewStep, bool SupressEvent=false)
Changes the current onboarding step.

NeuroAccessMaui.Services.Tag.ITagProfile.HttpFileUploadMaxSize
long HttpFileUploadMaxSize
The XMPP server's max size for file uploads.
Definition: ITagProfile.cs:137

NeuroAccessMaui.Services.Tag.ITagProfile.Account
string? Account
The account name for this profile
Definition: ITagProfile.cs:102

NeuroAccessMaui.Services.Tag.ITagProfile.SetDomain
void SetDomain(string DomainName, bool DefaultXmppConnectivity, string Key, string Secret)
Set the domain name to connect to.

NeuroAccessMaui.Services.Tag.ITagProfile.SetXmppPasswordNeedsUpdating
void SetXmppPasswordNeedsUpdating(bool Value)
Sets the local flag for if xmpp password needs updating.

NeuroAccessMaui.Services.Tag.ITagProfile.RegistryJid
string? RegistryJid
The Thing Registry JID
Definition: ITagProfile.cs:122

NeuroAccessMaui.Services.Tag.ITagProfile.EDalerJid
string? EDalerJid
The XMPP server's eDaler service JID.
Definition: ITagProfile.cs:147

NeuroAccessMaui.Services.Tag.ITagProfile.SetIdentityApplication
Task SetIdentityApplication(LegalIdentity? Identity, bool RemoveOldAttachments)
Sets the legal identity of the profile.

NeuroAccessMaui.Services.Tag.ITagProfile.ShouldCreateClient
bool ShouldCreateClient()
Returns true if the registration process for this ITagProfile has an account but not a legal id,...

NeuroAccessMaui.Services.Tag.ITagProfile.IdentityApplication
LegalIdentity? IdentityApplication
Any current Identity application.
Definition: ITagProfile.cs:227

NeuroAccessMaui.Services.Tag.ITagProfile.LogJid
string? LogJid
The XMPP server's log Jid.
Definition: ITagProfile.cs:142

NeuroAccessMaui.Services.Tag.ITagProfile.ApiKey
string? ApiKey
API Key, for creating new account.
Definition: ITagProfile.cs:62

NeuroAccessMaui.Services.Tag.ITagProfile.LegalJid
string? LegalJid
The Jabber Legal JID for this user/profile.
Definition: ITagProfile.cs:117

NeuroAccessMaui.Services.Tag.ITagProfile.ApiSecret
string? ApiSecret
API Secret, for creating new account.
Definition: ITagProfile.cs:67

NeuroAccessMaui.Services.Tag.ITagProfile.DefaultXmppConnectivity
bool DefaultXmppConnectivity
If connecting to the domain can be done using default parameters (host=domain, default c2s port).
Definition: ITagProfile.cs:57

NeuroAccessMaui.Services.Tag.ITagProfile.SupportsPushNotification
bool SupportsPushNotification
If Push Notification is supported by server.
Definition: ITagProfile.cs:167

NeuroAccessMaui.Services.Tag.ITagProfile.XmppPasswordHash
string? XmppPasswordHash
A hash of the current XMPP password.
Definition: ITagProfile.cs:107

NeuroAccessMaui.Services.Tag.ITagProfile.ClearLegalIdentity
Task ClearLegalIdentity()
Revert the Set LegalIdentity

NeuroAccessMaui.Services.Tag.ITagProfile.SetFileUploadParameters
void SetFileUploadParameters(string httpFileUploadJid, long maxSize)
Used during XMPP service discovery. Sets the file upload parameters.

NeuroAccessMaui.Services.Tag.ITagProfile.CheckContractReference
void CheckContractReference(ContractReference Reference)
Checks if Tag Profile properties need to be changed, with regards to a current ContractReference obje...

NeuroAccessMaui.Services.Tag.ITagProfile.ClearAll
void ClearAll()
Clears the entire profile.

NeuroAccessMaui.Services.Tag.ITagProfile.XmppPasswordHashMethod
string? XmppPasswordHashMethod
The hash method used for hashing the XMPP password.
Definition: ITagProfile.cs:112

NeuroAccessMaui.Services.Tag.ITagProfile.ProvisioningJid
string? ProvisioningJid
The XMPP server's provisioning Jid.
Definition: ITagProfile.cs:127

NeuroAccessMaui.Services.Tag.ITagProfile.LegalIdentity
LegalIdentity? LegalIdentity
The legal identity of the current user/profile.
Definition: ITagProfile.cs:222

NeuroAccessMaui.Services.Tag.ITagProfile.NeedsUpdating
bool NeedsUpdating()
Returns true if the current ITagProfile needs to have its values updated, false otherwise.

NeuroAccessMaui.Services.Tag.ITagProfile.SetAccount
void SetAccount(string AccountName, string ClientPasswordHash, string ClientPasswordHashMethod)
Set the account name and password for a new account.

NeuroAccessMaui.Services.Tag.ITagProfile.Domain
string? Domain
The domain this profile is connected to.
Definition: ITagProfile.cs:52

NeuroAccessMaui.Services.Tag.ITagProfile.PubSubJid
string? PubSubJid
The XMPP server's PubSub JID.
Definition: ITagProfile.cs:157

NeuroAccessMaui.Services.Tag.ITagProfile.GetXmppPasswordNeedsUpdating
bool GetXmppPasswordNeedsUpdating()
Returns true if the current ITagProfile needs to have its Xmpp Password updated, false otherwise.

NeuroAccessMaui.Services.Xmpp.IXmppService.BareJid
string BareJid
The Bare Jid of the current connection, or null.
Definition: IXmppService.cs:82

Waher.Events.IDisposableAsync
Interface for asynchronously disposable objects.
Definition: IDisposableAsync.cs:10

Waher.Events.IDisposableAsync.DisposeAsync
Task DisposeAsync()
Disposes of the object, asynchronously.

Waher.Networking.Sniffers.ISniffer
Interface for sniffers. Sniffers can be added to ICommunicationLayer classes to eavesdrop on communic...
Definition: ISniffer.cs:10

Waher.Persistence.IDatabaseProvider.Flush
Task Flush()
Persists any pending changes.

Waher.Things.IThingReference
Interface for thing references.
Definition: IThingReference.cs:18

_
Definition: ImplTypes.g.cs:58

EDaler.Events
Definition: AccountEventsEventArgs.cs:4

EDaler.Uris
Definition: EDalerContractualPaymentUri.cs:5

EDaler
Definition: AccountEvent.cs:11

NeuroAccessMaui.Extensions
Definition: ArrayExtensions.cs:4

NeuroAccessMaui.Resources.Languages
Definition: AppResources.Designer.cs:11

NeuroAccessMaui.Services.Contacts
Definition: ContactInfo.cs:12

NeuroAccessMaui.Services.Contracts
Definition: ContractOrchestratorService.cs:33

NeuroAccessMaui.Services.Identity
Definition: ApplicationReview.cs:4

NeuroAccessMaui.Services.Kyc.Models
Definition: KycCondition.cs:5

NeuroAccessMaui.Services.Kyc
Definition: ApplicationReviewEventArgs.cs:5

NeuroAccessMaui.Services.Notification.Things
Definition: CanControlNotificationEvent.cs:12

NeuroAccessMaui.Services.Notification.Xmpp
Definition: ChatMessageNotificationEvent.cs:10

NeuroAccessMaui.Services.Notification
Definition: ContractNotificationEvent.cs:10

NeuroAccessMaui.Services.Notification.NotificationAction
NotificationAction
Actions that can be routed from notifications.
Definition: NotificationAction.cs:9

NeuroAccessMaui.Services.Notification.NotificationSource
NotificationSource
Describes the source producing a notification.
Definition: NotificationSource.cs:7

NeuroAccessMaui.Services.Push
Definition: AndroidNotificationRenderer.cs:15

NeuroAccessMaui.Services.Tag
Definition: AuthenticationMethod.cs:2

NeuroAccessMaui.Services.Tag.RegistrationStep
RegistrationStep
The different steps of a TAG Profile registration journey.
Definition: RegistrationStep.cs:7

NeuroAccessMaui.Services.UI.Photos
Definition: Photo.cs:4

NeuroAccessMaui.Services.UI.Photos.Photo
class Photo(byte[] Binary, int Rotation, Attachment? Attachment)
Class containing information about a photo.
Definition: Photo.cs:10

NeuroAccessMaui.Services.Wallet
Definition: INeuroWalletOrchestratorService.cs:4

NeuroAccessMaui.Services.Wallet.OptionsTransaction
class OptionsTransaction(string TransactionId)
Maintains the status of an ongoing retrieval of payment options.
Definition: OptionsTransaction.cs:9

NeuroAccessMaui.Services.Wallet.PaymentTransaction
class PaymentTransaction(string TransactionId, string Currency)
Maintains the status of an ongoing payment transaction.
Definition: PaymentTransaction.cs:10

NeuroAccessMaui.Services.Xmpp
Definition: IXmppService.cs:39

NeuroAccessMaui.UI.Pages.Applications.Applications
Definition: ApplicationsPage.xaml.cs:2

NeuroAccessMaui.UI.Pages.Contacts.Chat
Definition: ChatMessage.cs:8

NeuroAccessMaui.UI.Pages.Contacts
Definition: ChatMessage.cs:8

NeuroAccessMaui.UI.Pages.Kyc
Definition: KycFieldTemplateSelector.cs:10

NeuroAccessMaui.UI.Pages.Onboarding
Definition: BaseOnboardingView.cs:2

NeuroAccessMaui.UI.Pages
Definition: ApplicationsPage.xaml.cs:2

NeuroAccessMaui.UI.Popups.Xmpp.ReportOrBlock
Definition: ReportOrBlockPopup.cs:4

NeuroAccessMaui.UI.Popups.Xmpp.ReportOrBlock.ReportOrBlockAction
ReportOrBlockAction
How to continue when rejecting a subscription request.
Definition: ReportOrBlockViewModel.cs:12

NeuroAccessMaui.UI.Popups.Xmpp.ReportType
Definition: ReportTypePopup.cs:4

NeuroAccessMaui.UI.Popups.Xmpp.SubscribeTo
Definition: SubscribeToPopup.cs:4

NeuroAccessMaui.UI.Popups.Xmpp.SubscriptionRequest
Definition: SubscriptionRequestPopup.cs:4

NeuroAccessMaui.UI.Popups.Xmpp.SubscriptionRequest.PresenceRequestAction
PresenceRequestAction
How to respond to a presence subscription request.
Definition: SubscriptionRequestViewModel.cs:12

NeuroAccessMaui.UI
Definition: AppColors.cs:2

NeuroAccessMaui
Definition: ObservableTaskCommandGenerator.cs:9

NeuroAccessMaui.RegistrationPageMessage
class RegistrationPageMessage(RegistrationStep Step)
RegistrationPage view change message
Definition: Messages.cs:9

NeuroFeatures.EventArguments
Definition: CreationAttributesEventArgs.cs:5

NeuroFeatures.Events
Definition: Created.cs:5

NeuroFeatures
Definition: CreationAttributesEventArgs.cs:5

NeuroFeatures.ReportFormat
ReportFormat
Desired report format
Definition: ReportFormat.cs:7

System.Collections.Generic
Definition: ImplTypes.g.cs:4970

System
Definition: Adapters.g.cs:58

Waher.Content.Dsn.Action
Action
The Action field indicates the action performed by the Reporting-MTA as a result of its attempt to de...
Definition: PerRecipientFields.cs:13

Waher.Content.Html
Definition: CDATA.cs:6

Waher.Content.Markdown
Definition: ConsolidatedTable.cs:11

Waher.Content.Xml
Definition: Attribute.cs:7

Waher.Content
Definition: Array.cs:6

Waher.Content.ToString
delegate string ToString(IElement Element)
Delegate for callback methods that convert an element value to a string.

Waher.Events.Filter
Definition: CustomEventFilter.cs:4

Waher.Events.XMPP
Definition: EventEventArgs.cs:4

Waher.Events
Definition: ConsoleEventSink.cs:8

Waher.Events.EventHandlerAsync
delegate Task EventHandlerAsync(object Sender, EventArgs e)
Asynchronous version of EventArgs.

Waher.Events.EventType
EventType
Type of event.
Definition: EventType.cs:7

Waher.Networking.Sniffers
Definition: BinaryPresentationMethod.cs:2

Waher.Networking.Sniffers.BinaryPresentationMethod
BinaryPresentationMethod
How binary data is to be presented.
Definition: BinaryPresentationMethod.cs:7

Waher.Networking.XMPP.Abuse
Definition: AbuseClient.cs:11

Waher.Networking.XMPP.Abuse.ReportingReason
ReportingReason
Reason for blocking.
Definition: AbuseClient.cs:16

Waher.Networking.XMPP.AuthenticationErrors
Definition: AccountDisabledException.cs:4

Waher.Networking.XMPP.Concentrator
Definition: ConcentratorClient.cs:20

Waher.Networking.XMPP.Contracts.EventArguments
Definition: ClientMessageEventArgs.cs:4

Waher.Networking.XMPP.Contracts
Definition: AltitudeUse.cs:2

Waher.Networking.XMPP.Contracts.IdentityState
IdentityState
Lists recognized legal identity states.
Definition: LegalIdentity.cs:17

Waher.Networking.XMPP.Contracts.SignWith
SignWith
Options on what keys to use when signing data.
Definition: Enumerations.cs:82

Waher.Networking.XMPP.Contracts.ContractParts
ContractParts
How the parts of the contract are defined.
Definition: Part.cs:9

Waher.Networking.XMPP.Contracts.ContractVisibility
ContractVisibility
Visibility types for contracts.
Definition: Enumerations.cs:56

Waher.Networking.XMPP.Contracts.IdentityStatus
IdentityStatus
Validation Status of legal identity
Definition: IdentityStatus.cs:7

Waher.Networking.XMPP.Control
Definition: ControlClient.cs:14

Waher.Networking.XMPP.DataForms
Definition: DataForm.cs:16

Waher.Networking.XMPP.Events
Definition: AuthorityEventArgs.cs:4

Waher.Networking.XMPP.HTTPX
Definition: Aes256Getter.cs:12

Waher.Networking.XMPP.HttpFileUpload
Definition: FilePurpose.cs:2

Waher.Networking.XMPP.PEP.Events
Definition: PersonalEventNotificationEventArgs.cs:4

Waher.Networking.XMPP.PEP
Definition: PersonalEventNotificationEventArgs.cs:4

Waher.Networking.XMPP.Provisioning.Events
Definition: CanControlEventArgs.cs:11

Waher.Networking.XMPP.Provisioning.SearchOperators
Definition: NumericTagEqualTo.cs:2

Waher.Networking.XMPP.Provisioning
Definition: CachedQuery.cs:5

Waher.Networking.XMPP.Provisioning.RuleRange
RuleRange
Range of a rule change
Definition: RuleRange.cs:7

Waher.Networking.XMPP.PubSub.Events
Definition: AffiliationNotificationEventArgs.cs:4

Waher.Networking.XMPP.PubSub
Definition: Affiliation.cs:2

Waher.Networking.XMPP.Push
Definition: ClientType.cs:2

Waher.Networking.XMPP.Push.ClientType
ClientType
Type of client requesting notification.
Definition: ClientType.cs:7

Waher.Networking.XMPP.Push.PushMessagingService
PushMessagingService
Push messaging service used.
Definition: PushMessagingService.cs:7

Waher.Networking.XMPP.ResultSetManagement
Definition: RestrictedQuery.cs:6

Waher.Networking.XMPP.Sensor
Definition: ApprovedReadoutParameters.cs:5

Waher.Networking.XMPP.ServiceDiscovery
Definition: Identity.cs:6

Waher.Networking.XMPP.StanzaErrors
Definition: BadRequestException.cs:4

Waher.Networking.XMPP.StreamErrors
Definition: BadFormatException.cs:4

Waher.Networking.XMPP
Definition: Avatar.cs:6

Waher.Networking.XMPP.Availability
Availability
Resource availability.
Definition: Availability.cs:7

Waher.Networking.XMPP.QoSLevel
QoSLevel
Quality of Service Level for asynchronous messages. Support for QoS Levels must be supported by the r...
Definition: QoSLevel.cs:8

Waher.Networking.XMPP.SubscriptionState
SubscriptionState
State of a presence subscription.
Definition: RosterItem.cs:16

Waher.Networking.XMPP.MessageType
MessageType
Type of message received.
Definition: MessageType.cs:7

Waher.Networking.XMPP.XmppState
XmppState
State of XMPP connection.
Definition: XmppState.cs:7

Waher.Networking
Definition: Program.cs:9

Waher.Persistence.Filters
Definition: Filter.cs:2

Waher.Persistence
Definition: Bookmark.cs:4

Waher.Runtime.Inventory
Definition: TypesLoader.cs:9

Waher.Runtime.Settings
Definition: EnvironmentSettings.cs:7

Waher.Runtime.Temporary
Definition: IoBytesEventArgs.cs:4

Waher.Script.Constants
Definition: C.cs:6

Waher.Security.JWT
Definition: AudienceEventArgs.cs:4

Waher.Security.JWT.Reason
Reason
Reason a token is not valid.
Definition: JwtFactory.cs:15

Waher.Service.IoTBroker.WebServices.Agent.StateMachines.ReportType
ReportType
Type of report to generate
Definition: CreateReport.cs:23

Waher.Things.SensorData
Definition: BooleanField.cs:6

Waher.Things.SensorData.FieldType
FieldType
Field Type flags
Definition: FieldType.cs:10

Waher.Things
Definition: AnalogInput.cs:15

Waher
Definition: App.xaml.cs:4

Waher.Content.Duration
Represents a duration value, as defined by the xsd:duration data type: http://www....
Definition: Duration.cs:14