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.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.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)
                throw new BadRequestException();
 
            object Obj = await Request.DecodeDataAsync();
            if (!(Obj is Dictionary<string, object> Form) ||
                !Form.TryGetValue("useFirebase", out Obj) || !(Obj is bool UseFirebase))
            {
                throw new BadRequestException();
            }
 
            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))
            {
                throw new BadRequestException();
            }
 
            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))
                throw new BadRequestException();
 
            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;
            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)
                throw new BadRequestException();
 
            object Obj = await Request.DecodeDataAsync();
            if (!(Obj is Dictionary<string, object> Form) ||
                !Form.TryGetValue("token", out Obj) || !(Obj is string Token) ||
                !Form.TryGetValue("title", out Obj) || !(Obj is string Title) ||
                !Form.TryGetValue("body", out Obj) || !(Obj is string Body))
            {
                throw new BadRequestException();
            }
 
            using (FirebaseClient Client = await GetClient(this.firebaseServiceAccountJson))
            {
                NotificationResponse FirebaseResponse = await Client.SendNotification(Token, new NotificationMessage()
                {
                    Title = Title,
                    Body = Body
                });
 
                Response.StatusCode = 200;
                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)
        {
            try
            {
                switch (Token.Service)
                {
                    case PushMessagingService.Firebase:
                        Dictionary<string, object> Data = null;
                        NotificationOptions Options = new NotificationOptions();
                        NotificationMessage Message;
 
                        switch (Token.ClientType)
                        {
                            case ClientType.Android:
                                Message = new NotificationMessageAndroid();
                                break;
 
                            case ClientType.iOS:
                                Message = new NotificationMessageApple();
                                break;
 
                            case ClientType.Web:
                                Message = new NotificationMessageWeb();
                                break;
 
                            case ClientType.Other:
                            default:
                                Message = new NotificationMessage();
                                break;
                        }
 
                        if (Content is Dictionary<string, object> JsonObject)
                        {
                            foreach (KeyValuePair<string, object> P in JsonObject)
                                SetProperty(Message, Options, ref Data, P.Key, P.Value);
                        }
                        else if (Content is Dictionary<string, IElement> ScriptObject)
                        {
                            foreach (KeyValuePair<string, IElement> P in ScriptObject)
                                SetProperty(Message, Options, ref Data, P.Key, P.Value.AssociatedObjectValue);
                        }
                        else
                            Message.Body = Content?.ToString();
 
                        FirebaseClient Client = firebaseClient;
                        if (!(Client is null))
                            await Client.SendNotification(Token.Token, Message, Options, Data);
                        break;
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private static void SetProperty(NotificationMessage Message, NotificationOptions Options, ref Dictionary<string, object> Data,
            string Key, object Value)
        {
            if (!Options.TrySetProperty(Key, Value) && !Message.TrySetProperty(Key, Value))
            {
                if (Data is null)
                    Data = new Dictionary<string, object>();
 
                if (Key == "data" && Value is Dictionary<string, object> DataItems)
                {
                    foreach (KeyValuePair<string, object> P in DataItems)
                        Data[P.Key] = P.Value;
                }
                else
                    Data[Key] = Value;
            }
        }
 
        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 Resources.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;
            }
        }
 
}
    }