Skip to content
Snippets Groups Projects
Select Git revision
  • aa37e0c26b1fac84ed5d0c238f02f7a4c516c232
  • master default protected
  • dev protected
  • Issue/3130-onboardingUzK
  • Issue/3109-onboarding
  • Issue/2915-migrateSql2Linked
  • test_ci
  • Issue/xxxx-fixDevcontainer
  • Issue/xxxx-generateLatestTag
  • Issue/2980-fixContainerBuild
  • Issue/2967-fixGD
  • Issue/2944-gdShenanigans
  • Issue/2906-containerCron
  • Issue/2880-gd
  • petar.hristov-master-patch-9e49
  • Issue/2668-graphDeployer
  • gitkeep
  • Hotfix/xxxx-fastDeployment
  • Hotfix/2615-graphDeployerLag
  • Issue/2568-betterLogging
  • Issue/2518-docs
  • v2.1.11
  • v2.1.10
  • v2.1.9
  • v2.1.8
  • v2.1.7
  • v2.1.6
  • v2.1.5
  • v2.1.4
  • v2.1.3
  • v2.1.2
  • v2.1.1
  • v2.1.0
  • v2.0.1
  • v2.0.0
  • v1.2.11
  • v1.2.10
  • v1.2.9
  • v1.2.8
  • v1.2.7
  • v1.2.6
41 results

Program.cs

Blame
  • Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    NotificationConfiguration.cs 4.63 KiB
    using Newtonsoft.Json;
    using Newtonsoft.Json.Linq;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Reflection;
    
    namespace Coscine.NotificationConfiguration
    {
        public class NotificationConfiguration
        {
            private readonly Dictionary<string, ActionObject> _actions = new Dictionary<string, ActionObject>();
    
            private readonly Dictionary<string, ChannelObject> _channels = new Dictionary<string, ChannelObject>();
    
            public NotificationConfiguration()
            {
                var actionsFileName = "Coscine.NotificationConfiguration.Actions.json";
                var channelsFileName = "Coscine.NotificationConfiguration.Channels.json";
    
                var actionsJSON = GetJSONFromAssembly(actionsFileName);
                var channelsJSON = GetJSONFromAssembly(channelsFileName);
    
                foreach (var action in actionsJSON)
                {
                    _actions.Add(action.Key, new ActionObject((JObject)action.Value));
                }
                foreach (var channel in channelsJSON)
                {
                    _channels.Add(channel.Key, new ChannelObject((JObject)channel.Value));
                }
            }
    
            public static JObject GetJSONFromAssembly(string fileName)
            {
                var assembly = Assembly.GetExecutingAssembly();
                using (Stream stream = assembly.GetManifestResourceStream(fileName))
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        string result = reader.ReadToEnd();
                        return (JObject)JsonConvert.DeserializeObject(result);
                    }
                }
            }
    
            public static string GetStringFromAssembly(string fileName)
            {
                var assembly = Assembly.GetExecutingAssembly();
                using (Stream stream = assembly.GetManifestResourceStream(fileName))
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        return reader.ReadToEnd();
                    }
                }
            }
    
            public static string GetStringFromAssembly(string channel, string language, string fileName)
            {
                var path = $"Coscine.NotificationConfiguration.Partials.{UppercaseFirst(channel)}.{UppercaseFirst(language)}.{fileName}";
                return GetStringFromAssembly(path);
            }
    
            public bool IsValidAction(string action)
            {
                return _actions.ContainsKey(action);
            }
    
            public bool IsValidChannel(string channel)
            {
                return _channels.ContainsKey(channel);
            }
    
            public ActionObject GetAction(string action)
            {
                if (_actions.ContainsKey(action))
                {
                    return _actions[action];
                }
                return null;
            }
    
            public ChannelObject GetChannel(string channel)
            {
                if (_channels.ContainsKey(channel))
                {
                    return _channels[channel];
                }
                return null;
            }
            public Dictionary<string, string> GetPartialsForChannel(string channel, string language)
            {
                if (_channels.ContainsKey(channel))
                {
                    var args = _channels[channel].Args;
                    var dict = new Dictionary<string, string>();
                    if (args["partials"] != null && args["partials"][language] != null)
                    {
                        var partialDict = args["partials"][language].ToObject<Dictionary<string, string>>();
                        foreach (var partial in partialDict)
                        {
                            dict.Add(partial.Key, GetStringFromAssembly(channel, language, partial.Value));
                        }
                    }
                    return dict;
                }
                return null;
            }
    
            private static string UppercaseFirst(string str)
            {
                if (string.IsNullOrEmpty(str))
                {
                    return string.Empty;
                }
                return char.ToUpper(str[0]) + str.Substring(1);
            }
    
            public List<string> GetAllChannelsForAction(string action)
            {
                ActionObject actionObject = GetAction(action);
                if (actionObject != null)
                {
                    var only = actionObject.ChannelsOnly;
                    var available = actionObject.ChannelsAvailable;
                    var always = actionObject.ChannelsOnly;
                    if (only.Count > 0)
                    {
                        return only;
                    }
                    else
                    {
                        return available.Union(always).ToList();
                    }
                }
                return new List<string>();
            }
        }
    }