Update #26: User Flags Bulk Assignment

Add or Override User Flag assignments in bulk.

Disco.Services/Users/UserFlags/UserFlagService.cs

@@ -3,6 +3,7 @@ using Disco.Models.Repository;
 using Disco.Services.Extensions;
 using Disco.Services.Tasks;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
@@ -88,6 +89,103 @@ namespace Disco.Services.Users.UserFlags
         }
         #endregion
 
+        #region Bulk Assignment
+        public static IEnumerable<UserFlagAssignment> BulkAssignAddUsers(DiscoDataContext Database, UserFlag UserFlag, User Technician, string Comments, List<User> Users, IScheduledTaskStatus Status)
+        {
+            if (Users.Count > 0)
+            {
+
+                double progressInterval;
+                string comments = string.IsNullOrWhiteSpace(Comments) ? null : Comments.Trim();
+
+                var addUsers = Users.Where(u => !u.UserFlagAssignments.Any(a => a.UserFlagId == UserFlag.Id && !a.RemovedDate.HasValue)).ToList();
+
+                progressInterval = (double)100 / addUsers.Count;
+
+                var addedUserAssignments = addUsers.Select((user, index) =>
+                {
+                    Status.UpdateStatus(index * progressInterval, string.Format("Assigning Flag: {0}", user.ToString()));
+
+                    var fa = new UserFlagAssignment()
+                    {
+                        UserFlagId = UserFlag.Id,
+                        UserId = user.UserId,
+                        AddedDate = DateTime.Now,
+                        AddedUserId = Technician.UserId,
+                        Comments = comments
+                    };
+
+                    Database.UserFlagAssignments.Add(fa);
+                    Database.SaveChanges();
+                    return fa;
+                }).Where(fa => fa != null).ToList();
+
+                Status.SetFinishedMessage(string.Format("{0} Users/s Added; {1} User/s Skipped", addUsers.Count, (Users.Count - addUsers.Count)));
+                
+                return addedUserAssignments;
+            }
+            else
+            {
+                Status.SetFinishedMessage("No changes found");
+                return Enumerable.Empty<UserFlagAssignment>();
+            }
+        }
+
+        public static IEnumerable<UserFlagAssignment> BulkAssignOverrideUsers(DiscoDataContext Database, UserFlag UserFlag, User Technician, string Comments, List<User> Users, IScheduledTaskStatus Status)
+        {
+            double progressInterval;
+            string comments = string.IsNullOrWhiteSpace(Comments) ? null : Comments.Trim();
+
+            Status.UpdateStatus(0, "Calculating assignment changes");
+
+            var currentAssignments = Database.UserFlagAssignments.Include("User").Where(a => a.UserFlagId == UserFlag.Id && !a.RemovedDate.HasValue).ToList();
+            var removeAssignments = currentAssignments.Where(ca => !Users.Any(u => u.UserId.Equals(ca.UserId, StringComparison.OrdinalIgnoreCase))).ToList();
+            var addUsers = Users.Where(u => !currentAssignments.Any(ca => ca.UserId.Equals(u.UserId, StringComparison.OrdinalIgnoreCase))).ToList();
+
+            if (removeAssignments.Count > 0 || addUsers.Count > 0)
+            {
+                progressInterval = (double)100 / (removeAssignments.Count + addUsers.Count);
+                var removedDateTime = DateTime.Now;
+
+                removeAssignments.Select((flagAssignment, index) =>
+                {
+                    Status.UpdateStatus(index * progressInterval, string.Format("Removing Flag: {0}", flagAssignment.User.ToString()));
+                    flagAssignment.RemovedDate = removedDateTime;
+                    flagAssignment.RemovedUserId = Technician.UserId;
+                    Database.SaveChanges();
+                    return flagAssignment;
+                }).ToList();
+
+                var addedUserAssignments = addUsers.Select((user, index) =>
+                {
+                    Status.UpdateStatus((removeAssignments.Count + index) * progressInterval, string.Format("Assigning Flag: {0}", user.ToString()));
+
+                    var fa = new UserFlagAssignment()
+                    {
+                        UserFlagId = UserFlag.Id,
+                        UserId = user.UserId,
+                        AddedDate = DateTime.Now,
+                        AddedUserId = Technician.UserId,
+                        Comments = comments
+                    };
+
+                    Database.UserFlagAssignments.Add(fa);
+                    Database.SaveChanges();
+                    return fa;
+                }).ToList();
+
+                Status.SetFinishedMessage(string.Format("{0} Users/s Added; {1} User/s Removed; {2} User/s Skipped", addUsers.Count, removeAssignments.Count, (Users.Count - addUsers.Count)));
+
+                return addedUserAssignments;
+            }
+            else
+            {
+                Status.SetFinishedMessage("No changes found");
+                return Enumerable.Empty<UserFlagAssignment>();
+            }
+        }
+        #endregion
+
         public static string RandomUnusedIcon()
         {
             return UIHelpers.RandomIcon(_cache.GetUserFlags().Select(f => f.Icon));

Disco.Services/Users/UserFlags/UserFlagsBulkAssignTask.cs

@@ -0,0 +1,104 @@
+using Disco.Data.Repository;
+using Disco.Models.Repository;
+using Disco.Services.Interop.ActiveDirectory;
+using Disco.Services.Tasks;
+using Quartz;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Disco.Services.Users.UserFlags
+{
+    public class UserFlagBulkAssignTask : ScheduledTask
+    {
+        public override string TaskName { get { return "User Flags - Bulk Assign Users"; } }
+
+        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"];
+            string TechnicianUserId = (string)this.ExecutionContext.JobDetail.JobDataMap["TechnicianUserId"];
+            string Comments = (string)this.ExecutionContext.JobDetail.JobDataMap["Comments"];
+            List<string> UserIds = (List<string>)this.ExecutionContext.JobDetail.JobDataMap["UserIds"];
+            bool Override = (bool)this.ExecutionContext.JobDetail.JobDataMap["Override"];
+
+            using (DiscoDataContext Database = new DiscoDataContext())
+            {
+                // Load Flag
+                var userFlag = Database.UserFlags.FirstOrDefault(uf => uf.Id == UserFlagId);
+
+                if (userFlag == null)
+                    throw new Exception("Invalid User Flag Id");
+                Status.UpdateStatus(0, string.Format("Bulk Assigning Users to User Flag: {0}", userFlag.Name), "Preparing to start");
+
+                // Load Technician
+                var technician = Database.Users.FirstOrDefault(user => user.UserId == TechnicianUserId);
+                if (technician == null)
+                    throw new Exception("Invalid Technician User Id");
+
+                // Parse Users
+                var userIds = UserIds
+                    .Select(u => u.Contains('\\') ? u : string.Concat(ActiveDirectory.Context.PrimaryDomain.NetBiosName, @"\", u))
+                    .Distinct(StringComparer.OrdinalIgnoreCase).ToList();
+
+                Status.UpdateStatus(10, "Loading users from the database");
+                var users = Database.Users.Include("UserFlagAssignments").Where(u => userIds.Contains(u.UserId)).ToList();
+
+                var missingUserIds = userIds.Where(uid => !users.Any(u => u.UserId.Equals(uid, StringComparison.OrdinalIgnoreCase))).ToList();
+
+                if (missingUserIds.Count > 0)
+                {
+                    var invalidUsersIds = new List<string>();
+
+                    for (int index = 0; index < missingUserIds.Count; index++)
+                    {
+                        var userId = missingUserIds[index];
+                        Status.UpdateStatus(20 + (index * ((double)30 / missingUserIds.Count)), string.Format("Loading user from Active Directory: {0}", userId));
+                        try
+                        {
+                            users.Add(UserService.GetUser(userId, Database, true));
+                        }
+                        catch (Exception)
+                        {
+                            invalidUsersIds.Add(userId);
+                        }
+                    }
+
+                    if (invalidUsersIds.Count > 0)
+                        throw new InvalidOperationException(string.Format("Bulk assignment aborted, invalid User Ids: {0}", string.Join(", ", invalidUsersIds)));
+                }
+                users = users.OrderBy(u => u.UserId).ToList();
+
+                Status.ProgressOffset = 50;
+                Status.ProgressMultiplier = 0.5;
+
+                if (Override)
+                {
+                    UserFlagService.BulkAssignOverrideUsers(Database, userFlag, technician, Comments, users, Status);
+                }
+                else
+                {
+                    UserFlagService.BulkAssignAddUsers(Database, userFlag, technician, Comments, users, Status);
+                }
+            }
+        }
+
+        public static ScheduledTaskStatus ScheduleBulkAssignUsers(UserFlag UserFlag, User Technician, string Comments, List<string> UserIds, bool Override)
+        {
+            JobDataMap taskData = new JobDataMap() {
+                {"UserFlagId", UserFlag.Id },
+                {"TechnicianUserId", Technician.UserId },
+                {"Comments", Comments },
+                {"UserIds", UserIds },
+                {"Override", Override }
+            };
+
+            var instance = new UserFlagBulkAssignTask();
+
+            return instance.ScheduleTask(taskData);
+        }
+    }
+}