PushNotificationPayload.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Waher.Script.Abstraction.Elements;
 
namespace Waher.Networking.XMPP.Server.PushNotification
{
    public class PushNotificationPayload
    {
        public const string DefaultKind = "PushNotificationPayload";
 
        public const int CurrentVersion = 1;
 
        public string PayloadKind { get; set; } = DefaultKind;
 
        public int PayloadVersion { get; set; } = CurrentVersion;
 
        public PushVisual Visual { get; set; } = new PushVisual();
 
        public PushAction Action { get; set; }
 
        public PushChannel Channel { get; set; }
 
        public PushDelivery Delivery { get; set; } = new PushDelivery();
 
        public Dictionary<string, object> Context { get; set; }
 
        public Dictionary<ClientType, Dictionary<string, object>> PlatformOverrides { get; set; }
 
        public Dictionary<string, object> CustomData { get; set; }
 
        public static bool TryParse(object Content, out PushNotificationPayload Payload)
        {
            object Normalized = Normalize(Content);
 
            if (Normalized is PushNotificationPayload Parsed && Parsed.IsPayloadKind())
            {
                Payload = Parsed;
                return true;
            }
 
            if (Normalized is Dictionary<string, object> Dict && HasPayloadMarker(Dict))
            {
                Payload = FromDictionary(Dict);
                return true;
            }
 
            Payload = null;
            return false;
        }
 
        private static PushNotificationPayload FromDictionary(Dictionary<string, object> Dict)
        {
            PushNotificationPayload Payload = new PushNotificationPayload
            {
                PayloadKind = GetString(Dict, "payloadKind") ?? GetString(Dict, "PayloadKind") ?? DefaultKind,
                PayloadVersion = GetInt(Dict, "payloadVersion") ?? GetInt(Dict, "PayloadVersion") ?? CurrentVersion,
                Visual = PushVisual.FromDictionary(GetDict(Dict, "visual")),
                Action = PushAction.FromDictionary(GetDict(Dict, "action")),
                Channel = PushChannel.FromDictionary(GetDict(Dict, "channel")),
                Delivery = PushDelivery.FromDictionary(GetDict(Dict, "delivery")),
                Context = GetDict(Dict, "context"),
                CustomData = GetDict(Dict, "data") ?? GetDict(Dict, "customData") ?? GetDict(Dict, "custom"),
                PlatformOverrides = ParsePlatformOverrides(GetDict(Dict, "platformOverrides"))
            };
 
            return Payload;
        }
 
        private static Dictionary<ClientType, Dictionary<string, object>> ParsePlatformOverrides(Dictionary<string, object> Dict)
        {
            if (Dict is null || Dict.Count == 0)
                return null;
 
            Dictionary<ClientType, Dictionary<string, object>> Result = new Dictionary<ClientType, Dictionary<string, object>>();
 
            foreach (KeyValuePair<string, object> P in Dict)
            {
                if (!Enum.TryParse(P.Key, true, out ClientType ClientType))
                    continue;
 
                if (Normalize(P.Value) is Dictionary<string, object> OverrideDict && OverrideDict.Count > 0)
                    Result[ClientType] = OverrideDict;
            }
 
            return Result.Count == 0 ? null : Result;
        }
 
        private static bool HasPayloadMarker(Dictionary<string, object> Dict)
        {
            if (Dict is null)
                return false;
 
            string PayloadKind = GetString(Dict, "payloadKind") ?? GetString(Dict, "PayloadKind");
            return !string.IsNullOrEmpty(PayloadKind) && string.Equals(PayloadKind, DefaultKind, StringComparison.OrdinalIgnoreCase);
        }
 
        private bool IsPayloadKind()
        {
            return !string.IsNullOrEmpty(this.PayloadKind) &&
                string.Equals(this.PayloadKind, DefaultKind, StringComparison.OrdinalIgnoreCase);
        }
 
        private static object Normalize(object Value)
        {
            if (Value is IElement Element)
                Value = Element.AssociatedObjectValue;
 
            if (Value is Dictionary<string, IElement> ScriptDict)
            {
                Dictionary<string, object> Converted = new Dictionary<string, object>();
                foreach (KeyValuePair<string, IElement> P in ScriptDict)
                    Converted[P.Key] = Normalize(P.Value);
 
                return Converted;
            }
 
            if (Value is Dictionary<string, object> Dict)
            {
                Dictionary<string, object> Converted = new Dictionary<string, object>();
                foreach (KeyValuePair<string, object> P in Dict)
                    Converted[P.Key] = Normalize(P.Value);
 
                return Converted;
            }
 
            if (Value is IEnumerable Enumerable && !(Value is string))
            {
                List<object> Items = new List<object>();
                foreach (object Item in Enumerable)
                    Items.Add(Normalize(Item));
 
                return Items.ToArray();
            }
 
            return Value;
        }
 
        internal static Dictionary<string, object> GetDict(Dictionary<string, object> Parent, string Key)
        {
            if (Parent is null)
                return null;
 
            if (!Parent.TryGetValue(Key, out object Value))
                return null;
 
            return Normalize(Value) as Dictionary<string, object>;
        }
 
        internal static string GetString(Dictionary<string, object> Dict, string Key)
        {
            if (Dict is null)
                return null;
 
            if (!Dict.TryGetValue(Key, out object Value) || Value is null)
                return null;
 
            return Value.ToString();
        }
 
        internal static int? GetInt(Dictionary<string, object> Dict, string Key)
        {
            if (Dict is null || !Dict.TryGetValue(Key, out object Value) || Value is null)
                return null;
 
            switch (Value)
            {
                case int i:
                    return i;
                case long l:
                    return (int)l;
                case double d:
                    return (int)d;
                default:
                    if (int.TryParse(Value.ToString(), out int i2))
                        return i2;
                    return null;
            }
        }
 
        internal static bool? GetBool(Dictionary<string, object> Dict, string Key)
        {
            if (Dict is null || !Dict.TryGetValue(Key, out object Value) || Value is null)
                return null;
 
            switch (Value)
            {
                case bool b:
                    return b;
                default:
                    if (bool.TryParse(Value.ToString(), out bool b2))
                        return b2;
                    return null;
            }
        }
    }
 
    public class PushVisual
    {
        public string Title { get; set; }
        public string Subtitle { get; set; }
        public string Body { get; set; }
        public string Icon { get; set; }
        public string Badge { get; set; }
 
        internal static PushVisual FromDictionary(Dictionary<string, object> Dict)
        {
            if (Dict is null)
                return new PushVisual();
 
            return new PushVisual
            {
                Title = PushNotificationPayload.GetString(Dict, "title"),
                Subtitle = PushNotificationPayload.GetString(Dict, "subtitle"),
                Body = PushNotificationPayload.GetString(Dict, "body"),
                Icon = PushNotificationPayload.GetString(Dict, "icon"),
                Badge = PushNotificationPayload.GetString(Dict, "badge"),
            };
        }
    }
 
    public class PushAction
    {
        public string Type { get; set; }
        public string EntityId { get; set; }
        public string CorrelationId { get; set; }
        public string NavigationTarget { get; set; }
 
        internal static PushAction FromDictionary(Dictionary<string, object> Dict)
        {
            if (Dict is null)
                return null;
 
            return new PushAction
            {
                Type = PushNotificationPayload.GetString(Dict, "type"),
                EntityId = PushNotificationPayload.GetString(Dict, "entityId"),
                CorrelationId = PushNotificationPayload.GetString(Dict, "correlationId"),
                NavigationTarget = PushNotificationPayload.GetString(Dict, "navigationTarget")
            };
        }
    }
 
    public class PushChannel
    {
        public string ChannelId { get; set; }
        public string Category { get; set; }
        public string Importance { get; set; }
        public string[] Tags { get; set; }
 
        internal static PushChannel FromDictionary(Dictionary<string, object> Dict)
        {
            if (Dict is null)
                return null;
 
            object TagsValue = null;
            Dict?.TryGetValue("tags", out TagsValue);
 
            string[] Tags = TagsValue switch
            {
                string[] Arr => Arr,
                IEnumerable<object> Items => new List<string>(Array.ConvertAll(new List<object>(Items).ToArray(), x => x.ToString())).ToArray(),
                _ => null
            };
 
            return new PushChannel
            {
                ChannelId = PushNotificationPayload.GetString(Dict, "channelId") ?? PushNotificationPayload.GetString(Dict, "channel_id"),
                Category = PushNotificationPayload.GetString(Dict, "category"),
                Importance = PushNotificationPayload.GetString(Dict, "importance"),
                Tags = Tags
            };
        }
    }
 
    public class PushDelivery
    {
        public string Priority { get; set; }
        public int? Ttl { get; set; }
        public string CollapseKey { get; set; }
        public bool Silent { get; set; }
 
        internal static PushDelivery FromDictionary(Dictionary<string, object> Dict)
        {
            if (Dict is null)
                return new PushDelivery();
 
            return new PushDelivery
            {
                Priority = PushNotificationPayload.GetString(Dict, "priority"),
                Ttl = PushNotificationPayload.GetInt(Dict, "ttl"),
                CollapseKey = PushNotificationPayload.GetString(Dict, "collapseKey") ?? PushNotificationPayload.GetString(Dict, "collapse_key"),
                Silent = PushNotificationPayload.GetBool(Dict, "silent") ?? false
            };
        }
    }
}