FirebaseClient.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Getters;
using Waher.Events;
using Waher.Networking.Sniffers;
using Waher.Script;
using Waher.Security.JWT;
 
namespace Waher.Networking.HTTP.Firebase
{
    public class FirebaseClient : CommunicationLayer, IDisposable
    {
        #region Construction
 
        private static readonly Uri productionEndpoint = new Uri("https://fcm.googleapis.com/");
        private const string scope = "https://www.googleapis.com/auth/firebase.messaging";  //"https://www.googleapis.com/auth/cloud-platform";
 
        private readonly string projectId;
        private readonly string privateKeyId;
        private readonly string clientEmail;
        private readonly string clientId;
        private readonly string authUri;
        private readonly string tokenUri;
        private readonly string universeDomain;
        private readonly bool test;
        private readonly Uri sendNotificationUri;
        private JwtFactory factory;
        private string token = null;
        private DateTime tokenTimestamp = DateTime.MinValue;
 
        private FirebaseClient(string ProjectId, string PrivateKeyId, JwtFactory Factory, string ClientEMail, string ClientId,
            string AuthUri, string TokenUri, string UniverseDomain, bool Test, params ISniffer[] Sniffers)
            : base(false, Sniffers)
        {
            this.projectId = ProjectId;
            this.privateKeyId = PrivateKeyId;
            this.clientEmail = ClientEMail;
            this.clientId = ClientId;
            this.authUri = AuthUri;
            this.tokenUri = TokenUri;
            this.universeDomain = UniverseDomain;
            this.factory = Factory;
            this.test = Test;
            this.sendNotificationUri = new Uri(productionEndpoint, "v1/projects/" + this.projectId + "/messages:send");
        }
 
        public string ProjectId => this.projectId;
 
        public string PrivateKeyId => this.privateKeyId;
 
        public string ClientEMail => this.clientEmail;
 
        public string ClientId => this.clientId;
        
        public string AuthUri => this.authUri;
 
        public string TokenUri => this.tokenUri;
 
        public string UniverseDomain => this.universeDomain;
 
        public bool Test => this.test;
 
        public static async Task<FirebaseClient> CreateAsync(string GoogleServiceAccountJson, bool Test, params ISniffer[] Sniffers)
        {
            if (!(JSON.Parse(GoogleServiceAccountJson) is Dictionary<string, object> Parsed) ||
                !Parsed.TryGetValue("type", out object Obj) || !(Obj is string Type))
            {
                throw new ArgumentException("Invalid Google Service Account JSON file.", nameof(GoogleServiceAccountJson));
            }
 
            if (Type != "service_account")
                throw new ArgumentException("File does not specify a Google Service account.", nameof(GoogleServiceAccountJson));
 
            if (!Parsed.TryGetValue("project_id", out Obj) || !(Obj is string ProjectId) ||
                !Parsed.TryGetValue("private_key_id", out Obj) || !(Obj is string PrivateKeyId) ||
                !Parsed.TryGetValue("private_key", out Obj) || !(Obj is string PrivateKey) ||
                !Parsed.TryGetValue("client_email", out Obj) || !(Obj is string ClientEmail) ||
                !Parsed.TryGetValue("client_id", out Obj) || !(Obj is string ClientId) ||
                !Parsed.TryGetValue("auth_uri", out Obj) || !(Obj is string AuthUri) ||
                !Parsed.TryGetValue("token_uri", out Obj) || !(Obj is string TokenUri) ||
                !Parsed.TryGetValue("universe_domain", out Obj) || !(Obj is string UniverseDomain))
            {
                throw new ArgumentException("Missing properties in JSON file.", nameof(GoogleServiceAccountJson));
            }
 
            JwtFactory Factory = (JwtFactory)await expCreateFactory.EvaluateAsync(new Variables() { { "PrivateKey", PrivateKey } });
 
            // Note: Importing private keys from PEM file not available in .NET Standard. It is available from .NET 5 however,
            // which is used by the executing container, which also publishes script functions for the purpose.
 
            return new FirebaseClient(ProjectId, PrivateKeyId, Factory, ClientEmail, ClientId, AuthUri, TokenUri, UniverseDomain, Test, Sniffers);
        }
 
        private static readonly Expression expCreateFactory = new Expression("CreateJwtFactory(RS256(RsaFromPem(PrivateKey)))");
 
        public void Dispose()
        {
            this.factory?.Dispose();
            this.factory = null;
        }
 
        #endregion
 
        #region Authentication
 
        public string BearerToken
        {
            get
            {
                DateTime Now = DateTime.Now;
 
                if (this.token is null || Now.Subtract(this.tokenTimestamp).TotalMinutes >= 30)
                {
                    int IssuedAt = (int)Math.Round(DateTime.UtcNow.Subtract(JSON.UnixEpoch).TotalSeconds);
                    int Expires = IssuedAt + 3600;
 
                    this.token = this.factory.Create(new KeyValuePair<string, object>[]
                    {
                        new KeyValuePair<string, object>("kid", this.privateKeyId),
                    },
                    new KeyValuePair<string, object>[]
                    {
                        new KeyValuePair<string, object>(JwtClaims.Issuer, this.clientEmail),
                        new KeyValuePair<string, object>(JwtClaims.Subject, this.clientEmail),
                        new KeyValuePair<string, object>(JwtClaims.Audience, productionEndpoint.OriginalString), // scope),
                        new KeyValuePair<string, object>(JwtClaims.IssueTime, IssuedAt),
                        new KeyValuePair<string, object>(JwtClaims.ExpirationTime, Expires)
                    });
 
                    this.tokenTimestamp = Now;
                }
 
                return this.token;
            }
        }
 
        #endregion
 
        #region Send Notification
 
        public Task<NotificationResponse> SendNotification(string To, NotificationMessage Message)
        {
            return this.SendNotification(To, Message, null, null);
        }
 
        public Task<NotificationResponse> SendNotification(string To, NotificationMessage Message, NotificationOptions Options)
        {
            return this.SendNotification(To, Message, Options, null);
        }
 
        public async Task<NotificationResponse> SendNotification(string To, NotificationMessage Message, NotificationOptions Options, Dictionary<string, object> Data)
        {
            Dictionary<string, object> Msg = new Dictionary<string, object>()
            {
                { "token", To },
            };
            Dictionary<string, object> Request = new Dictionary<string, object>()
            {
                { "message", Msg }
            };
 
            if (this.test)
                Request["validate_only"] = true;
 
            Message.ExportProperties(Msg);
            Options?.SetProperties(Msg, this);
 
            if (!(Data is null) && Data.Count > 0)
            {
                Dictionary<string, object> ConvertedData = new Dictionary<string, object>();
                foreach (KeyValuePair<string, object> Kvp in Data)
                {
                    // If the value is a nested structure, JSON-encode,
                    // otherwise call ToString() to ensure a string value.
                    if (Kvp.Value is Dictionary<string, object> NestedObj)
                    {
                        ConvertedData[Kvp.Key] = JSON.Encode(NestedObj, false);
                    }
                    else if (Kvp.Value is IEnumerable Enumerable && !(Kvp.Value is string))
                    {
                        List<object> Items = new List<object>();
                        foreach (object Item in Enumerable)
                            Items.Add(Item);
 
                        ConvertedData[Kvp.Key] = JSON.Encode(Items.ToArray(), false);
                    }
                    else
                    {
                        ConvertedData[Kvp.Key] = Kvp.Value?.ToString() ?? string.Empty;
                    }
                }
                Msg["data"] = ConvertedData;
            }
 
            try
            {
                if (this.HasSniffers)
                {
                    StringBuilder sb = new StringBuilder();
 
                    sb.Append("POST(");
                    sb.Append(this.sendNotificationUri.ToString());
                    sb.AppendLine(",");
                    sb.Append("   Authorization: Bearer ");
                    sb.Append(this.BearerToken);
                    sb.AppendLine(",");
 
                    string s = JSON.Encode(Request, true);
                    s = s.Replace("\t", "   ");
 
                    string[] Rows = s.Split(CommonTypes.CRLF, StringSplitOptions.RemoveEmptyEntries);
 
                    foreach (string Row in Rows)
                    {
                        sb.Append("   ");
                        sb.AppendLine(Row);
                    }
 
                    sb.Append(')');
 
                    this.TransmitText(sb.ToString());
                }
 
                ContentResponse Response = await InternetContent.PostAsync(this.sendNotificationUri, Request,
                    new KeyValuePair<string, string>("Authorization", "Bearer " + this.BearerToken));
 
                if (Response.HasError)
                {
                    if (Response.Error is WebException ex)
                    {
                        if (ex.Content is Dictionary<string, object> ErrorResponse &&
                            ErrorResponse.TryGetValue("error", out object Obj) &&
                            Obj is Dictionary<string, object> ErrorObject &&
                            ErrorObject.TryGetValue("message", out Obj) &&
                            Obj is string ErrorMessage)
                        {
                            this.Error(ErrorMessage);
                            return new NotificationResponse(ex, ErrorMessage);
                        }
                        else
                        {
                            this.Exception(ex);
                            Log.Exception(ex);
 
                            return new NotificationResponse(ex);
                        }
                    }
                    else
                    {
                        this.Exception(Response.Error);
                        Log.Exception(Response.Error);
 
                        return new NotificationResponse(Response.Error);
                    }
                }
                else
                {
                    if (this.HasSniffers)
                        this.ReceiveText(JSON.Encode(Response.Decoded, true));
 
                    if (!(Response.Decoded is Dictionary<string, object> Obj))
                    {
                        Exception ex = new Exception("Invalid or unexpected JSON content returned.");
                        this.Exception(ex);
                        Log.Exception(ex);
                        
                        return new NotificationResponse(ex);
                    }
 
                    return new NotificationResponse();
                }
            }
            catch (Exception ex)
            {
                this.Exception(ex);
                Log.Exception(ex);
 
                return new NotificationResponse(ex);
            }
        }
 
        #endregion
 
    }
}