init

Kreta.Core/FeatureToggle/FeatureContext.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Linq;
+using Kreta.Core.FeatureToggle.Configuration;
+
+namespace Kreta.Core.FeatureToggle
+{
+    public class FeatureContext : IFeatureContext
+    {
+        private Dictionary<string, IFeature> Features { get; }
+
+        private static readonly Lazy<FeatureContext> instance;
+        public static FeatureContext Instance => instance.Value;
+
+        static FeatureContext()
+        {
+            instance = new Lazy<FeatureContext>(() => new FeatureContext((FeatureConfigurationSection)ConfigurationManager.GetSection(Constants.ConfigurationSectionNames.FeatureConfig)));
+        }
+
+        public FeatureContext(FeatureConfigurationSection config)
+        {
+            Features = GetFeaturesFromConfig(config);
+        }
+
+        private static Dictionary<string, IFeature> GetFeaturesFromConfig(FeatureConfigurationSection config)
+        {
+            var features = new Dictionary<string, IFeature>();
+
+            foreach (SimpleFeatureConfiguration featureConfiguration in config.SimpleFeatures)
+            {
+                var feature = new SimpleFeature
+                {
+                    Name = featureConfiguration.Name,
+                    IsEnabled = featureConfiguration.IsEnabled,
+                    InstituteIds = featureConfiguration.InstituteIds,
+                    Environments = featureConfiguration.Environments
+                };
+
+                features[feature.Name] = feature;
+            }
+
+            return features;
+        }
+
+        public bool IsEnabled(string featureName, string environment = null, string instituteId = null, List<string> instituteIds = null)
+        {
+            if (string.IsNullOrWhiteSpace(featureName))
+            {
+                throw new ArgumentException($"{nameof(featureName)} null vagy üres");
+            }
+
+            if (!Features.ContainsKey(featureName))
+            {
+                throw new ArgumentException($"{featureName} nem létező feature");
+            }
+
+            bool isFeatureEnabled = Features[featureName].IsEnabled;
+
+            if (isFeatureEnabled && (!string.IsNullOrWhiteSpace(environment) || !string.IsNullOrWhiteSpace(instituteId)))
+            {
+                IFeature feature = Features[featureName];
+
+                return CheckEnvironment(feature, environment) && CheckInstituteId(feature, instituteId, instituteIds);
+            }
+
+            return isFeatureEnabled;
+        }
+
+        private bool CheckEnvironment(IFeature feature, string environment)
+        {
+            if (!string.IsNullOrWhiteSpace(environment))
+            {
+                return !feature.Environments.Any() || feature.Environments.Contains(environment);
+            }
+
+            return true;
+        }
+
+        private bool CheckInstituteId(IFeature feature, string instituteId, List<string> instituteIds = null)
+        {
+            if (!string.IsNullOrWhiteSpace(instituteId))
+            {
+                if (instituteIds != null && instituteIds.Any())
+                {
+                    return instituteIds.Contains(instituteId, StringComparer.InvariantCultureIgnoreCase);
+                }     
+
+                return !feature.InstituteIds.Any() || feature.InstituteIds.Contains(instituteId, StringComparer.InvariantCultureIgnoreCase);
+            }
+
+            return true;
+        }
+    }
+}