#138 device flag services

2024-01-14 17:54:06 +11:00
parent 53baf4eb78
commit 15e2806731
10 changed files with 1292 additions and 0 deletions
@@ -0,0 +1,196 @@
+using Disco.Data.Repository;
+using Disco.Models.Repository;
+using Disco.Services.Authorization;
+using Disco.Services.Expressions;
+using Disco.Services.Logging;
+using Disco.Services.Users;
+using System;
+using System.Collections;
+using System.Data.Entity;
+using System.Linq;
+
+namespace Disco.Services
+{
+    public static class DeviceFlagExtensions
+    {
+
+        #region Edit Comments
+        public static bool CanEditComments(this DeviceFlagAssignment fa)
+        {
+            return UserService.CurrentAuthorization.Has(Claims.Device.Actions.EditFlags);
+        }
+        public static void OnEditComments(this DeviceFlagAssignment fa, string Comments)
+        {
+            if (!fa.CanEditComments())
+                throw new InvalidOperationException("Editing comments for device flags is denied");
+
+            fa.Comments = string.IsNullOrWhiteSpace(Comments) ? null : Comments.Trim();
+        }
+        #endregion
+
+        #region Remove
+        public static bool CanRemove(this DeviceFlagAssignment fa)
+        {
+            if (fa.RemovedDate.HasValue)
+                return false;
+
+            return UserService.CurrentAuthorization.Has(Claims.Device.Actions.RemoveFlags);
+        }
+        public static void OnRemove(this DeviceFlagAssignment fa, DiscoDataContext Database, User RemovingUser)
+        {
+            if (!fa.CanRemove())
+                throw new InvalidOperationException("Removing device flags is denied");
+
+            fa.OnRemoveUnsafe(Database, RemovingUser);
+        }
+
+        public static void OnRemoveUnsafe(this DeviceFlagAssignment fa, DiscoDataContext Database, User RemovingUser)
+        {
+            fa = Database.DeviceFlagAssignments
+                .Include(a => a.DeviceFlag)
+                .First(a => a.Id == fa.Id);
+            RemovingUser = Database.Users.First(u => u.UserId == RemovingUser.UserId);
+
+            fa.RemovedDate = DateTime.Now;
+            fa.RemovedUserId = RemovingUser.UserId;
+
+            if (!string.IsNullOrWhiteSpace(fa.DeviceFlag.OnUnassignmentExpression))
+            {
+                try
+                {
+                    Database.SaveChanges();
+                    var expressionResult = fa.EvaluateOnUnassignmentExpression(Database, RemovingUser, fa.AddedDate);
+                    if (!string.IsNullOrWhiteSpace(expressionResult))
+                    {
+                        fa.OnUnassignmentExpressionResult = expressionResult;
+                        Database.SaveChanges();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    SystemLog.LogException("Device Flag Expression - OnUnassignmentExpression", ex);
+                }
+            }
+        }
+        #endregion
+
+        #region Add
+        public static bool CanAddDeviceFlags(this Device d)
+        {
+            return UserService.CurrentAuthorization.Has(Claims.Device.Actions.AddFlags);
+        }
+        public static bool CanAddDeviceFlag(this Device d, DeviceFlag flag)
+        {
+            // Shortcut
+            if (!d.CanAddDeviceFlags())
+                return false;
+
+            // Already has Device Flag?
+            if (d.DeviceFlagAssignments.Any(fa => !fa.RemovedDate.HasValue && fa.DeviceFlagId == flag.Id))
+                return false;
+
+            return true;
+        }
+        public static DeviceFlagAssignment OnAddDeviceFlag(this Device d, DiscoDataContext Database, DeviceFlag flag, User AddingUser, string Comments)
+        {
+            if (!d.CanAddDeviceFlag(flag))
+                throw new InvalidOperationException("Adding device flag is denied");
+
+            return d.OnAddDeviceFlagUnsafe(Database, flag, AddingUser, Comments);
+        }
+
+        public static DeviceFlagAssignment OnAddDeviceFlagUnsafe(this Device d, DiscoDataContext Database, DeviceFlag flag, User AddingUser, string Comments)
+        {
+            flag = Database.DeviceFlags.First(f => f.Id == flag.Id);
+            d = Database.Devices.First(de => de.SerialNumber == d.SerialNumber);
+            AddingUser = Database.Users.First(user => user.UserId == AddingUser.UserId);
+
+            var fa = new DeviceFlagAssignment()
+            {
+                DeviceFlag = flag,
+                Device = d,
+                AddedDate = DateTime.Now,
+                AddedUser = AddingUser,
+                AddedUserId = AddingUser.UserId,
+                Comments = string.IsNullOrWhiteSpace(Comments) ? null : Comments.Trim()
+            };
+
+            Database.DeviceFlagAssignments.Add(fa);
+
+            if (!string.IsNullOrWhiteSpace(flag.OnAssignmentExpression))
+            {
+                try
+                {
+                    Database.SaveChanges();
+                    var expressionResult = fa.EvaluateOnAssignmentExpression(Database, AddingUser, fa.AddedDate);
+                    if (!string.IsNullOrWhiteSpace(expressionResult))
+                    {
+                        fa.OnAssignmentExpressionResult = expressionResult;
+                        Database.SaveChanges();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    SystemLog.LogException("Device Flag Expression - OnAssignmentExpression", ex);
+                }
+            }
+
+            return fa;
+        }
+        #endregion
+
+        #region Expressions
+
+        public static Expression OnAssignmentExpressionFromCache(this DeviceFlag uf)
+        {
+            return ExpressionCache.GetOrCreateSingleExpressions($"DeviceFlag_OnAssignmentExpression_{uf.Id}", () => Expression.TokenizeSingleDynamic(null, uf.OnAssignmentExpression, 0));
+        }
+
+        public static void OnAssignmentExpressionInvalidateCache(this DeviceFlag uf)
+        {
+            ExpressionCache.InvalidateSingleCache($"DeviceFlag_OnAssignmentExpression_{uf.Id}");
+        }
+
+        public static string EvaluateOnAssignmentExpression(this DeviceFlagAssignment dfa, DiscoDataContext Database, User AddingUser, DateTime TimeStamp)
+        {
+            if (!string.IsNullOrEmpty(dfa.DeviceFlag.OnAssignmentExpression))
+            {
+                Expression compiledExpression = dfa.DeviceFlag.OnAssignmentExpressionFromCache();
+                IDictionary evaluatorVariables = Expression.StandardVariables(null, Database, AddingUser, TimeStamp, null, dfa.Device);
+                object result = compiledExpression.EvaluateFirst<object>(dfa, evaluatorVariables);
+                if (result == null)
+                    return null;
+                else
+                    return result.ToString();
+            }
+            return null;
+        }
+
+        public static Expression OnUnassignmentExpressionFromCache(this DeviceFlag df)
+        {
+            return ExpressionCache.GetOrCreateSingleExpressions($"DeviceFlag_OnUnassignmentExpression_{df.Id}", () => Expression.TokenizeSingleDynamic(null, df.OnUnassignmentExpression, 0));
+        }
+
+        public static void OnUnassignmentExpressionInvalidateCache(this DeviceFlag df)
+        {
+            ExpressionCache.InvalidateSingleCache($"DeviceFlag_OnUnassignmentExpression_{df.Id}");
+        }
+
+        public static string EvaluateOnUnassignmentExpression(this DeviceFlagAssignment dfa, DiscoDataContext Database, User RemovingUser, DateTime TimeStamp)
+        {
+            if (!string.IsNullOrEmpty(dfa.DeviceFlag.OnUnassignmentExpression))
+            {
+                Expression compiledExpression = dfa.DeviceFlag.OnUnassignmentExpressionFromCache();
+                IDictionary evaluatorVariables = Expression.StandardVariables(null, Database, RemovingUser, TimeStamp, null, dfa.Device);
+                object result = compiledExpression.EvaluateFirst<object>(dfa, evaluatorVariables);
+                if (result == null)
+                    return null;
+                else
+                    return result.ToString();
+            }
+            return null;
+        }
+
+        #endregion
+    }
+}