ExternalRequest.cs

using System;
using Waher.Networking.XMPP.Server;
using Waher.Persistence;
 
namespace Waher.Service.IoTBroker.EDaler.Uris.States
{
    public class ExternalRequest : EDalerUriState
    {
        private readonly IqEventArgs request;
        private bool responseReturned = false;
 
        public ExternalRequest(IqEventArgs Request)
            : base()
        {
            this.request = Request;
        }
 
        public override void Error(EDalerUriErrorType ErrorType, string ErrorMessage, bool LogAsNotice)
        {
            if (!this.responseReturned)
            {
                this.responseReturned = true;
 
                switch (ErrorType)
                {
                    case EDalerUriErrorType.BadRequest:
                        this.request.IqErrorBadRequest(this.request.To, ErrorMessage, "en");
                        break;
 
                    case EDalerUriErrorType.Forbidden:
                        this.request.IqErrorForbidden(this.request.To, ErrorMessage, "en");
                        break;
 
                    case EDalerUriErrorType.ResourceConstraint:
                        this.request.IqErrorResourceConstraint(this.request.To, ErrorMessage, "en");
                        break;
 
                    case EDalerUriErrorType.Conflict:
                        this.request.IqErrorConflict(this.request.To, ErrorMessage, "en");
                        break;
 
                    case EDalerUriErrorType.ServiceUnavailable:
                    case EDalerUriErrorType.Internal:
                    case EDalerUriErrorType.Remote:
                    default:
                        this.request.IqErrorServiceUnavailable(this.request.To, ErrorMessage, "en");
                        break;
                }
 
                base.Error(ErrorType, ErrorMessage, LogAsNotice);
            }
        }
 
        public override void Error(string ErrorType, string ErrorXml, string ErrorMessage)
        {
            if (!this.responseReturned)
            {
                this.responseReturned = true;
                this.request.IqError(ErrorType, ErrorXml, this.request.To, ErrorMessage, string.Empty);
 
                base.Error(ErrorType, ErrorXml, ErrorMessage);
            }
        }
 
        public override void Error(Exception Exception)
        {
            if (!this.responseReturned)
            {
                this.responseReturned = true;
                this.request.IqError(Exception, this.request.To);
 
                base.Error(Exception);
            }
        }
 
        public override void Result(string Xml)
        {
            if (!this.responseReturned)
            {
                this.responseReturned = true;
                this.request.IqResult(Xml, this.request.To);
                
                base.Result(Xml);
            }
        }
 
        public override XmppAddress For
        {
            get
            {
                if (this.request.From.IsDomain && this.request.Query.HasAttribute("for"))
                    return new XmppAddress(this.request.Query.GetAttribute("for")).ToBareJID();
                else if (!this.request.From.IsDomain)
                    return this.request.From.ToBareJID();
                else
                    return null;
            }
        }
 
        public override CaseInsensitiveString Sender => this.request.From.Address;
 
        public override CaseInsensitiveString OriginalSender
        {
            get
            {
                string s = this.Sender;
 
                if (this.request.From.IsDomain && this.request.Query.HasAttribute("for"))
                    s = this.request.Query.GetAttribute("for");
 
                return s;
            }
        }
 
        public override bool Relayed => this.request.From.IsDomain;
 
    }
}