PushNotificationConfiguration.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Html.JavaScript;
using Waher.Content.Json;
using Waher.Content.Markdown.Functions;
using Waher.Events;
using Waher.IoTGateway;
using Waher.IoTGateway.Setup;
using Waher.Networking.HTTP;
using Waher.Networking.HTTP.Firebase;
using Waher.Networking.Sniffers;
using Waher.Networking.XMPP.Server.PushNotification;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Runtime.IO;
using Waher.Runtime.Language;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Service.IoTBroker.Setup
{
    public class PushNotificationConfiguration : SystemMultiStepConfiguration
    {
        private static PushNotificationConfiguration instance = null;
        private static FirebaseClient firebaseClient = null;
 
        private string firebaseServiceAccountJson = string.Empty;
        private string firebaseApiKey = string.Empty;
        private string firebaseAuthDomain = string.Empty;
        private string firebaseProjectId = string.Empty;
        private string firebaseStorageBucket = string.Empty;
        private string firebaseMessagingSenderId = string.Empty;
        private string firebaseAppId = string.Empty;
        private string firebaseWebPushPublicKey = string.Empty;
 
        private DateTime firebaseServiceAccountJsonUploaded = DateTime.MinValue;
        private bool useFirebase = false;
 
        private HttpResource firebaseWebPushJavascript = null;
        private HttpResource testFirebaseConnection = null;
        private HttpResource testFirebaseNotification = null;
 
        [DefaultValueStringEmpty]
        public string FirebaseServiceAccountJson
        {
            get => this.firebaseServiceAccountJson;
            set => this.firebaseServiceAccountJson = value;
        }
 
        [DefaultValueStringEmpty]
        public string FirebaseApiKey
        {
            get => this.firebaseApiKey;
            set => this.firebaseApiKey = value;
        }
 
        [DefaultValueStringEmpty]
        public string FirebaseAuthDomain
        {
            get => this.firebaseAuthDomain;
            set => this.firebaseAuthDomain = value;
        }
 
        [DefaultValueStringEmpty]
        public string FirebaseProjectId
        {
            get => this.firebaseProjectId;
            set => this.firebaseProjectId = value;
        }
 
        [DefaultValueStringEmpty]
        public string FirebaseStorageBucket
        {
            get => this.firebaseStorageBucket;
            set => this.firebaseStorageBucket = value;
        }
 
        [DefaultValueStringEmpty]
        public string FirebaseMessagingSenderId
        {
            get => this.firebaseMessagingSenderId;
            set => this.firebaseMessagingSenderId = value;
        }
 
        [DefaultValueStringEmpty]
        public string FirebaseAppId
        {
            get => this.firebaseAppId;
            set => this.firebaseAppId = value;
        }
 
        public string FirebaseWebPushPublicKey
        {
            get => this.firebaseWebPushPublicKey;
            set => this.firebaseWebPushPublicKey = value;
        }
 
        [DefaultValueDateTimeMinValue]
        public DateTime FirebaseServiceAccountJsonUploaded
        {
            get => this.firebaseServiceAccountJsonUploaded;
            set => this.firebaseServiceAccountJsonUploaded = value;
        }
 
        [DefaultValue(false)]
        public bool UseFirebase
        {
            get => this.useFirebase;
            set => this.useFirebase = value;
        }
 
        public static FirebaseClient FirebaseClient => firebaseClient;
 
        public static PushNotificationConfiguration Instance => instance;
 
        public override string Resource => "/Settings/PushNotification.md";
 
        public override int Priority => 460;
 
        public override Task<string> Title(Language Language)
        {
            return Language.GetStringAsync(typeof(XmppServerModule), 41, "Push Notification");
        }
 
        public override async Task ConfigureSystem()
        {
            firebaseClient?.Dispose();
            firebaseClient = null;
 
            if (this.useFirebase && !string.IsNullOrEmpty(this.firebaseServiceAccountJson))
                firebaseClient = await GetClient(this.firebaseServiceAccountJson);
        }
 
        private static async Task<FirebaseClient> GetClient(string ServiceAccountJson)
        {
            if (XmppConfiguration.Instance.Sniffer)
            {
                ISniffer Sniffer = new XmlFileSniffer(Gateway.AppDataFolder + "Firebase" + Path.DirectorySeparatorChar +
                    "Firebase Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml",
                    Gateway.AppDataFolder + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",
                    7, BinaryPresentationMethod.ByteCount);
 
                return await FirebaseClient.CreateAsync(ServiceAccountJson, false, Sniffer);
            }
            else
                return await FirebaseClient.CreateAsync(ServiceAccountJson, false);
        }
 
        public override void SetStaticInstance(ISystemConfiguration Configuration)
        {
            instance = Configuration as PushNotificationConfiguration;
        }
 
        public override Task InitSetup(HttpServer WebServer)
        {
            this.firebaseWebPushJavascript = WebServer.Register("/Settings/FirebaseWebPush.js",
                this.FirebaseWebPushJs, true, false, false);
            this.testFirebaseConnection = WebServer.Register("/Settings/TestFirebaseConnection",
                null, this.TestFirebaseConnection, true, false, true);
            this.testFirebaseNotification = WebServer.Register("/Settings/TestFirebaseNotification",
                null, this.TestFirebaseNotification, true, false, true);
 
            return base.InitSetup(WebServer);
        }
 
        public override Task UnregisterSetup(HttpServer WebServer)
        {
            WebServer.Unregister(this.testFirebaseConnection);
            WebServer.Unregister(this.testFirebaseNotification);
 
            return base.UnregisterSetup(WebServer);
        }
 
        protected override string ConfigPrivilege => "Admin.Communication.PushNotification";
 
        private async Task FirebaseWebPushJs(HttpRequest Request, HttpResponse Response)
        {
            Response.StatusCode = 200;
            Response.StatusMessage = "OK";
            Response.ContentType = JavaScriptCodec.DefaultContentType;
 
            StringBuilder sb = new StringBuilder();
 
            sb.AppendLine("import { initializeApp } from 'https://www.gstatic.com/firebasejs/10.12.4/firebase-app.js';");
            sb.AppendLine("import { getMessaging, getToken } from 'https://www.gstatic.com/firebasejs/10.12.4/firebase-messaging.js';");
            sb.AppendLine();
            sb.AppendLine("const firebaseConfig =");
            sb.AppendLine("{");
            sb.Append("\tapiKey: '");
            sb.Append(this.firebaseApiKey);
            sb.AppendLine("',");
            sb.Append("\tauthDomain: '");
            sb.Append(this.firebaseAuthDomain);
            sb.AppendLine("',");
            sb.Append("\tprojectId: '");
            sb.Append(this.firebaseProjectId);
            sb.AppendLine("',");
            sb.Append("\tstorageBucket: '");
            sb.Append(this.firebaseStorageBucket);
            sb.AppendLine("',");
            sb.Append("\tmessagingSenderId: '");
            sb.Append(this.firebaseMessagingSenderId);
            sb.AppendLine("',");
            sb.Append("\tappId: '");
            sb.Append(this.firebaseAppId);
            sb.AppendLine("'");
            sb.AppendLine("};");
            sb.AppendLine();
            sb.AppendLine("const app = initializeApp(firebaseConfig);");
            sb.AppendLine("const messaging = getMessaging(app);");
            sb.AppendLine();
            sb.AppendLine("window.GetFirebaseToken = function GetFirebaseToken()");
            sb.AppendLine("{");
            sb.AppendLine("\tgetToken(messaging, { vapidKey: '" + this.firebaseWebPushPublicKey + "'}).then(");
            sb.AppendLine("\t\t(token) =>");
            sb.AppendLine("\t\t{");
            sb.AppendLine("\t\t\tif (token)");
            sb.AppendLine("\t\t\t\tFirebaseTokenReceived(token);");
            sb.AppendLine("\t\t\telse");
            sb.AppendLine("\t\t\t\tFirebaseTokenRejected();");
            sb.AppendLine("\t\t}).catch((error) => FirebaseTokenFailure(error));");
            sb.AppendLine("};");
 
            await Response.Write(sb.ToString());
        }
 
        private async Task TestFirebaseConnection(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> Form) ||
                !Form.TryGetValue("useFirebase", out object Obj) || !(Obj is bool UseFirebase))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            if (!Form.TryGetValue("firebaseWebConfig", out Obj) ||
                !(Obj is string FirebaseWebConfigJson) ||
                string.IsNullOrEmpty(FirebaseWebConfigJson))
            {
                FirebaseWebConfigJson = null;
            }
 
            if (!Form.TryGetValue("firebaseWebPushPublicKey", out Obj) ||
                !(Obj is string FirebaseWebPushPublicKey))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            this.firebaseWebPushPublicKey = FirebaseWebPushPublicKey;
 
            if (!Form.TryGetValue("serviceAccountJson", out Obj) ||
                !(Obj is string ServiceAccountJson) ||
                string.IsNullOrEmpty(ServiceAccountJson))
            {
                ServiceAccountJson = this.firebaseServiceAccountJson;
            }
 
            if (Form.TryGetValue("firebaseMessagingSwJsContents", out Obj) &&
                Obj is string FirebaseMessagingSwJsContents)
            {
                await DomainSettings.SetSettingAsync(Request, Path.Combine(Gateway.RootFolder, "firebase-messaging-sw.js"),
                    FirebaseMessagingSwJsContents);
            }
 
            string TabID = Request.Header["X-TabID"];
            if (string.IsNullOrEmpty(TabID))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            bool Ok = await this.Test(UseFirebase, FirebaseWebConfigJson, ServiceAccountJson, TabID);
 
            string TimestampHtml = await MarkdownToHtml.ToHtml("JSON file uploaded: **{{Config.FirebaseServiceAccountJsonUploaded}}**.",
                new Variables()
                {
                    { "Config", this }
                });
 
            Response.StatusCode = 200;
            Response.StatusMessage = "OK";
            await Response.Return(new Dictionary<string, object>()
            {
                { "ok", Ok },
                { "timestampHtml", TimestampHtml }
            });
        }
 
        private async Task<bool> Test(bool UseFirebase, string FirebaseWebConfigJson, string ServiceAccountJson, params string[] TabIDs)
        {
            try
            {
                this.useFirebase = UseFirebase;
 
                if (this.firebaseServiceAccountJson != ServiceAccountJson)
                {
                    this.firebaseServiceAccountJson = ServiceAccountJson;
                    this.firebaseServiceAccountJsonUploaded = DateTime.Now;
                }
 
                if (!string.IsNullOrEmpty(FirebaseWebConfigJson))
                {
                    if (!(JSON.Parse(FirebaseWebConfigJson) is Dictionary<string, object> FirebaseWebConfig))
                        throw new Exception("Invalid Web Configuration JSON object.");
 
                    foreach (KeyValuePair<string, object> P in FirebaseWebConfig)
                    {
                        if (!(P.Value is string Value))
                            throw new Exception("Web Configuration object values must be strings.");
 
                        switch (P.Key)
                        {
                            case "apiKey":
                                this.firebaseApiKey = Value;
                                break;
 
                            case "authDomain":
                                this.firebaseAuthDomain = Value;
                                break;
 
                            case "projectId":
                                this.firebaseProjectId = Value;
                                break;
 
                            case "storageBucket":
                                this.firebaseStorageBucket = Value;
                                break;
 
                            case "messagingSenderId":
                                this.firebaseMessagingSenderId = Value;
                                break;
 
                            case "appId":
                                this.firebaseAppId = Value;
                                break;
 
                            default:
                                throw new Exception("Unrecognized property: " + P.Key);
                        }
                    }
                }
 
                await Database.Update(this);
 
                if (UseFirebase)
                {
                    FirebaseClient Client = null;
 
                    try
                    {
                        Client = await GetClient(ServiceAccountJson);
 
                        if (Client.ProjectId != this.firebaseProjectId)
                            throw new Exception("Inconsistency between mobile phone and web Project IDs");
 
                        await ClientEvents.PushEvent(TabIDs, "ConnectionSuccessful", string.Empty, false, "User");
 
                        firebaseClient?.Dispose();
                        firebaseClient = Client;
                        Client = null;
 
                        return true;
                    }
                    finally
                    {
                        Client?.Dispose();
                    }
                }
                else
                {
                    firebaseClient?.Dispose();
                    firebaseClient = null;
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
                await ClientEvents.PushEvent(TabIDs, "ConnectionError", string.Empty, false, "User");
                await ClientEvents.PushEvent(TabIDs, "ShowStatus", ex.Message, false, "User");
            }
 
            return false;
        }
 
        private async Task TestFirebaseNotification(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> Form) ||
                !Form.TryGetValue("token", out object Obj) || !(Obj is string Token) ||
                !Form.TryGetValue("title", out Obj) || !(Obj is string Title) ||
                !Form.TryGetValue("body", out Obj) || !(Obj is string Body))
            {
                await Response.SendResponse(new BadRequestException());
                return;
            }
 
            using FirebaseClient Client = await GetClient(this.firebaseServiceAccountJson);
            NotificationResponse FirebaseResponse = await Client.SendNotification(Token, new NotificationMessage()
            {
                Title = Title,
                Body = Body
            });
 
            Response.StatusCode = 200;
            Response.StatusMessage = "OK";
            Response.ContentType = JsonCodec.DefaultContentType;
 
            await Response.Write(JSON.Encode(new Dictionary<string, object>()
                {
                    { "ok", FirebaseResponse.Ok },
                    { "errorMessage", FirebaseResponse.ErrorMessage }
                }, false));
        }
 
        public override Task<bool> SimplifiedConfiguration()
        {
            return Task.FromResult(true);
        }
 
        internal static async void PushNotification(PushNotificationToken Token, object Content, PushNotificationRule Rule)
        {
            try
            {
                switch (Token.Service)
                {
                    case PushMessagingService.Firebase:
                        NotificationBuilder Builder = new NotificationBuilder(Token.ClientType);
 
                        if (!PushNotificationPayload.TryParse(Content, out PushNotificationPayload Payload))
                        {
                            StringBuilder sb = new StringBuilder();
                            sb.AppendLine("Push notification payload could not be parsed.");
                            sb.AppendLine();
                            sb.AppendLine("Pattern-Matching Script");
                            sb.AppendLine("--------------------------");
                            sb.AppendLine();
                            sb.AppendLine("```");
                            sb.AppendLine(Rule.PatternMatchingScript);
                            sb.AppendLine("```");
                            sb.AppendLine();
                            sb.AppendLine("Content Script");
                            sb.AppendLine("-----------");
                            sb.AppendLine();
                            sb.AppendLine("```");
                            sb.AppendLine(Rule.ContentScript);
                            sb.AppendLine("```");
 
                            Log.Error(sb.ToString(),
                                new KeyValuePair<string, object>("BareJid", Rule.BareJid.Value),
                                new KeyValuePair<string, object>("MessageType", Rule.MessageType),
                                new KeyValuePair<string, object>("Namespace", Rule.Namespace),
                                new KeyValuePair<string, object>("LocalName", Rule.LocalName),
                                new KeyValuePair<string, object>("Channel", Rule.Channel),
                                new KeyValuePair<string, object>("MessageVariable", Rule.MessageVariable),
                                new KeyValuePair<string, object>("Service", Token.Service),
                                new KeyValuePair<string, object>("ClientType", Token.ClientType),
                                new KeyValuePair<string, object>("Token", Token.Token));
                            return;
                        }
 
                        Builder.ApplyPayload(Payload);
 
                        FirebaseClient Client = firebaseClient;
                        if (!(Client is null))
                        {
                            (NotificationMessage Message, NotificationOptions Options, Dictionary<string, object> Data) = Builder.Build();
                            await Client.SendNotification(Token.Token, Message, Options, Data);
                        }
                        break;
 
                    default:
                        Log.Error("Unsupported push notification service: " + Token.Service);
                        break;
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        public const string BROKER_FIREBASE_USE = nameof(BROKER_FIREBASE_USE);
 
        public const string BROKER_FIREBASE_SERVICE_JSON = nameof(BROKER_FIREBASE_SERVICE_JSON);
 
        public const string BROKER_FIREBASE_API_KEY = nameof(BROKER_FIREBASE_API_KEY);
 
        public const string BROKER_FIREBASE_AUTH_DOMAIN = nameof(BROKER_FIREBASE_AUTH_DOMAIN);
 
        public const string BROKER_FIREBASE_PROJECT_ID = nameof(BROKER_FIREBASE_PROJECT_ID);
 
        public const string BROKER_FIREBASE_STORAGE_BUCKET = nameof(BROKER_FIREBASE_STORAGE_BUCKET);
 
        public const string BROKER_FIREBASE_MESSAGING_SENDER_ID = nameof(BROKER_FIREBASE_MESSAGING_SENDER_ID);
 
        public const string BROKER_FIREBASE_APP_ID = nameof(BROKER_FIREBASE_APP_ID);
 
        public override async Task<bool> EnvironmentConfiguration()
        {
            if (!this.TryGetEnvironmentVariable(BROKER_FIREBASE_USE, false, out this.useFirebase))
                return false;
 
            if (!this.useFirebase)
                return true;
 
            if (!this.TryGetEnvironmentVariable(BROKER_FIREBASE_SERVICE_JSON, true, out string FileName) ||
                !File.Exists(FileName))
            {
                return false;
            }
 
            try
            {
                string Json = await Files.ReadAllTextAsync(FileName);
                FirebaseClient Client = await GetClient(Json);
 
                this.firebaseServiceAccountJson = Json;
                this.firebaseServiceAccountJsonUploaded = DateTime.Now;
 
                if (!this.TryGetEnvironmentVariable(BROKER_FIREBASE_API_KEY, true, out this.firebaseApiKey) ||
                    !this.TryGetEnvironmentVariable(BROKER_FIREBASE_AUTH_DOMAIN, true, out this.firebaseAuthDomain) ||
                    !this.TryGetEnvironmentVariable(BROKER_FIREBASE_PROJECT_ID, true, out this.firebaseProjectId) ||
                    !this.TryGetEnvironmentVariable(BROKER_FIREBASE_STORAGE_BUCKET, true, out this.firebaseStorageBucket) ||
                    !this.TryGetEnvironmentVariable(BROKER_FIREBASE_MESSAGING_SENDER_ID, true, out this.firebaseMessagingSenderId) ||
                    !this.TryGetEnvironmentVariable(BROKER_FIREBASE_APP_ID, true, out this.firebaseAppId))
                {
                    return false;
                }
 
                return Client.ProjectId == this.firebaseProjectId;
            }
            catch (Exception ex)
            {
                Log.Exception(ex, FileName);
                return false;
            }
        }
 
}
    }