Feature #26: User Flags

Flags can be associated with Users. Includes minor updates to Job Queues
and improved visibility of user information.

Disco.Services/Users/UserFlags/Cache.cs

@@ -0,0 +1,82 @@
+using Disco.Data.Repository;
+using Disco.Models.Repository;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Disco.Services.Users.UserFlags
+{
+    internal class Cache
+    {
+        private ConcurrentDictionary<int, UserFlag> _Cache;
+
+        public Cache(DiscoDataContext Database)
+        {
+            Initialize(Database);
+        }
+
+        public void ReInitialize(DiscoDataContext Database)
+        {
+            Initialize(Database);
+        }
+
+        private void Initialize(DiscoDataContext Database)
+        {
+            // Queues from Database
+            var flags = Database.UserFlags.ToList();
+
+            // Add Queues to In-Memory Cache
+            this._Cache = new ConcurrentDictionary<int, UserFlag>(flags.Select(f => new KeyValuePair<int, UserFlag>(f.Id, f)));
+        }
+
+        public UserFlag GetUserFlag(int UserFlagId)
+        {
+            UserFlag item;
+            if (_Cache.TryGetValue(UserFlagId, out item))
+                return item;
+            else
+                return null;
+        }
+        public List<UserFlag> GetUserFlags()
+        {
+            return _Cache.Values.ToList();
+        }
+
+        public UserFlag Update(UserFlag UserFlag)
+        {
+            UserFlag existingItem;
+
+            if (_Cache.TryGetValue(UserFlag.Id, out existingItem))
+            {
+                if (_Cache.TryUpdate(UserFlag.Id, UserFlag, existingItem))
+                {
+                    return UserFlag;
+                }
+                else
+                    return null;
+            }
+            else
+            {
+                if (_Cache.TryAdd(UserFlag.Id, UserFlag))
+                {
+                    return UserFlag;
+                }
+                else
+                    return null;
+            }
+        }
+
+        public UserFlag Remove(int UserFlagId)
+        {
+            UserFlag item;
+            if (_Cache.TryRemove(UserFlagId, out item))
+                return item;
+            else
+                return null;
+        }
+        public UserFlag Remove(UserFlag UserFlag)
+        {
+            return Remove(UserFlag.Id);
+        }
+    }
+}

Disco.Services/Users/UserFlags/UserFlagService.cs

@@ -0,0 +1,100 @@
+using Disco.Data.Repository;
+using Disco.Models.Repository;
+using Disco.Services.Extensions;
+using Disco.Services.Tasks;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Disco.Services.Users.UserFlags
+{
+    public static class UserFlagService
+    {
+        private static Cache _cache;
+
+        public static void Initialize(DiscoDataContext Database)
+        {
+            _cache = new Cache(Database);
+        }
+
+        public static List<UserFlag> GetUserFlags() { return _cache.GetUserFlags(); }
+        public static UserFlag GetUserFlag(int UserFlagId) { return _cache.GetUserFlag(UserFlagId); }
+
+        #region User Flag Maintenance
+        public static UserFlag CreateUserFlag(DiscoDataContext Database, UserFlag UserFlag)
+        {
+            // Verify
+            if (string.IsNullOrWhiteSpace(UserFlag.Name))
+                throw new ArgumentException("The User Flag Name is required");
+
+            // Name Unique
+            if (_cache.GetUserFlags().Any(f => f.Name == UserFlag.Name))
+                throw new ArgumentException("Another User Flag already exists with that name", "UserFlag");
+
+            // Clone to break reference
+            var flag = new UserFlag()
+            {
+                Name = UserFlag.Name,
+                Description = UserFlag.Description,
+                Icon = UserFlag.Icon,
+                IconColour = UserFlag.IconColour
+            };
+
+            Database.UserFlags.Add(flag);
+            Database.SaveChanges();
+
+            return _cache.Update(flag);
+        }
+        public static UserFlag Update(DiscoDataContext Database, UserFlag UserFlag)
+        {
+            // Verify
+            if (string.IsNullOrWhiteSpace(UserFlag.Name))
+                throw new ArgumentException("The User Flag Name is required");
+
+            // Name Unique
+            if (_cache.GetUserFlags().Any(f => f.Id != UserFlag.Id && f.Name == UserFlag.Name))
+                throw new ArgumentException("Another User Flag already exists with that name", "UserFlag");
+
+            Database.SaveChanges();
+
+            return _cache.Update(UserFlag);
+        }
+        public static void DeleteUserFlag(DiscoDataContext Database, int UserFlagId, IScheduledTaskStatus Status)
+        {
+            UserFlag flag = Database.UserFlags.Find(UserFlagId);
+
+            // Delete Assignments
+            Status.UpdateStatus(0, string.Format("Removing '{0}' [{1}] User Flag", flag.Name, flag.Id), "Starting");
+            List<UserFlagAssignment> flagAssignments = Database.UserFlagAssignments.Where(fa => fa.UserFlagId == flag.Id).ToList();
+            if (flagAssignments.Count > 0)
+            {
+                Status.UpdateStatus(20, "Removing flag from users");
+                flagAssignments.ForEach(flagAssignment => Database.UserFlagAssignments.Remove(flagAssignment));
+                Database.SaveChanges();
+            }
+
+            // Delete Flag
+            Status.UpdateStatus(90, "Deleting User Flag");
+            Database.UserFlags.Remove(flag);
+            Database.SaveChanges();
+
+            // Remove from Cache
+            _cache.Remove(UserFlagId);
+
+            Status.Finished(string.Format("Successfully Deleted User Flag: '{0}' [{1}]", flag.Name, flag.Id));
+        }
+        #endregion
+
+        public static string RandomUnusedIcon()
+        {
+            return UIHelpers.RandomIcon(_cache.GetUserFlags().Select(f => f.Icon));
+        }
+        public static string RandomUnusedThemeColour()
+        {
+            return UIHelpers.RandomThemeColour(_cache.GetUserFlags().Select(f => f.IconColour));
+        }
+    }
+}

Disco.Services/Users/UserFlags/UserFlagsDeleteTask.cs

@@ -0,0 +1,34 @@
+using Disco.Data.Repository;
+using Disco.Services.Tasks;
+using Quartz;
+
+namespace Disco.Services.Users.UserFlags
+{
+    public class UserFlagDeleteTask : ScheduledTask
+    {
+        public override string TaskName { get { return "User Flags - Delete Flag"; } }
+
+        public override bool SingleInstanceTask { get { return false; }}
+        public override bool CancelInitiallySupported { get { return false; } }
+        public override bool LogExceptionsOnly { get { return true; } }
+
+        protected override void ExecuteTask()
+        {
+            int UserFlagId = (int)this.ExecutionContext.JobDetail.JobDataMap["UserFlagId"];
+
+            using (DiscoDataContext Database = new DiscoDataContext())
+            {
+                UserFlagService.DeleteUserFlag(Database, UserFlagId, this.Status);
+            }
+        }
+
+        public static ScheduledTaskStatus ScheduleNow(int UserFlagId)
+        {
+            JobDataMap taskData = new JobDataMap() { { "UserFlagId", UserFlagId } };
+
+            var instance = new UserFlagDeleteTask();
+
+            return instance.ScheduleTask(taskData);
+        }
+    }
+}