Added caching option

jameskimsca · jameskimsca · commit 64462996cae7 · 2018-08-24T11:20:32.000+10:00
diff --git a/Perplex.Umbraco.Forms/App_Plugins/PerplexUmbracoForms/PerplexUmbracoForms.config b/Perplex.Umbraco.Forms/App_Plugins/PerplexUmbracoForms/PerplexUmbracoForms.config
@@ -44,4 +44,8 @@
   <PerplexRecaptchConfig>
     <ErrorMessage />
   </PerplexRecaptchConfig>
+  <PerplexCacheConfig>
+    <EnableCache>true</EnableCache>
+    <CacheDurationInMinutes>10</CacheDurationInMinutes>
+  </PerplexCacheConfig>
 </PerplexUmbracoFormsConfig>
diff --git a/Perplex.Umbraco.Forms/Code/ArrayExtensions.cs b/Perplex.Umbraco.Forms/Code/ArrayExtensions.cs
@@ -0,0 +1,48 @@
+﻿using System;
+
+namespace PerplexUmbraco.Forms.Code
+{
+    public static class ArrayExtensions
+    {
+        public static void ForEach(this Array array, Action<Array, int[]> action)
+        {
+            if (array.LongLength == 0) return;
+            ArrayTraverse walker = new ArrayTraverse(array);
+            do action(array, walker.Position);
+            while (walker.Step());
+        }
+    }
+
+    internal class ArrayTraverse
+    {
+        public int[] Position;
+        private int[] maxLengths;
+
+        public ArrayTraverse(Array array)
+        {
+            maxLengths = new int[array.Rank];
+            for (int i = 0; i < array.Rank; ++i)
+            {
+                maxLengths[i] = array.GetLength(i) - 1;
+            }
+            Position = new int[array.Rank];
+        }
+
+        public bool Step()
+        {
+            for (int i = 0; i < Position.Length; ++i)
+            {
+                if (Position[i] < maxLengths[i])
+                {
+                    Position[i]++;
+                    for (int j = 0; j < i; j++)
+                    {
+                        Position[j] = 0;
+                    }
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}
diff --git a/Perplex.Umbraco.Forms/Code/CacheService.cs b/Perplex.Umbraco.Forms/Code/CacheService.cs
@@ -0,0 +1,71 @@
+﻿using System;
+
+using Umbraco.Core;
+using Umbraco.Core.Logging;
+
+namespace PerplexUmbraco.Forms.Code
+{
+    public class CacheService : ICacheService
+    {
+        public void SetRequestCache(string cacheKey, object cacheObject)
+        {
+            if (cacheObject != null)
+            {
+                ApplicationContext.Current.ApplicationCache.RequestCache.GetCacheItem(cacheKey, () => cacheObject);
+                return;
+            }
+
+            LogHelper.Warn<CacheService>($"Failed to cache null object with key: {cacheKey}");
+        }
+
+        public T GetRequestCache<T>(string cacheKey)
+        {
+            var cachedObject = ApplicationContext.Current.ApplicationCache.RequestCache.GetCacheItem(cacheKey);
+
+            if (cachedObject == null)
+            {
+                return default(T);
+            }
+
+            return (T)cachedObject;
+        }
+
+        public void SetRuntimeCache(string cacheKey, object cacheObject, TimeSpan duration)
+        {
+            SetRuntimeCache(cacheKey, cacheObject, duration, false);
+        }
+
+        public void SetRuntimeCache(string cacheKey, object cacheObject, TimeSpan duration, bool isSliding)
+        {
+            if (cacheObject != null)
+            {
+                ApplicationContext.Current.ApplicationCache.RuntimeCache.InsertCacheItem(cacheKey, cacheObject.Copy, duration, isSliding);
+                return;
+            }
+
+            LogHelper.Warn<CacheService>($"Failed to cache null object with key: {cacheKey}");
+        }
+
+        public void ClearRuntimeCacheByKey(string cacheKey)
+        {
+            ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(cacheKey);
+        }
+
+        public void ClearRuntimeCacheByPrefix(string prefix)
+        {
+            ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheByKeySearch(prefix);
+        }
+
+        public T GetRuntimeCache<T>(string cacheKey)
+        {
+            var cachedObject = ApplicationContext.Current.ApplicationCache.RuntimeCache.GetCacheItem(cacheKey);
+
+            if (cachedObject == null)
+            {
+                return default(T);
+            }
+
+            return ((T)cachedObject).Copy();
+        }
+    }
+}
diff --git a/Perplex.Umbraco.Forms/Code/Configuration/ExtensionConfig.cs b/Perplex.Umbraco.Forms/Code/Configuration/ExtensionConfig.cs
@@ -1,9 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml.Serialization;
+﻿using System.Xml.Serialization;
 
 namespace PerplexUmbraco.Forms.Code.Configuration
 {
diff --git a/Perplex.Umbraco.Forms/Code/Configuration/FieldTypeConfig.cs b/Perplex.Umbraco.Forms/Code/Configuration/FieldTypeConfig.cs
@@ -1,8 +1,4 @@
 ﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Xml.Serialization;
 
 namespace PerplexUmbraco.Forms.Code.Configuration
diff --git a/Perplex.Umbraco.Forms/Code/Configuration/PerplexBaseFileConfig.cs b/Perplex.Umbraco.Forms/Code/Configuration/PerplexBaseFileConfig.cs
@@ -1,8 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+﻿using System.Collections.Generic;
 using System.Xml.Serialization;
 
 namespace PerplexUmbraco.Forms.Code.Configuration
diff --git a/Perplex.Umbraco.Forms/Code/Configuration/PerplexCacheConfig.cs b/Perplex.Umbraco.Forms/Code/Configuration/PerplexCacheConfig.cs
@@ -0,0 +1,14 @@
+﻿using System.Xml.Serialization;
+
+namespace PerplexUmbraco.Forms.Code.Configuration
+{
+    [XmlType("PerplexCacheConfig")]
+    public class PerplexCacheConfig
+    {
+        [XmlElement("CacheDurationInMinutes")]
+        public int CacheDurationInMinutes { get; set; }
+
+        [XmlElement("EnableCache")]
+        public bool EnableCache { get; set; }
+    }
+}
diff --git a/Perplex.Umbraco.Forms/Code/Configuration/PerplexFileUploadConfig.cs b/Perplex.Umbraco.Forms/Code/Configuration/PerplexFileUploadConfig.cs
@@ -1,9 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml.Serialization;
+﻿using System.Xml.Serialization;
 
 namespace PerplexUmbraco.Forms.Code.Configuration
 {
diff --git a/Perplex.Umbraco.Forms/Code/Configuration/PerplexImageUploadConfig.cs b/Perplex.Umbraco.Forms/Code/Configuration/PerplexImageUploadConfig.cs
@@ -1,9 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml.Serialization;
+﻿using System.Xml.Serialization;
 
 namespace PerplexUmbraco.Forms.Code.Configuration
 {
diff --git a/Perplex.Umbraco.Forms/Code/Configuration/PerplexRecaptchaConfig.cs b/Perplex.Umbraco.Forms/Code/Configuration/PerplexRecaptchaConfig.cs
@@ -1,9 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml.Serialization;
+﻿using System.Xml.Serialization;
 
 namespace PerplexUmbraco.Forms.Code.Configuration
 {
diff --git a/Perplex.Umbraco.Forms/Code/Configuration/PerplexUmbracoFormsConfig.cs b/Perplex.Umbraco.Forms/Code/Configuration/PerplexUmbracoFormsConfig.cs
@@ -1,11 +1,9 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using System.Web.Hosting;
 using System.Xml.Serialization;
+
 using static PerplexUmbraco.Forms.Code.Constants;
 
 namespace PerplexUmbraco.Forms.Code.Configuration
@@ -73,6 +71,8 @@ public static void CreateIfNotExists()
 
         public PerplexRecaptchaConfig PerplexRecaptchaConfig { get; set; }
 
+        public PerplexCacheConfig PerplexCacheConfig { get; set; }
+
         private static string GetFilePath()
         {
             return HostingEnvironment.MapPath(Constants.CONFIGURATION_FILE_PATH);
@@ -139,6 +139,12 @@ private static string GetFilePath()
             PerplexRecaptchaConfig = new PerplexRecaptchaConfig
             {
                 ErrorMessage = ""
+            },
+
+            PerplexCacheConfig = new PerplexCacheConfig
+            {
+                EnableCache = false,
+                CacheDurationInMinutes = 10
             }
         };
     }
diff --git a/Perplex.Umbraco.Forms/Code/ICacheService.cs b/Perplex.Umbraco.Forms/Code/ICacheService.cs
@@ -0,0 +1,15 @@
+﻿using System;
+
+namespace PerplexUmbraco.Forms.Code
+{
+    public interface ICacheService
+    {
+        T GetRequestCache<T>(string cacheKey);
+        void SetRequestCache(string cacheKey, object cacheObject);
+        T GetRuntimeCache<T>(string cacheKey);
+        void SetRuntimeCache(string cacheKey, object cacheObject, TimeSpan duration);
+        void SetRuntimeCache(string cacheKey, object cacheObject, TimeSpan duration, bool isSliding);
+        void ClearRuntimeCacheByKey(string cacheKey);
+        void ClearRuntimeCacheByPrefix(string prefix);
+    }
+}
diff --git a/Perplex.Umbraco.Forms/Code/ObjectExtensions.cs b/Perplex.Umbraco.Forms/Code/ObjectExtensions.cs
@@ -0,0 +1,104 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+
+namespace PerplexUmbraco.Forms.Code
+{
+    public static class ObjectExtensions
+    {
+        private static readonly MethodInfo CloneMethod = typeof(Object).GetMethod("MemberwiseClone", BindingFlags.NonPublic | BindingFlags.Instance);
+
+        public static bool IsPrimitive(this Type type)
+        {
+            if (type == typeof(String)) return true;
+            return (type.IsValueType & type.IsPrimitive);
+        }
+
+        public static Object Copy(this Object originalObject)
+        {
+            return InternalCopy(originalObject, new Dictionary<Object, Object>(new ReferenceEqualityComparer()));
+        }
+
+        public static T Copy<T>(this T original)
+        {
+            return (T)Copy((Object)original);
+        }
+
+        public static bool IsNullOrWhiteSpaceString(this object item)
+        {
+            return string.IsNullOrWhiteSpace(item?.ToString());
+        }
+
+        public static string ToJson(this object o, bool camelCase = false)
+        {
+            var settings = new JsonSerializerSettings();
+            if (camelCase)
+            {
+                settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
+            }
+
+            return JsonConvert.SerializeObject(o, settings);
+        }
+
+        private static Object InternalCopy(Object originalObject, IDictionary<Object, Object> visited)
+        {
+            if (originalObject == null) return null;
+            var typeToReflect = originalObject.GetType();
+            if (IsPrimitive(typeToReflect)) return originalObject;
+            if (visited.ContainsKey(originalObject)) return visited[originalObject];
+            if (typeof(Delegate).IsAssignableFrom(typeToReflect)) return null;
+            var cloneObject = CloneMethod.Invoke(originalObject, null);
+            if (typeToReflect.IsArray)
+            {
+                var arrayType = typeToReflect.GetElementType();
+                if (IsPrimitive(arrayType) == false)
+                {
+                    Array clonedArray = (Array)cloneObject;
+                    clonedArray.ForEach((array, indices) => array.SetValue(InternalCopy(clonedArray.GetValue(indices), visited), indices));
+                }
+
+            }
+            visited.Add(originalObject, cloneObject);
+            CopyFields(originalObject, visited, cloneObject, typeToReflect);
+            RecursiveCopyBaseTypePrivateFields(originalObject, visited, cloneObject, typeToReflect);
+            return cloneObject;
+        }
+
+        private static void RecursiveCopyBaseTypePrivateFields(object originalObject, IDictionary<object, object> visited, object cloneObject, Type typeToReflect)
+        {
+            if (typeToReflect.BaseType != null)
+            {
+                RecursiveCopyBaseTypePrivateFields(originalObject, visited, cloneObject, typeToReflect.BaseType);
+                CopyFields(originalObject, visited, cloneObject, typeToReflect.BaseType, BindingFlags.Instance | BindingFlags.NonPublic, info => info.IsPrivate);
+            }
+        }
+
+        private static void CopyFields(object originalObject, IDictionary<object, object> visited, object cloneObject, Type typeToReflect, BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy, Func<FieldInfo, bool> filter = null)
+        {
+            foreach (FieldInfo fieldInfo in typeToReflect.GetFields(bindingFlags))
+            {
+                if (filter != null && filter(fieldInfo) == false) continue;
+                if (IsPrimitive(fieldInfo.FieldType)) continue;
+                var originalFieldValue = fieldInfo.GetValue(originalObject);
+                var clonedFieldValue = InternalCopy(originalFieldValue, visited);
+                fieldInfo.SetValue(cloneObject, clonedFieldValue);
+            }
+        }
+    }
+
+    public class ReferenceEqualityComparer : EqualityComparer<Object>
+    {
+        public override bool Equals(object x, object y)
+        {
+            return ReferenceEquals(x, y);
+        }
+        public override int GetHashCode(object obj)
+        {
+            if (obj == null) return 0;
+            return obj.GetHashCode();
+        }
+    }
+}
diff --git a/Perplex.Umbraco.Forms/Code/UmbracoEvents.cs b/Perplex.Umbraco.Forms/Code/UmbracoEvents.cs
diff --git a/Perplex.Umbraco.Forms/Controllers/PerplexFormTreeController.cs b/Perplex.Umbraco.Forms/Controllers/PerplexFormTreeController.cs
diff --git a/Perplex.Umbraco.Forms/Controllers/PerplexUmbracoFormController.cs b/Perplex.Umbraco.Forms/Controllers/PerplexUmbracoFormController.cs
diff --git a/Perplex.Umbraco.Forms/Perplex.Umbraco.Forms.csproj b/Perplex.Umbraco.Forms/Perplex.Umbraco.Forms.csproj
diff --git a/Perplex.Umbraco.Forms/packages.config b/Perplex.Umbraco.Forms/packages.config
