NotificationConfiguration.cs

using System;
using System.Collections.Generic;
using System.Net.Mail;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Markdown;
using Waher.Networking.HTTP;
using Waher.Networking.XMPP;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.Language;
 
namespace Waher.IoTGateway.Setup
{
    public class NotificationConfiguration : SystemConfiguration
    {
        private static NotificationConfiguration instance = null;
        private HttpResource testAddresses = null;
 
        private CaseInsensitiveString[] addresses = new CaseInsensitiveString[0];
 
        public NotificationConfiguration()
            : base()
        {
        }
 
        public static NotificationConfiguration Instance => instance;
 
        [DefaultValueNull]
        public CaseInsensitiveString[] Addresses
        {
            get => this.addresses;
            set => this.addresses = value;
        }
 
        public string AddressesString
        {
            get
            {
                StringBuilder sb = new StringBuilder();
                bool First = true;
 
                foreach (string s in this.addresses)
                {
                    if (First)
                        First = false;
                    else
                        sb.Append("; ");
 
                    sb.Append(s);
                }
 
                return sb.ToString();
            }
        }
 
        public override string Resource => "/Settings/Notification.md";
 
        public override int Priority => 600;
 
        public override Task<string> Title(Language Language)
        {
            return Language.GetStringAsync(typeof(Gateway), 2, "Notification");
        }
 
        public override Task ConfigureSystem()
        {
            return Task.CompletedTask;
        }
 
        public override void SetStaticInstance(ISystemConfiguration Configuration)
        {
            instance = Configuration as NotificationConfiguration;
        }
 
        public override Task InitSetup(HttpServer WebServer)
        {
            this.testAddresses = WebServer.Register("/Settings/TestNotificationAddresses", null, this.TestNotificationAddresses, true, false, true);
 
            return base.InitSetup(WebServer);
        }
 
        public override Task UnregisterSetup(HttpServer WebServer)
        {
            WebServer.Unregister(this.testAddresses);
 
            return base.UnregisterSetup(WebServer);
        }
 
        protected override string ConfigPrivilege => "Admin.Communication.Notification";
 
        private async Task TestNotificationAddresses(HttpRequest Request, HttpResponse Response)
        {
            Gateway.AssertUserAuthenticated(Request, this.ConfigPrivilege);
 
            if (!Request.HasData)
                throw new BadRequestException();
 
            object Obj = await Request.DecodeDataAsync();
            if (!(Obj is string Address))
                throw new BadRequestException();
 
            string TabID = Request.Header["X-TabID"];
 
            List<CaseInsensitiveString> Addresses = new List<CaseInsensitiveString>();
 
            Response.StatusCode = 200;
 
            try
            {
                foreach (string Part in Address.Split(';'))
                {
                    string s = Part.Trim();
                    if (string.IsNullOrEmpty(s))
                        continue;
 
                    if (string.Compare(s, Gateway.XmppClient.BareJID, true) == 0)
                        continue;
 
                    MailAddress Addr = new MailAddress(s);
                    Addresses.Add(Addr.Address);
                }
 
                this.addresses = Addresses.ToArray();
 
                await Database.Update(this);
 
                if (this.addresses.Length > 0)
                {
                    await Gateway.SendNotification("Test\r\n===========\r\n\r\nThis message was generated to test the notification feature of **" +
                        MarkdownDocument.Encode(Gateway.ApplicationName) + "**.");
                }
 
                if (!string.IsNullOrEmpty(TabID))
                    await Response.Write(1);
            }
            catch (Exception ex)
            {
                if (!string.IsNullOrEmpty(TabID))
                    await Response.Write(0);
                else
                    throw new BadRequestException(ex.Message);
            }
 
            await Response.SendResponse();
        }
 
        public override Task<bool> SimplifiedConfiguration()
        {
            return Task.FromResult(true);
        }
 
        public const string GATEWAY_NOTIFICATION_JIDS = nameof(GATEWAY_NOTIFICATION_JIDS);
 
        public override Task<bool> EnvironmentConfiguration()
        {
            CaseInsensitiveString Value = Environment.GetEnvironmentVariable(GATEWAY_NOTIFICATION_JIDS);
            if (CaseInsensitiveString.IsNullOrEmpty(Value))
                return Task.FromResult(false);
 
            CaseInsensitiveString[] Jids = Value.Split(',');
            foreach (CaseInsensitiveString Jid in Jids)
            {
                if (!XmppClient.BareJidRegEx.IsMatch(Jid))
                {
                    this.LogEnvironmentError("Invalid JID.", GATEWAY_NOTIFICATION_JIDS, Jid);
                    return Task.FromResult(false);
                }
            }
 
            this.addresses = Jids;
 
            return Task.FromResult(true);
        }
 
    }
}