FirebaseClient.cs

using System;
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 },
                { "notification", Message.GetNotificationObject() }
            };
            Dictionary<string, object> Request = new Dictionary<string, object>()
            {
                { "message", Msg }
            };
 
            if (this.test)
                Request["validate_only"] = true;
 
            Options?.SetProperties(Msg, this);
            Message.ExportProperties(Msg);
 
            if (!(Data is null) && Data.Count > 0)
            {
                Dictionary<string, object> Updated = new Dictionary<string, object>();
 
                foreach (KeyValuePair<string, object> P in Data)
                {
                    if (P.Value is Dictionary<string, object> NestedObj)
                    {
                        if (Updated is null)
                            Updated = new Dictionary<string, object>();
 
                        Updated[P.Key] = JSON.Encode(P.Value, false);   // Nested data objects no longer supported by new Firebase API.
                    }
                }
 
                if (!(Updated is null))
                {
                    foreach (KeyValuePair<string, object> P in Updated)
                        Data[P.Key] = P.Value;
                }
 
                Msg["data"] = Data;
            }
 
            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(')');
 
                    await this.TransmitText(sb.ToString());
                }
 
                object Response = await InternetContent.PostAsync(this.sendNotificationUri, Request,
                    new KeyValuePair<string, string>("Authorization", "Bearer " + this.BearerToken));
 
                if (this.HasSniffers)
                    await this.ReceiveText(JSON.Encode(Response, true));
 
                if (!(Response is Dictionary<string, object> Obj))
                    throw new Exception("Invalid or unexpected JSON content returned.");
 
                return new NotificationResponse();
            }
            catch (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)
                {
                    await this.Error(ErrorMessage);
                    return new NotificationResponse(ex, ErrorMessage);
                }
                else
                {
                    await this.Exception(ex);
                    Log.Exception(ex);
 
                    return new NotificationResponse(ex);
                }
            }
            catch (Exception ex)
            {
                await this.Exception(ex);
                Log.Exception(ex);
 
                return new NotificationResponse(ex);
            }
        }
 
        #endregion
 
    }
}