BrokerNotificationConfiguration.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Content;
using Waher.IoTGateway;
using Waher.IoTGateway.Setup;
using Waher.Networking.HTTP;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Language;
 
namespace Waher.Service.IoTBroker.Setup
{
    public class BrokerNotificationConfiguration : SystemConfiguration
    {
        private static BrokerNotificationConfiguration instance = null;
 
        private HttpResource setRegistration = null;
 
        private bool accountCreated = true;
        private bool accountDeleted = true;
        private bool legalIdReceived = true;
        private bool otherLegalIds = true;
        private bool peerReviewApproved = true;
        private bool legalIdAutoApproved = true;
        private bool legalIdAutoRejected = true;
        private bool contractProposalReceived = true;
        private bool accountRecoveryRequest = true;
        private bool apiKeyCreated = true;
        private bool feedbackReceived = true;
        private bool accountRequested = true;
        private bool apiKeyRequested = true;
 
        public static BrokerNotificationConfiguration Instance => instance;
 
        public override string Resource => "/Settings/BrokerNotifications.md";
 
        public override int Priority => 610;
 
        [DefaultValue(true)]
        public bool AccountCreated
        {
            get => this.accountCreated;
            set => this.accountCreated = value;
        }
 
        [DefaultValue(true)]
        public bool AccountDeleted
        {
            get => this.accountDeleted;
            set => this.accountDeleted = value;
        }
 
        [DefaultValue(true)]
        public bool LegalIdReceived
        {
            get => this.legalIdReceived;
            set => this.legalIdReceived = value;
        }
 
        [DefaultValue(true)]
        public bool OtherLegalIds
        {
            get => this.otherLegalIds;
            set => this.otherLegalIds = value;
        }
 
        [DefaultValue(true)]
        public bool PeerReviewApproved
        {
            get => this.peerReviewApproved;
            set => this.peerReviewApproved = value;
        }
 
        [DefaultValue(true)]
        public bool LegalIdAutoApproved
        {
            get => this.legalIdAutoApproved;
            set => this.legalIdAutoApproved = value;
        }
 
        [DefaultValue(true)]
        public bool LegalIdAutoRejected
        {
            get => this.legalIdAutoRejected;
            set => this.legalIdAutoRejected = value;
        }
 
        [DefaultValue(true)]
        public bool ContractProposalReceived
        {
            get => this.contractProposalReceived;
            set => this.contractProposalReceived = value;
        }
 
        [DefaultValue(true)]
        public bool AccountRecoveryRequest
        {
            get => this.accountRecoveryRequest;
            set => this.accountRecoveryRequest = value;
        }
 
        [DefaultValue(true)]
        public bool ApiKeyCreated
        {
            get => this.apiKeyCreated;
            set => this.apiKeyCreated = value;
        }
 
        [DefaultValue(true)]
        public bool FeedbackReceived
        {
            get => this.feedbackReceived;
            set => this.feedbackReceived = value;
        }
 
        [DefaultValue(true)]
        public bool AccountRequested
        {
            get => this.accountRequested;
            set => this.accountRequested = value;
        }
 
        [DefaultValue(true)]
        public bool ApiKeyRequested
        {
            get => this.apiKeyRequested;
            set => this.apiKeyRequested = value;
        }
 
        public override Task<string> Title(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 44, "Broker Notifications");
        }
 
        public override Task ConfigureSystem()
        {
            return Task.CompletedTask;
        }
 
        public override void SetStaticInstance(ISystemConfiguration Configuration)
        {
            instance = Configuration as BrokerNotificationConfiguration;
        }
 
        public override Task InitSetup(HttpServer WebServer)
        {
            this.setRegistration = WebServer.Register("/Settings/SetBrokerNotifications",
                null, this.SetRegistration, true, false, true);
 
            return base.InitSetup(WebServer);
        }
 
        protected override string ConfigPrivilege => "Admin.Broker.Notifications";
 
        private async Task SetRegistration(HttpRequest Request, HttpResponse Response)
        {
            Gateway.AssertUserAuthenticated(Request, this.ConfigPrivilege);
 
            if (!Request.HasData)
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            ContentResponse Content = await Request.DecodeDataAsync();
            if (Content.HasError ||
                !(Content.Decoded is Dictionary<string, object> Parameters))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Parameters.TryGetValue("accountCreated", out object Obj) || !(Obj is bool AccountCreated) ||
                !Parameters.TryGetValue("accountDeleted", out Obj) || !(Obj is bool AccountDeleted) ||
                !Parameters.TryGetValue("legalIdReceived", out Obj) || !(Obj is bool LegalIdReceived) ||
                !Parameters.TryGetValue("otherLegalIds", out Obj) || !(Obj is bool OtherLegalIds) ||
                !Parameters.TryGetValue("peerReviewApproved", out Obj) || !(Obj is bool PeerReviewApproved) ||
                !Parameters.TryGetValue("legalIdAutoApproved", out Obj) || !(Obj is bool LegalIdAutoApproved) ||
                !Parameters.TryGetValue("legalIdAutoRejected", out Obj) || !(Obj is bool LegalIdAutoRejected) ||
                !Parameters.TryGetValue("contractProposalReceived", out Obj) || !(Obj is bool ContractProposalReceived) ||
                !Parameters.TryGetValue("accountRecoveryRequest", out Obj) || !(Obj is bool AccountRecoveryRequest) ||
                !Parameters.TryGetValue("apiKeyCreated", out Obj) || !(Obj is bool ApiKeyCreated) ||
                !Parameters.TryGetValue("feedbackReceived", out Obj) || !(Obj is bool FeedbackReceived) ||
                !Parameters.TryGetValue("accountRequested", out Obj) || !(Obj is bool AccountRequested) ||
                !Parameters.TryGetValue("apiKeyRequested", out Obj) || !(Obj is bool ApiKeyRequested))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            this.accountCreated = AccountCreated;
            this.accountDeleted = AccountDeleted;
            this.legalIdReceived = LegalIdReceived;
            this.otherLegalIds = OtherLegalIds;
            this.peerReviewApproved = PeerReviewApproved;
            this.legalIdAutoApproved = LegalIdAutoApproved;
            this.legalIdAutoRejected = LegalIdAutoRejected;
            this.contractProposalReceived = ContractProposalReceived;
            this.accountRecoveryRequest = AccountRecoveryRequest;
            this.apiKeyCreated = ApiKeyCreated;
            this.feedbackReceived = FeedbackReceived;
            this.accountRequested = AccountRequested;
            this.apiKeyRequested = ApiKeyRequested;
 
            Response.StatusCode = 200;
            Response.StatusMessage = "OK";
 
            await Database.Update(this);
        }
 
        public override Task UnregisterSetup(HttpServer WebServer)
        {
            WebServer.Unregister(this.setRegistration);
 
            return base.UnregisterSetup(WebServer);
        }
 
        public override Task<bool> SimplifiedConfiguration()
        {
            this.accountCreated = true;
            this.accountDeleted = true;
            this.legalIdReceived = true;
            this.otherLegalIds = true;
            this.peerReviewApproved = true;
            this.legalIdAutoApproved = true;
            this.legalIdAutoRejected = true;
            this.contractProposalReceived = true;
            this.accountRecoveryRequest = true;
            this.apiKeyCreated = true;
            this.feedbackReceived = true;
            this.accountRequested = true;
            this.apiKeyRequested = true;
 
            return Task.FromResult(true);
        }
 
        public string BROKER_NOT_ACCOUNT_CREATED = nameof(BROKER_NOT_ACCOUNT_CREATED);
 
        public string BROKER_NOT_ACCOUNT_DELETED = nameof(BROKER_NOT_ACCOUNT_DELETED);
 
        public string BROKER_NOT_LEGAL_ID_RECEIVED = nameof(BROKER_NOT_LEGAL_ID_RECEIVED);
 
        public string BROKER_NOT_OTHER_LEGAL_IDS = nameof(BROKER_NOT_OTHER_LEGAL_IDS);
 
        public string BROKER_NOT_PEER_REVIEW_APPROVED = nameof(BROKER_NOT_PEER_REVIEW_APPROVED);
 
        public string BROKER_NOT_LEGAL_ID_AUTO_APPROVED = nameof(BROKER_NOT_LEGAL_ID_AUTO_APPROVED);
 
        public string BROKER_NOT_LEGAL_ID_AUTO_REJECTED = nameof(BROKER_NOT_LEGAL_ID_AUTO_REJECTED);
 
        public string BROKER_NOT_CONTRACT_PROPOSAL_RECEIVED = nameof(BROKER_NOT_CONTRACT_PROPOSAL_RECEIVED);
 
        public string BROKER_NOT_ACCOUNT_RECOVERY_REQUEST = nameof(BROKER_NOT_ACCOUNT_RECOVERY_REQUEST);
 
        public string BROKER_NOT_API_KEY_CREATED = nameof(BROKER_NOT_API_KEY_CREATED);
 
        public string BROKER_NOT_FEEDBACK_RECEIVED = nameof(BROKER_NOT_FEEDBACK_RECEIVED);
 
        public string BROKER_NOT_ACCOUNT_REQUESTED = nameof(BROKER_NOT_ACCOUNT_REQUESTED);
 
        public string BROKER_NOT_API_KEY_REQUESTED = nameof(BROKER_NOT_API_KEY_REQUESTED);
 
        public override Task<bool> EnvironmentConfiguration()
        {
            if (!this.TryGetEnvironmentVariable(BROKER_NOT_ACCOUNT_CREATED, out this.accountCreated, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_ACCOUNT_DELETED, out this.accountDeleted, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_LEGAL_ID_RECEIVED, out this.legalIdReceived, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_OTHER_LEGAL_IDS, out this.otherLegalIds, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_PEER_REVIEW_APPROVED, out this.peerReviewApproved, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_LEGAL_ID_AUTO_APPROVED, out this.legalIdAutoApproved, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_LEGAL_ID_AUTO_REJECTED, out this.legalIdAutoRejected, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_CONTRACT_PROPOSAL_RECEIVED, out this.contractProposalReceived, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_ACCOUNT_RECOVERY_REQUEST, out this.accountRecoveryRequest, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_API_KEY_CREATED, out this.apiKeyCreated, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_FEEDBACK_RECEIVED, out this.feedbackReceived, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_ACCOUNT_REQUESTED, out this.accountRequested, true) ||
                !this.TryGetEnvironmentVariable(BROKER_NOT_API_KEY_REQUESTED, out this.apiKeyRequested, true))
            {
                return Task.FromResult(false);
            }
 
            return Task.FromResult(true);
        }
 
    }
}