com.amanotes.gdk 0.2.47 → 0.2.49

package/Runtime/Klavar/Attributes/MinMaxAttribute.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Min, Max validate param
+    /// </summary>
+    public class MinMaxAttribute : ValidateLogEventAttribute
+    {
+
+        public readonly double min;
+
+        public readonly double max;
+
+        public MinMaxAttribute(double min, double max)
+        {
+            this.min = min;
+            this.max = max;
+        }
+
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (!(param is int) && !(param is float) && !(param is double))
+                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
+
+            double val = Convert.ToDouble(param);
+            if (val < min) throw new ArgumentException($"Field `{fieldInfo.Name}` must be in range [{min}, {max}]. Current value: {param}");
+            if (val > max) throw new ArgumentException($"Field `{fieldInfo.Name}` must be in range [{min}, {max}]. Current value: {param}");
+        }
+    }
+
+
+    public class MinimumAttribute : ValidateLogEventAttribute
+    {
+
+        public readonly double min;
+
+
+        public MinimumAttribute(double min)
+        {
+            this.min = min;
+        }
+
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (!(param is int) && !(param is float) && !(param is double))
+                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
+
+            double val = Convert.ToDouble(param);
+            if (val < min) throw new ArgumentException($"Field `{fieldInfo.Name}` must be greater or equal to {min}. Current value: {param}");
+        }
+    }
+
+
+    public class ExclusiveMinimumAttribute : ValidateLogEventAttribute
+    {
+
+        public readonly double min;
+
+
+        public ExclusiveMinimumAttribute(double min)
+        {
+            this.min = min;
+        }
+
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (!(param is int) && !(param is float) && !(param is double))
+                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
+
+            double val = Convert.ToDouble(param);
+            if (val <= min) throw new ArgumentException($"Field `{fieldInfo.Name}` must be greater {min}. Current value: {param}");
+        }
+    }
+
+
+
+
+
+    public class MaximumAttribute : ValidateLogEventAttribute
+    {
+
+        public readonly double max;
+
+
+        public MaximumAttribute(double max)
+        {
+            this.max = max;
+        }
+
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (!(param is int) && !(param is float) && !(param is double))
+                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
+
+            double val = Convert.ToDouble(param);
+            if (val > max) throw new ArgumentException($"Field `{fieldInfo.Name}` must be smaller or equal to {max}. Current value: {param}");
+        }
+    }
+
+
+    public class ExclusiveMaximumAttribute : ValidateLogEventAttribute
+    {
+
+        public readonly double max;
+
+
+        public ExclusiveMaximumAttribute(double max)
+        {
+            this.max = max;
+        }
+
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (!(param is int) && !(param is float) && !(param is double))
+                throw new ArgumentException($"type of `{fieldInfo.Name}` is must be int, float or double");
+
+            double val = Convert.ToDouble(param);
+            if (val >= max) throw new ArgumentException($"Field `{fieldInfo.Name}` must be smaller to {max}. Current value: {param}");
+        }
+    }
+}
+
+

package/Runtime/Klavar/Attributes/MinMaxAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c773f7760fee54649bbd4adc39fc2c5b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/MinMaxLengthAttribute.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Min, Max length valudate validate param. (Just apply for string only)
+    /// </summary>
+    public class MinMaxLengthAttribute : ValidateLogEventAttribute
+    {
+        public readonly int min;
+        public readonly int max;
+
+        public MinMaxLengthAttribute(int min, int max)
+        {
+            this.min = min;
+            this.max = max;
+        }
+
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (!(param is string text)) throw new ArgumentException($"Field {fieldInfo.Name} must be string.");
+            if (param is null) throw new ArgumentException($"Field {fieldInfo.Name} must not be null.");
+            if (text.Length < min) throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be in range [{min}, {max}]. Current length: {text.Length}");
+            if (text.Length > max) throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be in range [{min}, {max}]. Current length: {text.Length}");
+        }
+    }
+
+
+    public class MinLengthAttribute : ValidateLogEventAttribute
+    {
+        public readonly int min;
+
+        public MinLengthAttribute(int min)
+        {
+            this.min = min;
+        }
+
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (!(param is string text)) throw new ArgumentException($"Field {fieldInfo.Name} must be string.");
+            if (param is null) throw new ArgumentException($"Field {fieldInfo.Name} must not be null.");
+            if (text.Length < min) throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be greater or equal to {min}. Current length: {text.Length}");
+        }
+    }
+
+
+    public class MaxLengthAttribute : ValidateLogEventAttribute
+    {
+        public readonly int max;
+
+        public MaxLengthAttribute(int max)
+        {
+            this.max = max;
+        }
+
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (!(param is string text)) throw new ArgumentException($"Field {fieldInfo.Name} must be string.");
+            if (param is null) throw new ArgumentException($"Field {fieldInfo.Name} must not be null.");
+            if (text.Length > max) throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be smaller or equal to {max}. Current length: {text.Length}");
+        }
+    }
+
+
+    public class FixedLengthAttribute : ValidateLogEventAttribute
+    {
+        public readonly int length;
+
+        public FixedLengthAttribute(int length)
+        {
+            this.length = length;
+        }
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (!(param is string text)) throw new ArgumentException($"Field {fieldInfo.Name} must be string.");
+            if (param is null) throw new ArgumentException($"Field {fieldInfo.Name} must not be null.");
+            if (text.Length != length)
+                throw new ArgumentException($"The length of string field `{fieldInfo.Name}` must be equal to {length}. Current length: {text.Length}");
+        }
+    }
+}
+
+

package/Runtime/Klavar/Attributes/MinMaxLengthAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6b927e38cacb34a7195b04f17f90c2f3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/NameAttribute.cs

@@ -0,0 +1,35 @@
+
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+
+    /// <summary>
+    /// Change the Name of param
+    /// </summary>
+    public class NameAttribute : NamingLogEventAttribute
+    {
+        public readonly string name;
+
+        public NameAttribute(string name)
+        {
+            this.name = name;
+        }
+        public override string GetName(object parent, FieldInfo fieldInfo) => name;
+    }
+
+
+
+    /// <summary>
+    /// Set the event name
+    /// </summary>
+    public class EventNameAttribute : KlavarEventAttribute
+    {
+        public readonly string name;
+
+        public EventNameAttribute(string name)
+        {
+            this.name = name;
+        }
+    }
+}

package/Runtime/Klavar/Attributes/NameAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 47031184d3e984c99abbca06a5c51fe0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/NotNullAttribute.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Not null validate param
+    /// </summary>
+    public class NotNullAttribute : ValidateLogEventAttribute
+    {
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (param is null) throw new ArgumentException($"Field `{fieldInfo.Name}` must not be null");
+        }
+    }
+}

package/Runtime/Klavar/Attributes/NotNullAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a9edce640cd3545c6a026d6590a1f50d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/RegexPatternAttribute.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace Amanotes.Core
+{
+#pragma warning disable CS3015
+
+    /// <summary>
+    /// Apply Regex Validation for param
+    /// </summary>
+    public class RegexPatternAttribute : ValidateLogEventAttribute
+    {
+        public readonly string[] regexes;
+
+
+        public RegexPatternAttribute(string regex)
+        {
+            this.regexes = new string[] { regex };
+        }
+
+
+        public RegexPatternAttribute(string[] regexes)
+        {
+            this.regexes = regexes;
+        }
+
+
+        public override void Validate(object parent, FieldInfo fieldInfo, object param)
+        {
+            if (param is null) throw new ArgumentException($"Field `{fieldInfo.Name}` must not be null");
+            foreach (var regex in regexes)
+            {
+                var match = Regex.Match(param.ToString(), regex);
+                if (match != null && match.Success) return;
+            }
+            throw new ArgumentException($"Field `{fieldInfo.Name}` is not match as {this.GetType().Name.Replace("Attribute", "")}");
+        }
+    }
+
+#pragma warning restore CA2200
+
+    /// <summary>
+    /// Is Email validate Param
+    /// </summary>
+    public class IsEmailAddressAttribute : RegexPatternAttribute
+    {
+        public IsEmailAddressAttribute() : base(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$") { }
+    }
+
+    /// <summary>
+    /// Is ObjectID validate param
+    /// </summary>
+    public class IsObjectIDAttribute : RegexPatternAttribute
+    {
+        public IsObjectIDAttribute() : base(@"^(?=[a-f\d]{24}$)(\d+[a-f]|[a-f]+\d)") { }
+    }
+}

package/Runtime/Klavar/Attributes/RegexPatternAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b25602076710f4965a41f41a5d1afb46
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/TimeDiffLastFireAttribute.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    public class TimeDiffLastFireAttribute : ConverterLogEventAttribute
+    {
+        static readonly Dictionary<string, float> lastFireInSessions = new Dictionary<string, float>();
+
+        public override object Convert(object parent, FieldInfo fieldInfo, object param)
+        {
+            // return AmaGDK.Ads.InterstitialShowCalledInSession;
+            string name = parent.GetType().FullName;
+            if (!lastFireInSessions.TryGetValue(name, out var lastFire))
+            {
+                lastFireInSessions[name] = Time.realtimeSinceStartup;
+                return 0;
+            }
+
+            var current = Time.realtimeSinceStartup;
+            var diff = Mathf.RoundToInt(current - lastFire);
+            lastFireInSessions[name] = current;
+            return diff;
+        }
+    }
+
+}

package/Runtime/Klavar/Attributes/TimeDiffLastFireAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e93b0c22875584b17840d4a5c8e30424
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/ToStringAttribute.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace Amanotes.Core
+{
+#pragma warning disable CS3005
+
+    /// <summary>
+    /// Convert param to string 
+    /// </summary>
+    public class ToStringAttribute : ConverterLogEventAttribute
+    {
+        public enum Converter
+        {
+            NoThing,
+
+            ToLowerCase,
+            ToUpperCase,
+
+            ToSnakeCase,
+            ToCamelCase,
+            ToPascalCase,
+            ToKebabCase
+        }
+
+        static readonly Dictionary<Converter, Func<string, string>> convertMethods = new Dictionary<Converter, Func<string, string>>()
+    {
+        {Converter.NoThing, val=>val},
+        {Converter.ToLowerCase, KlavarEventUtils.ToLowerCase},
+        {Converter.ToUpperCase, KlavarEventUtils.ToUpperCase},
+        {Converter.ToSnakeCase, KlavarEventUtils.ToSnakeCase},
+        {Converter.ToCamelCase, KlavarEventUtils.ToCamelCase},
+        {Converter.ToPascalCase, KlavarEventUtils.ToPascalCase},
+        {Converter.ToKebabCase, KlavarEventUtils.ToKebabCase},
+    };
+
+        public readonly Converter converter;
+
+        public ToStringAttribute() { converter = Converter.NoThing; }
+
+        public ToStringAttribute(Converter converter)
+        {
+            this.converter = converter;
+        }
+
+        private string GetValueAsString(object enumVal)
+        {
+            // get the field 
+            var field = enumVal.GetType().GetField(enumVal.ToString());
+            var attr = field.GetCustomAttribute<ValueAttribute>();
+
+            return attr != null ? convertMethods[converter](attr.sValue) : convertMethods[converter](enumVal.ToString());
+        }
+
+        public override object Convert(object parent, FieldInfo fieldInfo, object param)
+        {
+            return GetValueAsString(param);
+        }
+    }
+
+
+    public class ToStringLowerCase : ToStringAttribute
+    {
+        public ToStringLowerCase() : base(ToStringAttribute.Converter.ToLowerCase) { }
+    }
+
+
+    public class ToStringUpperCase : ToStringAttribute
+    {
+        public ToStringUpperCase() : base(ToStringAttribute.Converter.ToUpperCase) { }
+    }
+
+
+    public class ToStringToSnakeCase : ToStringAttribute
+    {
+        public ToStringToSnakeCase() : base(ToStringAttribute.Converter.ToSnakeCase) { }
+    }
+
+    public class ToStringCamelCase : ToStringAttribute
+    {
+        public ToStringCamelCase() : base(ToStringAttribute.Converter.ToCamelCase) { }
+    }
+
+    public class ToStringPascalCase : ToStringAttribute
+    {
+        public ToStringPascalCase() : base(ToStringAttribute.Converter.ToPascalCase) { }
+    }
+
+
+    public class ToStringKebabCase : ToStringAttribute
+    {
+        public ToStringKebabCase() : base(ToStringAttribute.Converter.ToKebabCase) { }
+    }
+
+#pragma warning restore CS3005
+}

package/Runtime/Klavar/Attributes/ToStringAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 68cd1a5ce6bfe432d8fceab8620a0d0f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes/ValueAttribute.cs

@@ -0,0 +1,30 @@
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// Change the value of param to new value in the attribute
+    /// </summary>
+    public class ValueAttribute : KlavarEventAttribute
+    {
+        public readonly int iValue;
+        public readonly string sValue;
+        public readonly float fValue;
+        public readonly double dValue;
+        public ValueAttribute(int value)
+        {
+            this.iValue = value;
+        }
+        public ValueAttribute(string value)
+        {
+            this.sValue = value;
+        }
+        public ValueAttribute(float value)
+        {
+            this.fValue = value;
+        }
+
+        public ValueAttribute(double value)
+        {
+            this.dValue = value;
+        }
+    }
+}

package/Runtime/Klavar/Attributes/ValueAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a4ddd16b5626545308d6e9948917f0a4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/Attributes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 74f302749097e44ff889ed117ec82dd3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Klavar/KlavarEvent.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+
+namespace Amanotes.Core
+{
+    /// <summary>
+    /// LogEvent parameters Schema
+    /// </summary>
+    public abstract class KlavarEvent
+    {
+        /// <summary>
+        /// LogEvent
+        /// </summary>
+        /// <exception cref="ArgumentException"></exception>
+        public void LogEvent()
+        {
+            var type = this.GetType();
+            var eventNameAttr = (EventNameAttribute)Attribute.GetCustomAttribute(type, typeof(EventNameAttribute));
+
+            if (eventNameAttr == null)
+                throw new ArgumentException($"Add `EventName` attribute to class {type.FullName}");
+            
+            var @params = this.ToDict();
+            var eventName = eventNameAttr.name;
+            AmaGDK.Analytics.LogEvent(eventName, @params);
+        }
+
+
+        /// <summary>
+        /// throw exception from attribute if field is invalid.
+        /// </summary>
+        /// <param name="field"></param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentException">when field go wrong.</exception>
+        private FieldInfo Validate(FieldInfo field)
+        {
+            var param = field.GetValue(this);
+            var attrs = field.GetCustomAttributes<ValidateLogEventAttribute>(true);
+            foreach (var attr in attrs) attr.Validate(this, field, param);
+
+            return field;
+        }
+
+        /// <summary>
+        /// Apply converter attribute in field.
+        /// </summary>
+        /// <param name="field"></param>
+        /// <returns></returns>
+        private object Convert(FieldInfo field)
+        {
+            var attrs = field.GetCustomAttributes<ConverterLogEventAttribute>(true);
+            var param = field.GetValue(this);
+            foreach (var attr in attrs) param = attr.Convert(this, field, param);
+            return param;
+        }
+
+
+        /// <summary>
+        /// Convert the name in field to new name by attribute.
+        /// </summary>
+        /// <param name="field"></param>
+        /// <returns>the new param name</returns>
+        private string GetName(FieldInfo field)
+        {
+            var attr = field.GetCustomAttribute<NamingLogEventAttribute>(true);
+            var param = field.GetValue(this);
+            return attr?.GetName(this, field) ?? field.Name;
+        }
+
+
+        /// <summary>
+        /// Convert all params to dict by field name.
+        /// </summary>
+        /// <returns>dictionary of params</returns>
+        public Dictionary<string, object> ToDict()
+        {
+            return this
+                .GetType()
+                .GetFields()
+                .Where(field => field.GetCustomAttribute<IgnoreAttribute>() == null)
+                .Select(field => Validate(field))
+                .ToDictionary(
+                    field => GetName(field),
+                    field => Convert(field)
+                );
+        }
+    }
+}