Version bump for release 1.2.1128

Updated bootstrapper correctly cleans up temporary files left by a
previous run which failed.

Disco.BI/BI/DataStore.cs

@@ -10,9 +10,9 @@ namespace Disco.BI
     public static class DataStore
     {
 
-        public static string CreateLocation(DiscoDataContext dbContext, string SubLocation, DateTime? SubSubLocationTimestamp = null)
+        public static string CreateLocation(DiscoDataContext Database, string SubLocation, DateTime? SubSubLocationTimestamp = null)
         {
-            return CreateLocation(dbContext.DiscoConfiguration, SubLocation, SubSubLocationTimestamp);
+            return CreateLocation(Database.DiscoConfiguration, SubLocation, SubSubLocationTimestamp);
         }
         public static string CreateLocation(SystemConfiguration DiscoConfiguration, string SubLocation, DateTime? SubSubLocationTimestamp = null)
         {

Disco.BI/BI/DeviceBI/BatchUtilities.cs

@@ -9,7 +9,7 @@ namespace Disco.BI.DeviceBI
 {
     public static class BatchUtilities
     {
-        public static DeviceBatch DefaultNewDeviceBatch(DiscoDataContext dbContext)
+        public static DeviceBatch DefaultNewDeviceBatch(DiscoDataContext Database)
         {
             return new DeviceBatch()
             {

Disco.BI/BI/DeviceBI/DeviceModelBI.cs

@@ -32,7 +32,7 @@ namespace Disco.BI
                     if (deviceModel == null)
                     {
                         // Create the Device Model in a different DataContext so we don't have to commit unrelated changes
-                        using (DiscoDataContext dbContext = new DiscoDataContext())
+                        using (DiscoDataContext database = new DiscoDataContext())
                         {
                             var addDeviceModel = new DeviceModel
                             {
@@ -41,8 +41,8 @@ namespace Disco.BI
                                 ModelType = ModelType,
                                 Description = string.Format("{0} {1}", Manufacturer, Model)
                             };
-                            dbContext.DeviceModels.Add(addDeviceModel);
-                            dbContext.SaveChanges();
+                            database.DeviceModels.Add(addDeviceModel);
+                            database.SaveChanges();
                         }
 
                         // Obtain the Device Model with the in-scope DataContext

Disco.BI/BI/DeviceBI/Enrol.cs

@@ -1,16 +1,16 @@
-using System;
-using System.Linq;
-using System.Text.RegularExpressions;
-using Disco.BI.Interop.ActiveDirectory;
 using Disco.BI.Extensions;
-using Disco.Data.Configuration.Modules;
+using Disco.BI.Interop.ActiveDirectory;
 using Disco.Data.Repository;
 using Disco.Models.ClientServices;
 using Disco.Models.Interop.ActiveDirectory;
 using Disco.Models.Repository;
+using Disco.Services.Authorization;
+using Disco.Services.Users;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
 using Tamir.SharpSsh;
-using Disco.Services.Plugins;
-using Disco.Services.Plugins.Features.CertificateProvider;
 
 namespace Disco.BI.DeviceBI
 {
@@ -24,7 +24,7 @@ namespace Disco.BI.DeviceBI
         }
 
         private static Regex SshPromptRegEx = new Regex("[\\$,\\#]", RegexOptions.Multiline);
-        public static MacSecureEnrolResponse MacSecureEnrol(DiscoDataContext dbContext, string Host)
+        public static MacSecureEnrolResponse MacSecureEnrol(DiscoDataContext Database, string Host)
         {
             MacEnrol trustedRequest = new MacEnrol();
             string sessionId = System.Guid.NewGuid().ToString("B");
@@ -32,8 +32,8 @@ namespace Disco.BI.DeviceBI
             try
             {
                 EnrolmentLog.LogSessionStarting(sessionId, Host, EnrolmentTypes.MacSecure);
-                EnrolmentLog.LogSessionProgress(sessionId, 0, string.Format("Connecting to '{0}' as '{1}'", Host, dbContext.DiscoConfiguration.Bootstrapper.MacSshUsername));
-                SshShell shell = new SshShell(Host, dbContext.DiscoConfiguration.Bootstrapper.MacSshUsername, dbContext.DiscoConfiguration.Bootstrapper.MacSshPassword);
+                EnrolmentLog.LogSessionProgress(sessionId, 0, string.Format("Connecting to '{0}' as '{1}'", Host, Database.DiscoConfiguration.Bootstrapper.MacSshUsername));
+                SshShell shell = new SshShell(Host, Database.DiscoConfiguration.Bootstrapper.MacSshUsername, Database.DiscoConfiguration.Bootstrapper.MacSshPassword);
                 try
                 {
                     shell.ExpectPattern = "#";
@@ -55,7 +55,7 @@ namespace Disco.BI.DeviceBI
                         output = shell.Expect(":");
                         EnrolmentLog.LogSessionProgress(sessionId, 27, "Connected, Elevating Credentials");
                         EnrolmentLog.LogSessionDiagnosticInformation(sessionId, output);
-                        shell.WriteLine(dbContext.DiscoConfiguration.Bootstrapper.MacSshPassword);
+                        shell.WriteLine(Database.DiscoConfiguration.Bootstrapper.MacSshPassword);
                         System.Threading.Thread.Sleep(250);
                         output = shell.Expect(SshPromptRegEx);
                         sessionElevated = true;
@@ -96,7 +96,7 @@ namespace Disco.BI.DeviceBI
                         shell.Close();
                     }
                     EnrolmentLog.LogSessionProgress(sessionId, 100, "Disconnected, Starting Disco Enrolment");
-                    MacSecureEnrolResponse response = MacSecureEnrolResponse.FromMacEnrolResponse(MacEnrol(dbContext, trustedRequest, true, sessionId));
+                    MacSecureEnrolResponse response = MacSecureEnrolResponse.FromMacEnrolResponse(MacEnrol(Database, trustedRequest, true, sessionId));
                     EnrolmentLog.LogSessionFinished(sessionId);
                     MacSecureEnrol = response;
                 }
@@ -211,7 +211,7 @@ namespace Disco.BI.DeviceBI
 
         #endregion
 
-        public static MacEnrolResponse MacEnrol(DiscoDataContext dbContext, MacEnrol Request, bool Trusted, string OpenSessionId = null)
+        public static MacEnrolResponse MacEnrol(DiscoDataContext Database, MacEnrol Request, bool Trusted, string OpenSessionId = null)
         {
             string sessionId;
             if (OpenSessionId == null)
@@ -228,7 +228,7 @@ namespace Disco.BI.DeviceBI
             try
             {
                 EnrolmentLog.LogSessionProgress(sessionId, 10, "Querying Database");
-                Device RepoDevice = dbContext.Devices.Include("AssignedUser").Include("DeviceProfile").Include("DeviceProfile").Where(d => d.SerialNumber == Request.DeviceSerialNumber).FirstOrDefault();
+                Device RepoDevice = Database.Devices.Include("AssignedUser").Include("DeviceProfile").Include("DeviceProfile").Where(d => d.SerialNumber == Request.DeviceSerialNumber).FirstOrDefault();
                 if (!Trusted)
                 {
                     if (RepoDevice == null)
@@ -240,9 +240,9 @@ namespace Disco.BI.DeviceBI
                 {
                     EnrolmentLog.LogSessionProgress(sessionId, 50, "New Device, Building Disco Instance");
                     EnrolmentLog.LogSessionTaskAddedDevice(sessionId, Request.DeviceSerialNumber);
-                    DeviceProfile deviceProfile = dbContext.DeviceProfiles.Find(dbContext.DiscoConfiguration.DeviceProfiles.DefaultDeviceProfileId);
+                    DeviceProfile deviceProfile = Database.DeviceProfiles.Find(Database.DiscoConfiguration.DeviceProfiles.DefaultDeviceProfileId);
 
-                    var deviceModelResult = dbContext.DeviceModels.GetOrCreateDeviceModel(Request.DeviceManufacturer.Trim(), Request.DeviceModel.Trim(), Request.DeviceModel.Trim());
+                    var deviceModelResult = Database.DeviceModels.GetOrCreateDeviceModel(Request.DeviceManufacturer.Trim(), Request.DeviceModel.Trim(), Request.DeviceModel.Trim());
                     DeviceModel deviceModel = deviceModelResult.Item1;
                     if (deviceModelResult.Item2)
                         EnrolmentLog.LogSessionTaskCreatedDeviceModel(sessionId, Request.DeviceSerialNumber, deviceModelResult.Item1.Manufacturer, deviceModelResult.Item1.Model);
@@ -259,7 +259,7 @@ namespace Disco.BI.DeviceBI
                         CreatedDate = DateTime.Now,
                         EnrolledDate = DateTime.Now
                     };
-                    dbContext.Devices.Add(RepoDevice);
+                    Database.Devices.Add(RepoDevice);
                 }
                 else
                 {
@@ -267,7 +267,7 @@ namespace Disco.BI.DeviceBI
                     EnrolmentLog.LogSessionTaskUpdatingDevice(sessionId, Request.DeviceSerialNumber);
                     if (!RepoDevice.DeviceModelId.HasValue || RepoDevice.DeviceModelId.Value == 1)
                     {
-                        var deviceModelResult = dbContext.DeviceModels.GetOrCreateDeviceModel(Request.DeviceManufacturer.Trim(), Request.DeviceModel.Trim(), Request.DeviceModel.Trim());
+                        var deviceModelResult = Database.DeviceModels.GetOrCreateDeviceModel(Request.DeviceManufacturer.Trim(), Request.DeviceModel.Trim(), Request.DeviceModel.Trim());
                         DeviceModel deviceModel = deviceModelResult.Item1;
                         if (deviceModelResult.Item2)
                             EnrolmentLog.LogSessionTaskCreatedDeviceModel(sessionId, Request.DeviceSerialNumber, deviceModelResult.Item1.Manufacturer, deviceModelResult.Item1.Model);
@@ -295,11 +295,11 @@ namespace Disco.BI.DeviceBI
                 if (RepoDevice.DeviceProfile.DistributionType == DeviceProfile.DistributionTypes.OneToOne && RepoDevice.AssignedUser != null)
                 {
                     ActiveDirectoryUserAccount AssignedUserInfo = ActiveDirectory.GetUserAccount(RepoDevice.AssignedUser.Id);
-                    EnrolmentLog.LogSessionTaskAssigningUser(sessionId, RepoDevice.SerialNumber, AssignedUserInfo.DisplayName, AssignedUserInfo.sAMAccountName, AssignedUserInfo.Domain, AssignedUserInfo.ObjectSid);
-                    response.DeviceAssignedUserUsername = AssignedUserInfo.sAMAccountName;
+                    EnrolmentLog.LogSessionTaskAssigningUser(sessionId, RepoDevice.SerialNumber, AssignedUserInfo.DisplayName, AssignedUserInfo.SamAccountName, AssignedUserInfo.Domain, AssignedUserInfo.SecurityIdentifier);
+                    response.DeviceAssignedUserUsername = AssignedUserInfo.SamAccountName;
                     response.DeviceAssignedUserDomain = AssignedUserInfo.Domain;
                     response.DeviceAssignedUserName = AssignedUserInfo.DisplayName;
-                    response.DeviceAssignedUserSID = AssignedUserInfo.ObjectSid;
+                    response.DeviceAssignedUserSID = AssignedUserInfo.SecurityIdentifier;
                 }
                 response.DeviceComputerName = RepoDevice.ComputerName;
                 EnrolmentLog.LogSessionProgress(sessionId, 100, "Completed Successfully");
@@ -321,11 +321,11 @@ namespace Disco.BI.DeviceBI
             }
             return response;
         }
-        public static EnrolResponse Enrol(DiscoDataContext dbContext, string Username, Models.ClientServices.Enrol Request)
+        public static EnrolResponse Enrol(DiscoDataContext Database, string Username, Models.ClientServices.Enrol Request)
         {
             ActiveDirectoryMachineAccount MachineInfo = null;
             EnrolResponse response = new EnrolResponse();
-            User authenticatedUser = null;
+            AuthorizationToken authenticatedToken = null;
             bool isAuthenticated = false;
             string sessionId = System.Guid.NewGuid().ToString("B");
             response.SessionId = sessionId;
@@ -336,29 +336,43 @@ namespace Disco.BI.DeviceBI
                 EnrolmentLog.LogSessionProgress(sessionId, 10, "Loading User Data");
                 if (!string.IsNullOrWhiteSpace(Username))
                 {
-                    authenticatedUser = UserBI.UserCache.GetUser(Username, dbContext);
-                    isAuthenticated = (authenticatedUser != null);
+                    authenticatedToken = UserService.GetAuthorization(Username, Database);
+                    isAuthenticated = (authenticatedToken != null);
                 }
                 EnrolmentLog.LogSessionProgress(sessionId, 13, "Loading Device Data");
 
-                Device RepoDevice = dbContext.Devices.Include("AssignedUser").Include("DeviceModel").Include("DeviceProfile").Where(d => d.SerialNumber == Request.DeviceSerialNumber).FirstOrDefault();
+                Device RepoDevice = Database.Devices.Include("AssignedUser").Include("DeviceModel").Include("DeviceProfile").Where(d => d.SerialNumber == Request.DeviceSerialNumber).FirstOrDefault();
                 EnrolmentLog.LogSessionProgress(sessionId, 15, "Discovering User/Device Disco Permissions");
                 if (isAuthenticated)
                 {
-                    if (authenticatedUser.Type != "Admin")
+                    if (!authenticatedToken.Has(Claims.Device.Actions.EnrolDevices))
                     {
-                        if (authenticatedUser.Type != "Computer")
-                            throw new EnrolSafeException(string.Format("Connection not correctly authenticated (SN: {0}; Auth User: {1}; User Type: {2})", Request.DeviceSerialNumber, authenticatedUser.Id, authenticatedUser.Type));
-                        if (!authenticatedUser.Id.Equals(string.Format("{0}$", Request.DeviceComputerName), System.StringComparison.InvariantCultureIgnoreCase))
-                            throw new EnrolSafeException(string.Format("Connection not correctly authenticated (SN: {0}; Auth User: {1}; User Type: {2})", Request.DeviceSerialNumber, authenticatedUser.Id, authenticatedUser.Type));
+                        if (!authenticatedToken.Has(Claims.ComputerAccount))
+                            throw new EnrolSafeException(string.Format("Connection not correctly authenticated (SN: {0}; Auth User: {1})", Request.DeviceSerialNumber, authenticatedToken.User.Id));
+                        if (!authenticatedToken.User.Id.Equals(string.Format("{0}$", Request.DeviceComputerName), System.StringComparison.InvariantCultureIgnoreCase))
+                            throw new EnrolSafeException(string.Format("Connection not correctly authenticated (SN: {0}; Auth User: {1})", Request.DeviceSerialNumber, authenticatedToken.User.Id));
                     }
                 }
                 else
                 {
                     if (RepoDevice == null)
+                    {
                         throw new EnrolSafeException(string.Format("Unknown Device Serial Number (SN: '{0}')", Request.DeviceSerialNumber));
+                    }
                     if (!RepoDevice.AllowUnauthenticatedEnrol)
-                        throw new EnrolSafeException(string.Format("Device isn't allowed an Unauthenticated Enrolment (SN: '{0}')", Request.DeviceSerialNumber));
+                    {
+                        if (RepoDevice.DeviceProfile.AllowUntrustedReimageJobEnrolment)
+                        {
+                            if (Database.Jobs.Count(j => j.DeviceSerialNumber == RepoDevice.SerialNumber && j.JobTypeId == JobType.JobTypeIds.SImg && !j.ClosedDate.HasValue) == 0)
+                            {
+                                throw new EnrolSafeException(string.Format("Device has no open 'Software - Reimage' job (SN: '{0}')", Request.DeviceSerialNumber));
+                            }
+                        }
+                        else
+                        {
+                            throw new EnrolSafeException(string.Format("Device isn't allowed an Unauthenticated Enrolment (SN: '{0}')", Request.DeviceSerialNumber));
+                        }
+                    }
                 }
                 if (Request.DeviceIsPartOfDomain && !string.IsNullOrWhiteSpace(Request.DeviceComputerName))
                 {
@@ -375,10 +389,10 @@ namespace Disco.BI.DeviceBI
                 {
                     EnrolmentLog.LogSessionProgress(sessionId, 30, "New Device, Creating Disco Instance");
                     EnrolmentLog.LogSessionTaskAddedDevice(sessionId, Request.DeviceSerialNumber);
-                    DeviceProfile deviceProfile = dbContext.DeviceProfiles.Find(dbContext.DiscoConfiguration.DeviceProfiles.DefaultDeviceProfileId);
+                    DeviceProfile deviceProfile = Database.DeviceProfiles.Find(Database.DiscoConfiguration.DeviceProfiles.DefaultDeviceProfileId);
 
 
-                    var deviceModelResult = dbContext.DeviceModels.GetOrCreateDeviceModel(Request.DeviceManufacturer.Trim(), Request.DeviceModel.Trim(), Request.DeviceModel.Trim());
+                    var deviceModelResult = Database.DeviceModels.GetOrCreateDeviceModel(Request.DeviceManufacturer.Trim(), Request.DeviceModel.Trim(), Request.DeviceModel.Trim());
                     DeviceModel deviceModel = deviceModelResult.Item1;
                     if (deviceModelResult.Item2)
                         EnrolmentLog.LogSessionTaskCreatedDeviceModel(sessionId, Request.DeviceSerialNumber, deviceModelResult.Item1.Manufacturer, deviceModelResult.Item1.Model);
@@ -394,16 +408,22 @@ namespace Disco.BI.DeviceBI
                         AllowUnauthenticatedEnrol = false,
                         CreatedDate = DateTime.Now,
                         EnrolledDate = DateTime.Now,
-                        LastEnrolDate = DateTime.Now
+                        LastEnrolDate = DateTime.Now,
+                        DeviceDetails = new List<DeviceDetail>()
                     };
-                    dbContext.Devices.Add(RepoDevice);
+                    Database.Devices.Add(RepoDevice);
+
+                    if (!string.IsNullOrEmpty(Request.DeviceLanMacAddress))
+                        RepoDevice.DeviceDetails.LanMacAddress(RepoDevice, Request.DeviceLanMacAddress);
+                    if (!string.IsNullOrEmpty(Request.DeviceWlanMacAddress))
+                        RepoDevice.DeviceDetails.WLanMacAddress(RepoDevice, Request.DeviceWlanMacAddress);
                 }
                 else
                 {
                     EnrolmentLog.LogSessionProgress(sessionId, 30, "Existing Device, Updating Disco Instance");
                     EnrolmentLog.LogSessionTaskUpdatingDevice(sessionId, Request.DeviceSerialNumber);
 
-                    var deviceModelResult = dbContext.DeviceModels.GetOrCreateDeviceModel(Request.DeviceManufacturer.Trim(), Request.DeviceModel.Trim(), Request.DeviceModel.Trim());
+                    var deviceModelResult = Database.DeviceModels.GetOrCreateDeviceModel(Request.DeviceManufacturer.Trim(), Request.DeviceModel.Trim(), Request.DeviceModel.Trim());
                     DeviceModel deviceModel = deviceModelResult.Item1;
                     if (deviceModelResult.Item2)
                         EnrolmentLog.LogSessionTaskCreatedDeviceModel(sessionId, Request.DeviceSerialNumber, deviceModelResult.Item1.Manufacturer, deviceModelResult.Item1.Model);
@@ -412,6 +432,11 @@ namespace Disco.BI.DeviceBI
 
                     RepoDevice.DeviceModel = deviceModel;
 
+                    if (!string.IsNullOrEmpty(Request.DeviceLanMacAddress))
+                        RepoDevice.DeviceDetails.LanMacAddress(RepoDevice, Request.DeviceLanMacAddress);
+                    if (!string.IsNullOrEmpty(Request.DeviceWlanMacAddress))
+                        RepoDevice.DeviceDetails.WLanMacAddress(RepoDevice, Request.DeviceWlanMacAddress);
+
                     if (!RepoDevice.EnrolledDate.HasValue)
                         RepoDevice.EnrolledDate = DateTime.Now;
                     RepoDevice.LastEnrolDate = DateTime.Now;
@@ -425,7 +450,7 @@ namespace Disco.BI.DeviceBI
                         {
                             EnrolmentLog.LogSessionProgress(sessionId, 50, "Provisioning an Active Directory Computer Account");
                             if (string.IsNullOrEmpty(RepoDevice.ComputerName) || RepoDevice.DeviceProfile.EnforceComputerNameConvention)
-                                RepoDevice.ComputerName = RepoDevice.ComputerNameRender(dbContext);
+                                RepoDevice.ComputerName = RepoDevice.ComputerNameRender(Database);
                             EnrolmentLog.LogSessionTaskProvisioningADAccount(sessionId, RepoDevice.SerialNumber, RepoDevice.ComputerName);
                             MachineInfo = ActiveDirectory.GetMachineAccount(RepoDevice.ComputerName);
                             response.OfflineDomainJoin = ActiveDirectory.OfflineDomainJoinProvision(ref MachineInfo, RepoDevice.ComputerName, RepoDevice.DeviceProfile.OrganisationalUnit, sessionId);
@@ -456,9 +481,9 @@ namespace Disco.BI.DeviceBI
                     response.DeviceDomainName = MachineInfo.Domain;
 
                     // Enforce Computer Name Convention
-                    if (RepoDevice.DeviceProfile.EnforceComputerNameConvention)
+                    if (!MachineInfo.IsCriticalSystemObject && RepoDevice.DeviceProfile.EnforceComputerNameConvention)
                     {
-                        var calculatedComputerName = RepoDevice.ComputerNameRender(dbContext);
+                        var calculatedComputerName = RepoDevice.ComputerNameRender(Database);
                         if (!Request.DeviceComputerName.Equals(calculatedComputerName, StringComparison.InvariantCultureIgnoreCase))
                         {
                             EnrolmentLog.LogSessionProgress(sessionId, 50, string.Format("Renaming Device: {0} -> {1}", Request.DeviceComputerName, calculatedComputerName));
@@ -474,23 +499,26 @@ namespace Disco.BI.DeviceBI
                     }
 
                     // Enforce Organisation Unit
-                    if (response.OfflineDomainJoin == null && RepoDevice.DeviceProfile.EnforceOrganisationalUnit)
+                    if (!MachineInfo.IsCriticalSystemObject && response.OfflineDomainJoin == null && RepoDevice.DeviceProfile.EnforceOrganisationalUnit)
                     {
-                        if ((RepoDevice.DeviceProfile.OrganisationalUnit == null && MachineInfo.ParentDistinguishedName.Equals("CN=Computers", StringComparison.InvariantCultureIgnoreCase)) // Null (Default) OU
-                            || !MachineInfo.ParentDistinguishedName.Equals(RepoDevice.DeviceProfile.OrganisationalUnit, StringComparison.InvariantCultureIgnoreCase)) // Custom OU
+                        var parentDistinguishedName = MachineInfo.ParentDistinguishedName();
+
+                        if ((RepoDevice.DeviceProfile.OrganisationalUnit == null && parentDistinguishedName != null
+                            && parentDistinguishedName.Equals("CN=Computers", StringComparison.InvariantCultureIgnoreCase)) // Null (Default) OU
+                            || !parentDistinguishedName.Equals(RepoDevice.DeviceProfile.OrganisationalUnit, StringComparison.InvariantCultureIgnoreCase)) // Custom OU
                         {
                             string newOU = RepoDevice.DeviceProfile.OrganisationalUnit ?? "CN=Computers";
 
-                            EnrolmentLog.LogSessionProgress(sessionId, 65, string.Format("Moving Device Organisation Unit: {0} -> {1}", MachineInfo.ParentDistinguishedName, newOU));
-                            EnrolmentLog.LogSessionTaskMovingDeviceOrganisationUnit(sessionId, MachineInfo.ParentDistinguishedName, newOU);
+                            EnrolmentLog.LogSessionProgress(sessionId, 65, string.Format("Moving Device Organisation Unit: {0} -> {1}", parentDistinguishedName, newOU));
+                            EnrolmentLog.LogSessionTaskMovingDeviceOrganisationUnit(sessionId, parentDistinguishedName, newOU);
                             MachineInfo.MoveOrganisationUnit(RepoDevice.DeviceProfile.OrganisationalUnit);
-                            MachineInfo = ActiveDirectory.GetMachineAccount(MachineInfo.sAMAccountName);
+                            MachineInfo = ActiveDirectory.GetMachineAccount(MachineInfo.SamAccountName);
                             response.RequireReboot = true;
                         }
                     }
 
                 }
-                if (MachineInfo != null)
+                if (MachineInfo != null && !MachineInfo.IsCriticalSystemObject)
                 {
                     EnrolmentLog.LogSessionProgress(sessionId, 75, "Updating Active Directory Computer Account Properties");
                     MachineInfo.UpdateNetbootGUID(Request.DeviceUUID, Request.DeviceLanMacAddress);
@@ -507,12 +535,13 @@ namespace Disco.BI.DeviceBI
                     {
                         EnrolmentLog.LogSessionProgress(sessionId, 80, "Retrieving Active Directory Assigned User Account");
                         ActiveDirectoryUserAccount AssignedUserInfo = ActiveDirectory.GetUserAccount(RepoDevice.AssignedUser.Id);
-                        EnrolmentLog.LogSessionTaskAssigningUser(sessionId, RepoDevice.SerialNumber, AssignedUserInfo.DisplayName, AssignedUserInfo.sAMAccountName, AssignedUserInfo.Domain, AssignedUserInfo.ObjectSid);
+                        EnrolmentLog.LogSessionTaskAssigningUser(sessionId, RepoDevice.SerialNumber, AssignedUserInfo.DisplayName, AssignedUserInfo.SamAccountName, AssignedUserInfo.Domain, AssignedUserInfo.SecurityIdentifier);
                         response.AllowBootstrapperUninstall = true;
-                        response.DeviceAssignedUserUsername = AssignedUserInfo.sAMAccountName;
+                        response.DeviceAssignedUserIsLocalAdmin = RepoDevice.DeviceProfile.AssignedUserLocalAdmin;
+                        response.DeviceAssignedUserUsername = AssignedUserInfo.SamAccountName;
                         response.DeviceAssignedUserDomain = AssignedUserInfo.Domain;
                         response.DeviceAssignedUserName = AssignedUserInfo.DisplayName;
-                        response.DeviceAssignedUserSID = AssignedUserInfo.ObjectSid;
+                        response.DeviceAssignedUserSID = AssignedUserInfo.SecurityIdentifier;
                     }
                 }
                 else
@@ -523,7 +552,7 @@ namespace Disco.BI.DeviceBI
                 {
                     EnrolmentLog.LogSessionProgress(sessionId, 90, "Provisioning a Wireless Certificate");
 
-                    var allocationResult = RepoDevice.AllocateCertificate(dbContext);
+                    var allocationResult = RepoDevice.AllocateCertificate(Database);
                     var deviceCertificate = allocationResult.Item1;
                     if (deviceCertificate != null)
                     {

Disco.BI/BI/DeviceBI/Importing/Import.cs

@@ -2,6 +2,7 @@
 using Disco.Data.Repository;
 using Disco.Models.BI.Device;
 using Disco.Models.Repository;
+using Disco.Services.Users;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -24,13 +25,13 @@ namespace Disco.BI.DeviceBI.Importing
             return (ImportDeviceSession)HttpRuntime.Cache.Get(parseKey);
         }
 
-        internal static bool ImportRecord(this ImportDevice device, DiscoDataContext dbContext, PopulateRecordReferences references)
+        internal static bool ImportRecord(this ImportDevice device, DiscoDataContext Database, PopulateRecordReferences references)
         {
             // Skips If Errors
             if (device.Errors == null || device.Errors.Count == 0)
             {
                 // Re-Populate & Skip If Errors
-                device.PopulateRecord(dbContext, references);
+                device.PopulateRecord(Database, references);
                 if (device.Errors == null || device.Errors.Count == 0)
                 {
                     Device discoDevice = device.Device;
@@ -44,7 +45,7 @@ namespace Disco.BI.DeviceBI.Importing
                             CreatedDate = DateTime.Now,
                             AllowUnauthenticatedEnrol = true,
                         };
-                        dbContext.Devices.Add(discoDevice);
+                        Database.Devices.Add(discoDevice);
                     }
 
                     if (discoDevice.DeviceModelId != device.DeviceModelId)
@@ -60,10 +61,10 @@ namespace Disco.BI.DeviceBI.Importing
 
                     if (discoDevice.AssignedUserId != device.AssignedUserId)
                     {
-                        discoDevice.AssignDevice(dbContext, device.AssignedUser);
+                        discoDevice.AssignDevice(Database, device.AssignedUser);
                     }
 
-                    dbContext.SaveChanges();
+                    Database.SaveChanges();
 
                     return true;
                 }
@@ -71,16 +72,16 @@ namespace Disco.BI.DeviceBI.Importing
             return false;
         }
 
-        internal static PopulateRecordReferences GetPopulateRecordReferences(DiscoDataContext dbContext)
+        internal static PopulateRecordReferences GetPopulateRecordReferences(DiscoDataContext Database)
         {
             return new PopulateRecordReferences(
-                dbContext.DeviceModels.ToDictionary(dm => dm.Id),
-                dbContext.DeviceProfiles.ToDictionary(dp => dp.Id),
-                dbContext.DeviceBatches.ToDictionary(db => db.Id)
+                Database.DeviceModels.ToDictionary(dm => dm.Id),
+                Database.DeviceProfiles.ToDictionary(dp => dp.Id),
+                Database.DeviceBatches.ToDictionary(db => db.Id)
                 );
         }
 
-        internal static void PopulateRecord(this ImportDevice device, DiscoDataContext dbContext, PopulateRecordReferences references)
+        internal static void PopulateRecord(this ImportDevice device, DiscoDataContext Database, PopulateRecordReferences references)
         {
 
             var deviceModels = references.Item1;
@@ -90,7 +91,7 @@ namespace Disco.BI.DeviceBI.Importing
             // SERIAL NUMBER - Existing Device
             if (!device.Errors.ContainsKey("SerialNumber"))
             {
-                device.Device = dbContext.Devices.Find(device.SerialNumber);
+                device.Device = Database.Devices.Find(device.SerialNumber);
                 if (device.Device != null && device.Device.DecommissionedDate.HasValue)
                     device.Errors.Add("SerialNumber", "The device is decommissioned");
             }
@@ -135,7 +136,7 @@ namespace Disco.BI.DeviceBI.Importing
             {
                 try
                 {
-                    device.AssignedUser = UserBI.UserCache.GetUser(device.AssignedUserId, dbContext, true);
+                    device.AssignedUser = UserService.GetUser(device.AssignedUserId, Database, true);
                 }
                 catch (ArgumentException)
                 {

Disco.BI/BI/DeviceBI/Importing/ImportParseTask.cs

@@ -45,14 +45,14 @@ namespace Disco.BI.DeviceBI.Importing
 
             this.Status.UpdateStatus(20, "Parsing CSV File", string.Format("Linking {0} Records", records.Count));
 
-            using (DiscoDataContext dbContext = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
-                var populateReferences = Import.GetPopulateRecordReferences(dbContext);
+                var populateReferences = Import.GetPopulateRecordReferences(database);
 
                 DateTime lastUpdate = DateTime.Now;
                 foreach (var record in records)
                 {
-                    record.PopulateRecord(dbContext, populateReferences);
+                    record.PopulateRecord(database, populateReferences);
 
                     if (DateTime.Now.Subtract(lastUpdate).TotalSeconds > 1)
                     {

Disco.BI/BI/DeviceBI/Importing/ImportProcessTask.cs

@@ -35,14 +35,14 @@ namespace Disco.BI.DeviceBI.Importing
 
             this.Status.UpdateStatus(0, "Processing Device Import", "Importing Devices");
 
-            using (DiscoDataContext dbContext = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
-                var populateReferences = Import.GetPopulateRecordReferences(dbContext);
+                var populateReferences = Import.GetPopulateRecordReferences(database);
 
                 DateTime lastUpdate = DateTime.Now;
                 foreach (var record in records)
                 {
-                    if (record.ImportRecord(dbContext, populateReferences))
+                    if (record.ImportRecord(database, populateReferences))
                         recordsImported++;
 
                     if (DateTime.Now.Subtract(lastUpdate).TotalSeconds > 1)

Disco.BI/BI/DeviceBI/Migration/LogMacAddressImporting.cs

@@ -0,0 +1,123 @@
+using Disco.BI.Extensions;
+using Disco.Data.Repository;
+using Disco.Services.Logging;
+using Disco.Services.Tasks;
+using Quartz;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Disco.BI.DeviceBI.Migration
+{
+    public class LogMacAddressImporting : ScheduledTask
+    {
+        public override string TaskName { get { return "Migration: Logs to Device Mac Address Details"; } }
+
+        public override bool SingleInstanceTask { get { return true; } }
+        public override bool CancelInitiallySupported { get { return false; } }
+
+        #region Required Helpers
+        private static string RequiredFilePath(DiscoDataContext Database)
+        {
+            if (Database.DiscoConfiguration.DataStoreLocation != null)
+                return System.IO.Path.Combine(Database.DiscoConfiguration.DataStoreLocation, "_LogMacAddressImportingRequired.txt");
+            else
+                return null;
+        }
+
+        public static bool IsRequired(DiscoDataContext Database)
+        {
+            var requiredFilePath = RequiredFilePath(Database);
+
+            if (requiredFilePath == null)
+                return false;
+            else
+                return System.IO.File.Exists(requiredFilePath);
+        }
+        public static void SetRequired(DiscoDataContext Database)
+        {
+            var requiredFilePath = RequiredFilePath(Database);
+
+            if (requiredFilePath != null)
+            {
+                System.IO.File.WriteAllText(requiredFilePath, "This file exists to indicate an Importing of Mac Address from the Disco Logs is required. It will automatically be deleted when the import completes.");
+                System.IO.File.SetAttributes(requiredFilePath, System.IO.FileAttributes.Hidden);
+            }
+            // ELSE: Could never be required if no DataStoreLocation is set (no logs to process)
+        }
+        #endregion
+
+        public override void InitalizeScheduledTask(DiscoDataContext Database)
+        {
+            if (IsRequired(Database))
+            {
+                // Schedule in 15mins
+                var trigger = TriggerBuilder.Create()
+                    .StartAt(DateTimeOffset.Now.AddMinutes(5));
+
+                this.ScheduleTask(trigger);
+            }
+        }
+
+        public static ScheduledTaskStatus ScheduleImmediately()
+        {
+            var existingTask = ScheduledTasks.GetTaskStatuses(typeof(LogMacAddressImporting)).Where(s => s.IsRunning).FirstOrDefault();
+            if (existingTask != null)
+                return existingTask;
+
+            var instance = new LogMacAddressImporting();
+            return instance.ScheduleTask();
+        }
+
+        protected override void ExecuteTask()
+        {
+            using (DiscoDataContext database = new DiscoDataContext())
+            {
+                Status.UpdateStatus(0, "Importing MAC Addresses", "Querying Logs for Details");
+                // Load Logs
+                var logRetriever = new ReadLogContext()
+                {
+                    Module = DeviceBI.EnrolmentLog.Current.ModuleId,
+                    EventTypes = new List<int>() { (int)DeviceBI.EnrolmentLog.EventTypeIds.SessionDeviceInfo }
+                };
+                var results = logRetriever.Query(database);
+
+                Status.UpdateStatus(50, string.Format("Passing {0} logs", results.Count));
+
+                Dictionary<string, Tuple<string, string>> addresses = new Dictionary<string, Tuple<string, string>>();
+
+                foreach (var result in results.OrderBy(r => r.Timestamp))
+                    addresses[((string)result.Arguments[1]).ToLower()] = new Tuple<string, string>((string)result.Arguments[4], (string)result.Arguments[5]);
+
+                Status.UpdateStatus(75, string.Format("Importing {0} details", addresses.Count));
+
+                var devices = database.Devices.Include("DeviceDetails").ToList();
+
+                Tuple<string, string> addressResult;
+                foreach (var device in devices)
+                {
+                    if (addresses.TryGetValue(device.SerialNumber.ToLower(), out addressResult))
+                    {
+                        if (!string.IsNullOrEmpty(addressResult.Item1))
+                            device.DeviceDetails.LanMacAddress(device, addressResult.Item1);
+                        if (!string.IsNullOrEmpty(addressResult.Item2))
+                            device.DeviceDetails.WLanMacAddress(device, addressResult.Item2);
+                    }
+                }
+
+                Status.UpdateStatus(90, "Saving to Database");
+
+                database.SaveChanges();
+
+                // Finished - Remove Placeholder File
+                var requiredFilePath = RequiredFilePath(database);
+                if (System.IO.File.Exists(requiredFilePath))
+                    System.IO.File.Delete(requiredFilePath);
+            }
+        }
+
+
+    }
+}

Disco.BI/BI/DeviceBI/Searching.cs

@@ -10,7 +10,8 @@ namespace Disco.BI.DeviceBI
 {
     public static class Searching
     {
-        private static List<DeviceSearchResultItem> Search_SelectDeviceSearchResultItem(IQueryable<Device> Query, int? LimitCount = null){
+        private static List<DeviceSearchResultItem> Search_SelectDeviceSearchResultItem(IQueryable<Device> Query, int? LimitCount = null)
+        {
             if (LimitCount.HasValue)
                 Query = Query.Take(LimitCount.Value);
 
@@ -28,28 +29,47 @@ namespace Disco.BI.DeviceBI
             }).ToList();
         }
 
-        public static List<DeviceSearchResultItem> Search(DiscoDataContext dbContext, string Term, int? LimitCount = null)
+        public static List<DeviceSearchResultItem> Search(DiscoDataContext Database, string Term, int? LimitCount = null, bool SearchDetails = false)
         {
-            return Search_SelectDeviceSearchResultItem(dbContext.Devices.Where(d =>
-                d.AssetNumber.Contains(Term) ||
-                d.ComputerName.Contains(Term) ||
-                d.SerialNumber.Contains(Term) ||
-                d.Location.Contains(Term) ||
-                Term.Contains(d.SerialNumber)
-                ), LimitCount);
+            IQueryable<Device> query;
+
+            query = null;
+
+            if (SearchDetails)
+            {
+                query = Database.Devices.Where(d =>
+                    d.AssetNumber.Contains(Term) ||
+                    d.ComputerName.Contains(Term) ||
+                    d.SerialNumber.Contains(Term) ||
+                    d.Location.Contains(Term) ||
+                    Term.Contains(d.SerialNumber) ||
+                    d.DeviceDetails.Any(dd => dd.Value.Contains(Term))
+                    );
+            }
+            else
+            {
+                query = Database.Devices.Where(d =>
+                    d.AssetNumber.Contains(Term) ||
+                    d.ComputerName.Contains(Term) ||
+                    d.SerialNumber.Contains(Term) ||
+                    d.Location.Contains(Term) ||
+                    Term.Contains(d.SerialNumber));
+            }
+            
+            return Search_SelectDeviceSearchResultItem(query, LimitCount);
         }
 
-        public static List<DeviceSearchResultItem> SearchDeviceModel(DiscoDataContext dbContext, int DeviceModelId, int? LimitCount = null)
+        public static List<DeviceSearchResultItem> SearchDeviceModel(DiscoDataContext Database, int DeviceModelId, int? LimitCount = null)
         {
-            return Search_SelectDeviceSearchResultItem(dbContext.Devices.Where(d => d.DeviceModelId == DeviceModelId), LimitCount);
+            return Search_SelectDeviceSearchResultItem(Database.Devices.Where(d => d.DeviceModelId == DeviceModelId), LimitCount);
         }
-        public static List<DeviceSearchResultItem> SearchDeviceProfile(DiscoDataContext dbContext, int DeviceProfileId, int? LimitCount = null)
+        public static List<DeviceSearchResultItem> SearchDeviceProfile(DiscoDataContext Database, int DeviceProfileId, int? LimitCount = null)
         {
-            return Search_SelectDeviceSearchResultItem(dbContext.Devices.Where(d => d.DeviceProfileId == DeviceProfileId), LimitCount);
+            return Search_SelectDeviceSearchResultItem(Database.Devices.Where(d => d.DeviceProfileId == DeviceProfileId), LimitCount);
         }
-        public static List<DeviceSearchResultItem> SearchDeviceBatch(DiscoDataContext dbContext, int DeviceBatchId, int? LimitCount = null)
+        public static List<DeviceSearchResultItem> SearchDeviceBatch(DiscoDataContext Database, int DeviceBatchId, int? LimitCount = null)
         {
-            return Search_SelectDeviceSearchResultItem(dbContext.Devices.Where(d => d.DeviceBatchId == DeviceBatchId), LimitCount);
+            return Search_SelectDeviceSearchResultItem(Database.Devices.Where(d => d.DeviceBatchId == DeviceBatchId), LimitCount);
         }
 
     }

Disco.BI/BI/DocumentTemplateBI/DocumentTemplateQRCodeLocationCache.cs

@@ -16,7 +16,7 @@ namespace Disco.BI.DocumentTemplateBI
     {
         private static ConcurrentDictionary<string, List<RectangleF>> _Cache = new ConcurrentDictionary<string, List<RectangleF>>();
 
-        public static List<RectangleF> GetLocations(DocumentTemplate dt, DiscoDataContext dbContext)
+        public static List<RectangleF> GetLocations(DocumentTemplate dt, DiscoDataContext Database)
         {
             // Check Cache
             List<RectangleF> locations;
@@ -25,7 +25,7 @@ namespace Disco.BI.DocumentTemplateBI
                 return locations;
             }
             // Generate Cache
-            return GenerateLocations(dt, dbContext);
+            return GenerateLocations(dt, Database);
         }
 
         public static bool InvalidateLocations(DocumentTemplate dt)
@@ -47,9 +47,9 @@ namespace Disco.BI.DocumentTemplateBI
             return _Cache.TryAdd(DocumentTemplateId, Locations);
         }
 
-        internal static List<RectangleF> GenerateLocations(DocumentTemplate dt, DiscoDataContext dbContext)
+        internal static List<RectangleF> GenerateLocations(DocumentTemplate dt, DiscoDataContext Database)
         {
-            string templateFilename = dt.RepositoryFilename(dbContext);
+            string templateFilename = dt.RepositoryFilename(Database);
             PdfReader pdfReader = new PdfReader(templateFilename);
             List<RectangleF> locations = new List<RectangleF>();
 

Disco.BI/BI/DocumentTemplateBI/DocumentUniqueIdentifier.cs

@@ -115,7 +115,7 @@ namespace Disco.BI.DocumentTemplateBI
             }
             throw new System.ArgumentException(string.Format("Invalid Document Unique Identifier Version ({0})", s[1]), "UniqueIdentifier");
         }
-        public bool LoadComponents(DiscoDataContext Context)
+        public bool LoadComponents(DiscoDataContext Database)
         {
             bool LoadComponents;
             if (!this._loadedComponentsOk.HasValue)
@@ -142,7 +142,7 @@ namespace Disco.BI.DocumentTemplateBI
                 }
                 else
                 {
-                    this._documentTemplate = Context.DocumentTemplates.Find(this.TemplateTypeId);
+                    this._documentTemplate = Database.DocumentTemplates.Find(this.TemplateTypeId);
                     if (this._documentTemplate != null)
                     {
                         scopeType = this._documentTemplate.Scope;
@@ -158,7 +158,7 @@ namespace Disco.BI.DocumentTemplateBI
                     switch (scopeType)
                     {
                         case DocumentTemplate.DocumentTemplateScopes.Device:
-                            Device d = Context.Devices.Find(this.DataId);
+                            Device d = Database.Devices.Find(this.DataId);
                             if (d != null)
                             {
                                 this._data = d;
@@ -169,7 +169,7 @@ namespace Disco.BI.DocumentTemplateBI
                             }
                             break;
                         case DocumentTemplate.DocumentTemplateScopes.Job:
-                            Job i = Context.Jobs.Find(int.Parse(this.DataId));
+                            Job i = Database.Jobs.Find(int.Parse(this.DataId));
                             if (i != null)
                             {
                                 this._data = i;
@@ -180,7 +180,7 @@ namespace Disco.BI.DocumentTemplateBI
                             }
                             break;
                         case DocumentTemplate.DocumentTemplateScopes.User:
-                            User u = Context.Users.Find(this.DataId);
+                            User u = Database.Users.Find(this.DataId);
                             if (u != null)
                             {
                                 this._data = u;

Disco.BI/BI/DocumentTemplateBI/Importer/DocumentDropBoxMonitor.cs

@@ -16,15 +16,15 @@ namespace Disco.BI.DocumentTemplateBI.Importer
 
         public const string WatcherFilter = "*.pdf";
         public string DropBoxLocation { get; private set; }
-     
-        public DocumentDropBoxMonitor(DiscoDataContext Context, ISchedulerFactory SchedulerFactory, Cache HttpCache)
+
+        public DocumentDropBoxMonitor(DiscoDataContext Database, ISchedulerFactory SchedulerFactory, Cache HttpCache)
         {
-            if (Context == null)
+            if (Database == null)
                 throw new System.ArgumentNullException("Context");
             
             this._httpCache = HttpCache;
 
-            var location = DataStore.CreateLocation(Context, "DocumentDropBox");
+            var location = DataStore.CreateLocation(Database, "DocumentDropBox");
             this.DropBoxLocation = location.EndsWith(@"\") ? location : string.Concat(location, @"\");
             
             this._scheduler = SchedulerFactory.GetScheduler();

Disco.BI/BI/DocumentTemplateBI/Importer/DocumentImporterCleanCacheJob.cs

@@ -13,7 +13,7 @@ namespace Disco.BI.DocumentTemplateBI.Importer
         public override bool SingleInstanceTask { get { return true; } }
         public override bool CancelInitiallySupported { get { return false; } }
 
-        public override void InitalizeScheduledTask(DiscoDataContext dbContext)
+        public override void InitalizeScheduledTask(DiscoDataContext Database)
         {
             // Trigger Daily @ 12:30am
             TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithSchedule(CronScheduleBuilder.DailyAtHourAndMinute(0, 30));
@@ -24,9 +24,9 @@ namespace Disco.BI.DocumentTemplateBI.Importer
         protected override void ExecuteTask()
         {
             string dataStoreLocation;
-            using (DiscoDataContext dbContext = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
-                dataStoreLocation = DataStore.CreateLocation(dbContext, "Cache\\DocumentDropBox_SessionPages");
+                dataStoreLocation = DataStore.CreateLocation(database, "Cache\\DocumentDropBox_SessionPages");
             }
 
             int deleteCount = 0;

Disco.BI/BI/DocumentTemplateBI/Importer/DocumentImporterJob.cs

@@ -40,12 +40,12 @@ namespace Disco.BI.DocumentTemplateBI.Importer
 
             try
             {
-                using (DiscoDataContext dbContext = new DiscoDataContext())
+                using (DiscoDataContext database = new DiscoDataContext())
                 {
                     if (retryCount < 18)
                     {
                         context.JobDetail.JobDataMap["RetryCount"] = (++retryCount);
-                        bool processResult = Interop.Pdf.PdfImporter.ProcessPdfAttachment(filename, dbContext, sessionId, httpCache);
+                        bool processResult = Interop.Pdf.PdfImporter.ProcessPdfAttachment(filename, database, sessionId, httpCache);
 
                         if (processResult)
                         {
@@ -60,7 +60,7 @@ namespace Disco.BI.DocumentTemplateBI.Importer
                             {
                                 try
                                 {
-                                    string folderError = DataStore.CreateLocation(dbContext, "DocumentDropBox_Errors");
+                                    string folderError = DataStore.CreateLocation(database, "DocumentDropBox_Errors");
                                     string filenameError = Path.Combine(folderError, Path.GetFileName(filename));
                                     int filenameErrorCount = 0;
                                     while (File.Exists(filenameError))
@@ -85,7 +85,7 @@ namespace Disco.BI.DocumentTemplateBI.Importer
                         {
                             try
                             {
-                                string folderError = DataStore.CreateLocation(dbContext, "DocumentDropBox_Errors");
+                                string folderError = DataStore.CreateLocation(database, "DocumentDropBox_Errors");
                                 string filenameError = Path.Combine(folderError, Path.GetFileName(filename));
                                 int filenameErrorCount = 0;
                                 while (File.Exists(filenameError))

Disco.BI/BI/Expressions/Expression.cs

@@ -167,14 +167,14 @@ namespace Disco.BI.Expressions
             return e;
         }
 
-        public static IDictionary StandardVariables(DocumentTemplate AttachmentType, DiscoDataContext DataContext, User User, System.DateTime TimeStamp, DocumentState DocumentState)
+        public static IDictionary StandardVariables(DocumentTemplate AttachmentType, DiscoDataContext Database, User User, System.DateTime TimeStamp, DocumentState DocumentState)
         {
             return new Hashtable
 			{
 
 				{
 					"DataContext", 
-					DataContext
+					Database
 				}, 
 
 				{

Disco.BI/BI/Expressions/ExpressionCachePreloadTask.cs

@@ -17,7 +17,7 @@ namespace Disco.BI.Expressions
         public override bool SingleInstanceTask { get { return true; } }
         public override bool CancelInitiallySupported { get { return false; } }
 
-        public override void InitalizeScheduledTask(DiscoDataContext dbContext)
+        public override void InitalizeScheduledTask(DiscoDataContext Database)
         {
             // Run in Background 1 Second after Scheduled (on App Startup)
             TriggerBuilder triggerBuilder = TriggerBuilder.Create().StartAt(new DateTimeOffset(DateTime.Now).AddSeconds(5));
@@ -28,9 +28,9 @@ namespace Disco.BI.Expressions
         protected override void ExecuteTask()
         {
             // Cache Document Template Filter Expressions
-            using (DiscoDataContext dbContext = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
-                foreach (var documentTemplate in dbContext.DocumentTemplates.Where(dt => dt.FilterExpression != null && dt.FilterExpression != string.Empty))
+                foreach (var documentTemplate in database.DocumentTemplates.Where(dt => dt.FilterExpression != null && dt.FilterExpression != string.Empty))
                 {
                     if (!string.IsNullOrWhiteSpace(documentTemplate.FilterExpression))
                         documentTemplate.FilterExpressionFromCache();

Disco.BI/BI/Expressions/Extensions/ImageExt.cs

@@ -26,39 +26,39 @@ namespace Disco.BI.Expressions.Extensions
             string AbsoluteFilePath = System.IO.Path.Combine(DataStoreLocation, RelativeFilePath);
             return new FileImageExpressionResult(AbsoluteFilePath);
         }
-        public static FileImageExpressionResult JobAttachmentFirstImage(Job Job, DiscoDataContext dbContext)
+        public static FileImageExpressionResult JobAttachmentFirstImage(Job Job, DiscoDataContext Database)
         {
             var attachment = Job.JobAttachments.FirstOrDefault(ja => ja.MimeType.StartsWith("image/", StringComparison.InvariantCultureIgnoreCase));
             if (attachment != null)
             {
-                var filename = attachment.RepositoryFilename(dbContext);
+                var filename = attachment.RepositoryFilename(Database);
                 return new FileImageExpressionResult(filename);
             }
             else
                 return null;
         }
-        public static FileImageExpressionResult JobAttachmentLastImage(Job Job, DiscoDataContext dbContext)
+        public static FileImageExpressionResult JobAttachmentLastImage(Job Job, DiscoDataContext Database)
         {
             var attachment = Job.JobAttachments.LastOrDefault(ja => ja.MimeType.StartsWith("image/", StringComparison.InvariantCultureIgnoreCase));
             if (attachment != null)
             {
-                var filename = attachment.RepositoryFilename(dbContext);
+                var filename = attachment.RepositoryFilename(Database);
                 return new FileImageExpressionResult(filename);
             }
             else
                 return null;
         }
-        public static FileImageExpressionResult JobAttachmentImage(JobAttachment JobAttachment, DiscoDataContext dbContext)
+        public static FileImageExpressionResult JobAttachmentImage(JobAttachment JobAttachment, DiscoDataContext Database)
         {
             if (JobAttachment == null)
                 throw new ArgumentNullException("JobAttachment");
             if (!JobAttachment.MimeType.StartsWith("image/", StringComparison.InvariantCultureIgnoreCase))
                 throw new ArgumentException("Invalid Image MimeType for Attachment");
 
-            var filename = JobAttachment.RepositoryFilename(dbContext);
+            var filename = JobAttachment.RepositoryFilename(Database);
             return new FileImageExpressionResult(filename);
         }
-        public static FileMontageImageExpressionResult JobAttachmentImageMontage(Job Job, DiscoDataContext dbContext)
+        public static FileMontageImageExpressionResult JobAttachmentImageMontage(Job Job, DiscoDataContext Database)
         {
             if (Job == null)
                 throw new ArgumentNullException("Job");
@@ -69,14 +69,14 @@ namespace Disco.BI.Expressions.Extensions
 
             if (attachments.Count > 0)
             {
-                var attachmentFilepaths = attachments.Select(a => a.RepositoryFilename(dbContext)).ToList();
+                var attachmentFilepaths = attachments.Select(a => a.RepositoryFilename(Database)).ToList();
 
                 return new FileMontageImageExpressionResult(attachmentFilepaths);
             }
             else
                 return null;
         }
-        public static FileMontageImageExpressionResult JobAttachmentsImageMontage(ArrayList JobAttachments, DiscoDataContext dbContext)
+        public static FileMontageImageExpressionResult JobAttachmentsImageMontage(ArrayList JobAttachments, DiscoDataContext Database)
         {
             if (JobAttachments == null)
                 throw new ArgumentNullException("JobAttachments");
@@ -85,7 +85,7 @@ namespace Disco.BI.Expressions.Extensions
 
             if (attachments.Count > 0)
             {
-                var attachmentFilepaths = attachments.Select(a => a.RepositoryFilename(dbContext)).ToList();
+                var attachmentFilepaths = attachments.Select(a => a.RepositoryFilename(Database)).ToList();
 
                 return new FileMontageImageExpressionResult(attachmentFilepaths);
             }

Disco.BI/BI/Extensions/AttachmentActionExtensions.cs

@@ -4,6 +4,8 @@ using System.Linq;
 using System.Text;
 using Disco.Models.Repository;
 using Disco.Data.Repository;
+using Disco.Services.Users;
+using Disco.Services.Authorization;
 
 namespace Disco.BI.Extensions
 {
@@ -13,39 +15,60 @@ namespace Disco.BI.Extensions
         #region Delete
         public static bool CanDelete(this DeviceAttachment da)
         {
-            return true; // Placeholder - Currently Can Always Delete;
+            if (UserService.CurrentAuthorization.Has(Claims.Device.Actions.RemoveAnyAttachments))
+                return true;
+
+            if (UserService.CurrentAuthorization.Has(Claims.Device.Actions.RemoveOwnAttachments)
+                && da.TechUserId == UserService.CurrentUserId)
+                return true;
+
+            return false;
         }
-        public static void OnDelete(this DeviceAttachment da, DiscoDataContext dbContext)
+        public static void OnDelete(this DeviceAttachment da, DiscoDataContext Database)
         {
             if (!da.CanDelete())
                 throw new InvalidOperationException("Deletion of Attachment is Denied");
 
-            da.RepositoryDelete(dbContext);
-            dbContext.DeviceAttachments.Remove(da);
+            da.RepositoryDelete(Database);
+            Database.DeviceAttachments.Remove(da);
         }
         public static bool CanDelete(this JobAttachment ja)
         {
-            return true; // Placeholder - Currently Can Always Delete;
+            if (UserService.CurrentAuthorization.Has(Claims.Job.Actions.RemoveAnyAttachments))
+                return true;
+
+            if (UserService.CurrentAuthorization.Has(Claims.Job.Actions.RemoveOwnAttachments)
+                && ja.TechUserId == UserService.CurrentUserId)
+                return true;
+
+            return false;
         }
-        public static void OnDelete(this JobAttachment ja, DiscoDataContext dbContext)
+        public static void OnDelete(this JobAttachment ja, DiscoDataContext Database)
         {
             if (!ja.CanDelete())
                 throw new InvalidOperationException("Deletion of Attachment is Denied");
 
-            ja.RepositoryDelete(dbContext);
-            dbContext.JobAttachments.Remove(ja);
+            ja.RepositoryDelete(Database);
+            Database.JobAttachments.Remove(ja);
         }
         public static bool CanDelete(this UserAttachment ua)
         {
-            return true; // Placeholder - Currently Can Always Delete;
+            if (UserService.CurrentAuthorization.Has(Claims.User.Actions.RemoveAnyAttachments))
+                return true;
+
+            if (UserService.CurrentAuthorization.Has(Claims.User.Actions.RemoveOwnAttachments)
+                && ua.TechUserId == UserService.CurrentUserId)
+                return true;
+
+            return false;
         }
-        public static void OnDelete(this UserAttachment ua, DiscoDataContext dbContext)
+        public static void OnDelete(this UserAttachment ua, DiscoDataContext Database)
         {
             if (!ua.CanDelete())
                 throw new InvalidOperationException("Deletion of Attachment is Denied");
 
-            ua.RepositoryDelete(dbContext);
-            dbContext.UserAttachments.Remove(ua);
+            ua.RepositoryDelete(Database);
+            Database.UserAttachments.Remove(ua);
         }
         #endregion
 

Disco.BI/BI/Extensions/AttachmentExtensions.cs

@@ -6,16 +6,17 @@ using Disco.Models.Repository;
 using Disco.Data.Repository;
 using System.IO;
 using Disco.BI.DocumentTemplateBI;
+using Disco.Services.Users;
 
 namespace Disco.BI.Extensions
 {
     public static class AttachmentExtensions
     {
 
-        public static bool ImportPdfAttachment(this DocumentUniqueIdentifier UniqueIdentifier, DiscoDataContext dbContext, System.IO.Stream PdfContent, byte[] PdfThumbnail)
+        public static bool ImportPdfAttachment(this DocumentUniqueIdentifier UniqueIdentifier, DiscoDataContext Database, System.IO.Stream PdfContent, byte[] PdfThumbnail)
         {
 
-            UniqueIdentifier.LoadComponents(dbContext);
+            UniqueIdentifier.LoadComponents(Database);
             DocumentTemplate documentTemplate = UniqueIdentifier.DocumentTemplate;
             string filename;
             string comments;
@@ -31,25 +32,25 @@ namespace Disco.BI.Extensions
                 comments = string.Format("Generated: {0:s}", UniqueIdentifier.TimeStamp);
             }
 
-            User creatorUser = UserBI.UserCache.GetUser(UniqueIdentifier.CreatorId, dbContext);
+            User creatorUser = UserService.GetUser(UniqueIdentifier.CreatorId, Database);
             if (creatorUser == null)
             {
                 // No Creator User (or Username invalid)
-                creatorUser = UserBI.UserCache.CurrentUser;
+                creatorUser = UserService.CurrentUser;
             }
             switch (UniqueIdentifier.DataScope)
             {
                 case DocumentTemplate.DocumentTemplateScopes.Device:
                     Device d = (Device)UniqueIdentifier.Data;
-                    d.CreateAttachment(dbContext, creatorUser, filename, DocumentTemplate.PdfMimeType, comments, PdfContent, documentTemplate, PdfThumbnail);
+                    d.CreateAttachment(Database, creatorUser, filename, DocumentTemplate.PdfMimeType, comments, PdfContent, documentTemplate, PdfThumbnail);
                     return true;
                 case DocumentTemplate.DocumentTemplateScopes.Job:
                     Job j = (Job)UniqueIdentifier.Data;
-                    j.CreateAttachment(dbContext, creatorUser, filename, DocumentTemplate.PdfMimeType, comments, PdfContent, documentTemplate, PdfThumbnail);
+                    j.CreateAttachment(Database, creatorUser, filename, DocumentTemplate.PdfMimeType, comments, PdfContent, documentTemplate, PdfThumbnail);
                     return true;
                 case DocumentTemplate.DocumentTemplateScopes.User:
                     User u = (User)UniqueIdentifier.Data;
-                    u.CreateAttachment(dbContext, creatorUser, filename, DocumentTemplate.PdfMimeType, comments, PdfContent, documentTemplate, PdfThumbnail);
+                    u.CreateAttachment(Database, creatorUser, filename, DocumentTemplate.PdfMimeType, comments, PdfContent, documentTemplate, PdfThumbnail);
                     return true;
                 default:
                     return false;
@@ -57,47 +58,47 @@ namespace Disco.BI.Extensions
 
         }
 
-        public static string RepositoryFilename(this DeviceAttachment da, DiscoDataContext dbContext)
+        public static string RepositoryFilename(this DeviceAttachment da, DiscoDataContext Database)
         {
-            return Path.Combine(DataStore.CreateLocation(dbContext, "DeviceAttachments", da.Timestamp), string.Format("{0}_{1}_file", da.DeviceSerialNumber, da.Id));
+            return Path.Combine(DataStore.CreateLocation(Database, "DeviceAttachments", da.Timestamp), string.Format("{0}_{1}_file", da.DeviceSerialNumber, da.Id));
         }
-        public static string RepositoryFilename(this JobAttachment ja, DiscoDataContext dbContext)
+        public static string RepositoryFilename(this JobAttachment ja, DiscoDataContext Database)
         {
-            return Path.Combine(DataStore.CreateLocation(dbContext, "JobAttachments", ja.Timestamp), string.Format("{0}_{1}_file", ja.JobId, ja.Id));
+            return Path.Combine(DataStore.CreateLocation(Database, "JobAttachments", ja.Timestamp), string.Format("{0}_{1}_file", ja.JobId, ja.Id));
         }
-        public static string RepositoryFilename(this UserAttachment ua, DiscoDataContext dbContext)
+        public static string RepositoryFilename(this UserAttachment ua, DiscoDataContext Database)
         {
-            return Path.Combine(DataStore.CreateLocation(dbContext, "UserAttachments", ua.Timestamp), string.Format("{0}_{1}_file", ua.UserId, ua.Id));
+            return Path.Combine(DataStore.CreateLocation(Database, "UserAttachments", ua.Timestamp), string.Format("{0}_{1}_file", ua.UserId, ua.Id));
         }
 
         private static string RepositoryThumbnailFilenameInternal(string DirectoryPath, string Filename)
         {
             return Path.Combine(DirectoryPath, Filename);
         }
-        public static string RepositoryThumbnailFilename(this DeviceAttachment da, DiscoDataContext dbContext)
+        public static string RepositoryThumbnailFilename(this DeviceAttachment da, DiscoDataContext Database)
         {
-            return RepositoryThumbnailFilenameInternal(DataStore.CreateLocation(dbContext, "DeviceAttachments", da.Timestamp), string.Format("{0}_{1}_thumb.jpg", da.DeviceSerialNumber, da.Id));
+            return RepositoryThumbnailFilenameInternal(DataStore.CreateLocation(Database, "DeviceAttachments", da.Timestamp), string.Format("{0}_{1}_thumb.jpg", da.DeviceSerialNumber, da.Id));
         }
-        public static string RepositoryThumbnailFilename(this JobAttachment ja, DiscoDataContext dbContext)
+        public static string RepositoryThumbnailFilename(this JobAttachment ja, DiscoDataContext Database)
         {
-            return RepositoryThumbnailFilenameInternal(DataStore.CreateLocation(dbContext, "JobAttachments", ja.Timestamp), string.Format("{0}_{1}_thumb.jpg", ja.JobId, ja.Id));
+            return RepositoryThumbnailFilenameInternal(DataStore.CreateLocation(Database, "JobAttachments", ja.Timestamp), string.Format("{0}_{1}_thumb.jpg", ja.JobId, ja.Id));
         }
-        public static string RepositoryThumbnailFilename(this UserAttachment ua, DiscoDataContext dbContext)
+        public static string RepositoryThumbnailFilename(this UserAttachment ua, DiscoDataContext Database)
         {
-            return RepositoryThumbnailFilenameInternal(DataStore.CreateLocation(dbContext, "UserAttachments", ua.Timestamp), string.Format("{0}_{1}_thumb.jpg", ua.UserId, ua.Id));
+            return RepositoryThumbnailFilenameInternal(DataStore.CreateLocation(Database, "UserAttachments", ua.Timestamp), string.Format("{0}_{1}_thumb.jpg", ua.UserId, ua.Id));
         }
 
-        public static void RepositoryDelete(this DeviceAttachment da, DiscoDataContext dbContext)
+        public static void RepositoryDelete(this DeviceAttachment da, DiscoDataContext Database)
         {
-            RepositoryDelete(da.RepositoryFilename(dbContext), da.RepositoryThumbnailFilename(dbContext));
+            RepositoryDelete(da.RepositoryFilename(Database), da.RepositoryThumbnailFilename(Database));
         }
-        public static void RepositoryDelete(this JobAttachment ja, DiscoDataContext dbContext)
+        public static void RepositoryDelete(this JobAttachment ja, DiscoDataContext Database)
         {
-            RepositoryDelete(ja.RepositoryFilename(dbContext), ja.RepositoryThumbnailFilename(dbContext));
+            RepositoryDelete(ja.RepositoryFilename(Database), ja.RepositoryThumbnailFilename(Database));
         }
-        public static void RepositoryDelete(this UserAttachment ua, DiscoDataContext dbContext)
+        public static void RepositoryDelete(this UserAttachment ua, DiscoDataContext Database)
         {
-            RepositoryDelete(ua.RepositoryFilename(dbContext), ua.RepositoryThumbnailFilename(dbContext));
+            RepositoryDelete(ua.RepositoryFilename(Database), ua.RepositoryThumbnailFilename(Database));
         }
         private static void RepositoryDelete(params string[] filePaths)
         {
@@ -108,39 +109,39 @@ namespace Disco.BI.Extensions
             }
         }
 
-        public static string SaveAttachment(this DeviceAttachment da, DiscoDataContext dbContext, Stream FileContent)
+        public static string SaveAttachment(this DeviceAttachment da, DiscoDataContext Database, Stream FileContent)
         {
-            string filePath = da.RepositoryFilename(dbContext);
+            string filePath = da.RepositoryFilename(Database);
             SaveAttachment(filePath, FileContent);
             return filePath;
         }
-        public static string SaveAttachment(this JobAttachment ja, DiscoDataContext dbContext, Stream FileContent)
+        public static string SaveAttachment(this JobAttachment ja, DiscoDataContext Database, Stream FileContent)
         {
-            string filePath = ja.RepositoryFilename(dbContext);
+            string filePath = ja.RepositoryFilename(Database);
             SaveAttachment(filePath, FileContent);
             return filePath;
         }
-        public static string SaveAttachment(this UserAttachment ua, DiscoDataContext dbContext, Stream FileContent)
+        public static string SaveAttachment(this UserAttachment ua, DiscoDataContext Database, Stream FileContent)
         {
-            string filePath = ua.RepositoryFilename(dbContext);
+            string filePath = ua.RepositoryFilename(Database);
             SaveAttachment(filePath, FileContent);
             return filePath;
         }
-        public static string SaveThumbnailAttachment(this DeviceAttachment da, DiscoDataContext dbContext, byte[] FileContent)
+        public static string SaveThumbnailAttachment(this DeviceAttachment da, DiscoDataContext Database, byte[] FileContent)
         {
-            string filePath = da.RepositoryThumbnailFilename(dbContext);
+            string filePath = da.RepositoryThumbnailFilename(Database);
             File.WriteAllBytes(filePath, FileContent);
             return filePath;
         }
-        public static string SaveThumbnailAttachment(this JobAttachment ja, DiscoDataContext dbContext, byte[] FileContent)
+        public static string SaveThumbnailAttachment(this JobAttachment ja, DiscoDataContext Database, byte[] FileContent)
         {
-            string filePath = ja.RepositoryThumbnailFilename(dbContext);
+            string filePath = ja.RepositoryThumbnailFilename(Database);
             File.WriteAllBytes(filePath, FileContent);
             return filePath;
         }
-        public static string SaveThumbnailAttachment(this UserAttachment ua, DiscoDataContext dbContext, byte[] FileContent)
+        public static string SaveThumbnailAttachment(this UserAttachment ua, DiscoDataContext Database, byte[] FileContent)
         {
-            string filePath = ua.RepositoryThumbnailFilename(dbContext);
+            string filePath = ua.RepositoryThumbnailFilename(Database);
             File.WriteAllBytes(filePath, FileContent);
             return filePath;
         }
@@ -154,39 +155,39 @@ namespace Disco.BI.Extensions
             }
         }
 
-        public static string GenerateThumbnail(this DeviceAttachment da, DiscoDataContext dbContext)
+        public static string GenerateThumbnail(this DeviceAttachment da, DiscoDataContext Database)
         {
-            string filePath = da.RepositoryThumbnailFilename(dbContext);
-            AttachmentBI.Utilities.GenerateThumbnail(da.RepositoryFilename(dbContext), da.MimeType, filePath);
+            string filePath = da.RepositoryThumbnailFilename(Database);
+            AttachmentBI.Utilities.GenerateThumbnail(da.RepositoryFilename(Database), da.MimeType, filePath);
             return filePath;
         }
-        public static string GenerateThumbnail(this JobAttachment ja, DiscoDataContext dbContext)
+        public static string GenerateThumbnail(this JobAttachment ja, DiscoDataContext Database)
         {
-            string filePath = ja.RepositoryThumbnailFilename(dbContext);
-            AttachmentBI.Utilities.GenerateThumbnail(ja.RepositoryFilename(dbContext), ja.MimeType, filePath);
+            string filePath = ja.RepositoryThumbnailFilename(Database);
+            AttachmentBI.Utilities.GenerateThumbnail(ja.RepositoryFilename(Database), ja.MimeType, filePath);
             return filePath;
         }
-        public static string GenerateThumbnail(this UserAttachment ua, DiscoDataContext dbContext)
+        public static string GenerateThumbnail(this UserAttachment ua, DiscoDataContext Database)
         {
-            string filePath = ua.RepositoryThumbnailFilename(dbContext);
-            AttachmentBI.Utilities.GenerateThumbnail(ua.RepositoryFilename(dbContext), ua.MimeType, filePath);
+            string filePath = ua.RepositoryThumbnailFilename(Database);
+            AttachmentBI.Utilities.GenerateThumbnail(ua.RepositoryFilename(Database), ua.MimeType, filePath);
             return filePath;
         }
-        public static string GenerateThumbnail(this DeviceAttachment da, DiscoDataContext dbContext, Stream SourceFile)
+        public static string GenerateThumbnail(this DeviceAttachment da, DiscoDataContext Database, Stream SourceFile)
         {
-            string filePath = da.RepositoryThumbnailFilename(dbContext);
+            string filePath = da.RepositoryThumbnailFilename(Database);
             AttachmentBI.Utilities.GenerateThumbnail(SourceFile, da.MimeType, filePath);
             return filePath;
         }
-        public static string GenerateThumbnail(this JobAttachment ja, DiscoDataContext dbContext, Stream SourceFile)
+        public static string GenerateThumbnail(this JobAttachment ja, DiscoDataContext Database, Stream SourceFile)
         {
-            string filePath = ja.RepositoryThumbnailFilename(dbContext);
+            string filePath = ja.RepositoryThumbnailFilename(Database);
             AttachmentBI.Utilities.GenerateThumbnail(SourceFile, ja.MimeType, filePath);
             return filePath;
         }
-        public static string GenerateThumbnail(this UserAttachment ua, DiscoDataContext dbContext, Stream SourceFile)
+        public static string GenerateThumbnail(this UserAttachment ua, DiscoDataContext Database, Stream SourceFile)
         {
-            string filePath = ua.RepositoryThumbnailFilename(dbContext);
+            string filePath = ua.RepositoryThumbnailFilename(Database);
             AttachmentBI.Utilities.GenerateThumbnail(SourceFile, ua.MimeType, filePath);
             return filePath;
         }

Disco.BI/BI/Extensions/AuthorizationRoleExtensions.cs

@@ -0,0 +1,28 @@
+using Disco.Data.Repository;
+using Disco.Models.Authorization;
+using Disco.Models.Repository;
+using Disco.Services.Users;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Disco.BI.Extensions
+{
+    public static class AuthorizationRoleExtensions
+    {
+
+        public static void Delete(this IRoleToken roleToken, DiscoDataContext Database)
+        {
+            var role = Database.AuthorizationRoles.Find(roleToken.Role.Id);            
+            UserService.DeleteAuthorizationRole(Database, roleToken.Role);
+        }
+
+        public static void Delete(this AuthorizationRole role, DiscoDataContext Database)
+        {
+            UserService.DeleteAuthorizationRole(Database, role);
+        }
+
+    }
+}

Disco.BI/BI/Extensions/ClientServicesExtensions.cs

@@ -6,6 +6,8 @@ using Disco.Models.ClientServices;
 using System.Web;
 using Disco.Data.Repository;
 using Disco.Models.Repository;
+using Disco.Services.Users;
+using Disco.Services.Authorization;
 
 namespace Disco.BI.Extensions
 {
@@ -20,10 +22,10 @@ namespace Disco.BI.Extensions
             if (HttpContext.Current.Request.IsAuthenticated)
                 username = HttpContext.Current.User.Identity.Name;
 
-            using (DiscoDataContext dbContext = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
-                EnrolResponse response = DeviceBI.DeviceEnrol.Enrol(dbContext, username, request);
-                dbContext.SaveChanges();
+                EnrolResponse response = DeviceBI.DeviceEnrol.Enrol(database, username, request);
+                database.SaveChanges();
                 return response;
             }
         }
@@ -40,14 +42,15 @@ namespace Disco.BI.Extensions
             if (username == null)
                 throw new InvalidOperationException("Unauthenticated Http Context");
 
-            using (DiscoDataContext dbContext = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
-                User user = UserBI.UserCache.GetUser(username, dbContext, true);
+                AuthorizationToken token = UserService.GetAuthorization(username, database, true);
+
                 WhoAmIResponse response = new WhoAmIResponse()
                 {
-                    Username = user.Id,
-                    DisplayName = user.DisplayName,
-                    Type = user.Type
+                    Username = token.User.Id,
+                    DisplayName = token.User.DisplayName,
+                    Type = token.Has(Claims.ComputerAccount) ? "Computer Account" : "User Account"
                 };
                 return response;
             }
@@ -58,10 +61,10 @@ namespace Disco.BI.Extensions
             if (HttpContext.Current == null)
                 throw new PlatformNotSupportedException("This function can only be accessed from within ASP.NET");
 
-            using (DiscoDataContext dbContext = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
-                MacEnrolResponse response = DeviceBI.DeviceEnrol.MacEnrol(dbContext, request, false);
-                dbContext.SaveChanges();
+                MacEnrolResponse response = DeviceBI.DeviceEnrol.MacEnrol(database, request, false);
+                database.SaveChanges();
                 return response;
             }
         }

Disco.BI/BI/Extensions/DeviceActionExtensions.cs

@@ -5,6 +5,8 @@ using System.Text;
 using Disco.Models.Repository;
 using Disco.Data.Repository;
 using Disco.BI.Interop.ActiveDirectory;
+using Disco.Services.Users;
+using Disco.Services.Authorization;
 
 namespace Disco.BI.Extensions
 {
@@ -17,36 +19,57 @@ namespace Disco.BI.Extensions
 
         public static bool CanCreateJob(this Device d)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Actions.Create))
+                return false;
+
             return !d.IsDecommissioned();
         }
 
         public static bool CanUpdateAssignment(this Device d)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Device.Actions.AssignUser))
+                return false;
+
             return !d.IsDecommissioned();
         }
 
         public static bool CanUpdateDeviceProfile(this Device d)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Device.Properties.DeviceProfile))
+                return false;
+
             return !d.IsDecommissioned();
         }
 
         public static bool CanUpdateDeviceBatch(this Device d)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Device.Properties.DeviceBatch))
+                return false;
+
             return !d.IsDecommissioned();
         }
 
         public static bool CanUpdateTrustEnrol(this Device d)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Device.Actions.AllowUnauthenticatedEnrol))
+                return false;
+
             return !d.IsDecommissioned() && !d.AllowUnauthenticatedEnrol;
         }
         public static bool CanUpdateUntrustEnrol(this Device d)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Device.Actions.AllowUnauthenticatedEnrol))
+                return false;
+
             return !d.IsDecommissioned() && d.AllowUnauthenticatedEnrol;
         }
 
         #region Decommission
         public static bool CanDecommission(this Device d)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Device.Actions.Decommission))
+                return false;
+
             if (d.DecommissionedDate.HasValue)
                 return false; // Already Decommissioned
 
@@ -58,18 +81,19 @@ namespace Disco.BI.Extensions
 
             return true;
         }
-        public static void OnDecommission(this Device d)
+        public static void OnDecommission(this Device d, Disco.Models.Repository.Device.DecommissionReasons Reason)
         {
             if (!d.CanDecommission())
                 throw new InvalidOperationException("Decommission of Device is Denied");
 
             d.DecommissionedDate = DateTime.Now;
+            d.DecommissionReason = Reason;
 
             // Disable AD Account
             if (d.ComputerName != null)
             {
                 var adAccount = d.ActiveDirectoryAccount();
-                if (adAccount != null)
+                if (adAccount != null && !adAccount.IsCriticalSystemObject)
                 {
                     adAccount.DisableAccount();
                 }
@@ -79,6 +103,9 @@ namespace Disco.BI.Extensions
         #region Recommission
         public static bool CanRecommission(this Device d)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Device.Actions.Recommission))
+                return false;
+
             return d.DecommissionedDate.HasValue;
         }
         public static void OnRecommission(this Device d)
@@ -87,12 +114,13 @@ namespace Disco.BI.Extensions
                 throw new InvalidOperationException("Recommission of Device is Denied");
 
             d.DecommissionedDate = null;
+            d.DecommissionReason = null;
 
             // Enable AD Account
             if (d.ComputerName != null)
             {
                 var adAccount = d.ActiveDirectoryAccount();
-                if (adAccount != null)
+                if (adAccount != null && !adAccount.IsCriticalSystemObject)
                 {
                     adAccount.EnableAccount();
                 }
@@ -103,17 +131,20 @@ namespace Disco.BI.Extensions
         #region Delete
         public static bool CanDelete(this Device d)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Device.Actions.Delete))
+                return false;
+
             return d.DecommissionedDate.HasValue;
         }
-        public static void OnDelete(this Device d, DiscoDataContext dbContext)
+        public static void OnDelete(this Device d, DiscoDataContext Database)
         {
             // Delete Jobs
-            foreach (Job j in dbContext.Jobs.Where(i => i.DeviceSerialNumber == d.SerialNumber))
+            foreach (Job j in Database.Jobs.Where(i => i.DeviceSerialNumber == d.SerialNumber))
             {
                 if (j.UserId == null)
                 { // No User associated, thus must Delete whole Job
                     if (j.CanDelete())
-                        j.OnDelete(dbContext);
+                        j.OnDelete(Database);
                     else
                         throw new InvalidOperationException(string.Format("Deletion of Device is Denied (See Job# {0})", j.Id));
                 }
@@ -126,35 +157,35 @@ namespace Disco.BI.Extensions
                     JobLog jobLog = new JobLog()
                     {
                         JobId = j.Id,
-                        TechUserId = UserBI.UserCache.CurrentUser.Id,
+                        TechUserId = UserService.CurrentUser.Id,
                         Timestamp = DateTime.Now,
                         Comments = string.Format("Device Deleted{0}{0}Serial Number: {1}{0}Computer Name: {2}{0}Model: {3}{0}Profile: {4}",
                                                     Environment.NewLine, d.SerialNumber, d.ComputerName, d.DeviceModel, d.DeviceProfile)
                     };
-                    dbContext.JobLogs.Add(jobLog);
+                    Database.JobLogs.Add(jobLog);
                 }
             }
 
             // Disable Wireless Certificates
-            foreach (var wc in dbContext.DeviceCertificates.Where(i => i.DeviceSerialNumber == d.SerialNumber))
+            foreach (var wc in Database.DeviceCertificates.Where(i => i.DeviceSerialNumber == d.SerialNumber))
             {
                 wc.DeviceSerialNumber = null;
                 wc.Enabled = false;
             }
             // Delete Device Details
-            foreach (var dd in dbContext.DeviceDetails.Where(i => i.DeviceSerialNumber == d.SerialNumber))
-                dbContext.DeviceDetails.Remove(dd);
+            foreach (var dd in Database.DeviceDetails.Where(i => i.DeviceSerialNumber == d.SerialNumber))
+                Database.DeviceDetails.Remove(dd);
             // Delete Device Attachments
-            foreach (var da in dbContext.DeviceAttachments.Where(i => i.DeviceSerialNumber == d.SerialNumber))
+            foreach (var da in Database.DeviceAttachments.Where(i => i.DeviceSerialNumber == d.SerialNumber))
             {
-                da.RepositoryDelete(dbContext);
-                dbContext.DeviceAttachments.Remove(da);
+                da.RepositoryDelete(Database);
+                Database.DeviceAttachments.Remove(da);
             }
             // Delete Device User Assignments
-            foreach (var dua in dbContext.DeviceUserAssignments.Where(i => i.DeviceSerialNumber == d.SerialNumber))
-                dbContext.DeviceUserAssignments.Remove(dua);
+            foreach (var dua in Database.DeviceUserAssignments.Where(i => i.DeviceSerialNumber == d.SerialNumber))
+                Database.DeviceUserAssignments.Remove(dua);
 
-            dbContext.Devices.Remove(d);
+            Database.Devices.Remove(d);
         }
         #endregion
     }

Disco.BI/BI/Extensions/DeviceBatchExtensions.cs

@@ -4,28 +4,33 @@ using System.Linq;
 using System.Text;
 using Disco.Models.Repository;
 using Disco.Data.Repository;
+using Disco.Services.Users;
+using Disco.Services.Authorization;
 
 namespace Disco.BI.Extensions
 {
     public static class DeviceBatchExtensions
     {
-        public static bool CanDelete(this DeviceBatch db, DiscoDataContext dbContext)
+        public static bool CanDelete(this DeviceBatch db, DiscoDataContext Database)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Config.DeviceBatch.Delete))
+                return false;
+
             // Can't Delete if Contains Devices
-            var deviceCount = dbContext.Devices.Count(d => d.DeviceBatchId == db.Id);
+            var deviceCount = Database.Devices.Count(d => d.DeviceBatchId == db.Id);
             if (deviceCount > 0)
                 return false;
 
             return true;
         }
 
-        public static void Delete(this DeviceBatch db, DiscoDataContext dbContext)
+        public static void Delete(this DeviceBatch db, DiscoDataContext Database)
         {
-            if (!db.CanDelete(dbContext))
+            if (!db.CanDelete(Database))
                 throw new InvalidOperationException("The state of this Device Batch doesn't allow it to be deleted");
 
             // Delete Batch
-            dbContext.DeviceBatches.Remove(db);
+            Database.DeviceBatches.Remove(db);
         }
     }
 }

Disco.BI/BI/Extensions/DeviceCertificateExtensions.cs

@@ -11,16 +11,10 @@ namespace Disco.BI.Extensions
     public static class DeviceCertificateExtensions
     {
 
-        public static Tuple<DeviceCertificate, List<string>> AllocateCertificate(this Device device, DiscoDataContext dbContext)
+        public static Tuple<DeviceCertificate, List<string>> AllocateCertificate(this Device device, DiscoDataContext Database)
         {
             if (!string.IsNullOrEmpty(device.DeviceProfile.CertificateProviderId))
             {
-                // REMOVED 2012-07-18 G# - Plugin is responsible for checking
-                //var deviceCertificates = dbContext.DeviceCertificates.Where(c =>
-                //    c.DeviceSerialNumber == device.SerialNumber &&
-                //    c.ProviderId == device.DeviceProfile.CertificateProviderId &&
-                //    c.Enabled == true).ToList();
-
                 // Load Plugin
                 PluginFeatureManifest featureManifest = Plugins.GetPluginFeature(device.DeviceProfile.CertificateProviderId, typeof(CertificateProviderFeature));
 
@@ -32,7 +26,7 @@ namespace Disco.BI.Extensions
                     //    return new Tuple<DeviceCertificate, List<string>>(deviceCertificates[0], providerPlugin.RemoveExistingCertificateNames());
                     //else
 
-                    return providerFeature.AllocateCertificate(dbContext, device);    
+                    return providerFeature.AllocateCertificate(Database, device);    
                 }
             }
 

Disco.BI/BI/Extensions/DeviceDetailExtensions.cs

@@ -0,0 +1,137 @@
+using Disco.Models.Repository;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Disco.BI.Extensions
+{
+    public static class DeviceDetailExtensions
+    {
+
+        #region Scope Declaration
+
+        public const string ScopeHardware = "Hardware";
+        
+        #endregion
+
+        #region Helpers
+        private static string GetDetail(this IEnumerable<DeviceDetail> details, string Scope, string Key)
+        {
+            if (details == null)
+                throw new ArgumentNullException("details");
+            if (string.IsNullOrEmpty(Scope))
+                throw new ArgumentNullException("Scope");
+            if (string.IsNullOrEmpty(Key))
+                throw new ArgumentNullException("Key");
+
+            var detail = details.Where(d => d.Key == Key).FirstOrDefault();
+
+            if (detail == null)
+                return null;
+            else
+                return detail.Value;
+        }
+
+        private static void SetDetail(this Device device, string Scope, string Key, string Value)
+        {
+            if (device == null)
+                throw new ArgumentNullException("device");
+            if (string.IsNullOrEmpty(Scope))
+                throw new ArgumentNullException("Scope");
+            if (string.IsNullOrEmpty(Key))
+                throw new ArgumentNullException("Key");
+
+            var detail = device.DeviceDetails.Where(d => d.Scope == Scope && d.Key == Key).FirstOrDefault();
+
+            // No Detail Stored & Set to Null
+            if (detail == null && Value == null)
+                return;
+
+            if (detail == null)
+            {
+                detail = new DeviceDetail()
+                {
+                    DeviceSerialNumber = device.SerialNumber,
+                    Scope = Scope,
+                    Key = Key,
+                    Value = Value
+                };
+                device.DeviceDetails.Add(detail);
+            }
+
+            if (detail.Value != Value)
+            {
+                if (Value == null)
+                {
+                    device.DeviceDetails.Remove(detail);
+                }
+                else
+                {
+                    detail.Value = Value;
+                }
+            }
+        } 
+        #endregion
+
+        #region LanMacAddress
+        public const string KeyLanMacAddress = "LanMacAddress";
+        /// <summary>
+        /// Gets the LanMacAddress Device Detail Value
+        /// </summary>
+        /// <returns>The LanMacAddress or null</returns>
+        public static string LanMacAddress(this IEnumerable<DeviceDetail> details)
+        {
+            return details.GetDetail(ScopeHardware, KeyLanMacAddress);
+        }
+        /// <summary>
+        /// Sets the LanMacAddress Device Detail Value
+        /// </summary>
+        public static void LanMacAddress(this IEnumerable<DeviceDetail> details, Device device, string LanMacAddress)
+        {
+            device.SetDetail(ScopeHardware, KeyLanMacAddress, LanMacAddress);
+        } 
+        #endregion
+
+        #region WLanMacAddress
+        public const string KeyWLanMacAddress = "WLanMacAddress";
+        /// <summary>
+        /// Gets the WLanMacAddress Device Detail Value
+        /// </summary>
+        /// <returns>The WLanMacAddress or null</returns>
+        public static string WLanMacAddress(this IEnumerable<DeviceDetail> details)
+        {
+            return details.GetDetail(ScopeHardware, KeyWLanMacAddress);
+        }
+        /// <summary>
+        /// Sets the WLanMacAddress Device Detail Value
+        /// </summary>
+        public static void WLanMacAddress(this IEnumerable<DeviceDetail> details, Device device, string WLanMacAddress)
+        {
+            device.SetDetail(ScopeHardware, KeyWLanMacAddress, WLanMacAddress);
+        } 
+        #endregion
+
+        #region ACAdapter
+        public const string KeyACAdapter = "ACAdapter";
+        /// <summary>
+        /// Gets the ACAdapter Device Detail Value
+        /// </summary>
+        /// <returns>The ACAdapter or null</returns>
+        public static string ACAdapter(this IEnumerable<DeviceDetail> details)
+        {
+            return details.GetDetail(ScopeHardware, KeyACAdapter);
+        }
+        /// <summary>
+        /// Sets the ACAdapter Device Detail Value
+        /// </summary>
+        public static void ACAdapter(this IEnumerable<DeviceDetail> details, Device device, string ACAdapter)
+        {
+            device.SetDetail(ScopeHardware, KeyACAdapter, ACAdapter);
+        }
+        #endregion
+
+    }
+}

Disco.BI/BI/Extensions/DeviceExtensions.cs

@@ -8,13 +8,15 @@ using System.Collections.Generic;
 using System;
 using System.IO;
 using Disco.Models.Interop.ActiveDirectory;
+using Disco.Services.Users;
+using Disco.Services.Authorization;
 
 namespace Disco.BI.Extensions
 {
     public static class DeviceExtensions
     {
 
-        public static string ComputerNameRender(this Device device, DiscoDataContext context)
+        public static string ComputerNameRender(this Device device, DiscoDataContext Database)
         {
             DeviceProfile deviceProfile = device.DeviceProfile;
             Expressions.Expression computerNameTemplateExpression = null;
@@ -24,7 +26,7 @@ namespace Disco.BI.Extensions
                 //return Expressions.Expression.TokenizeSingleDynamic(null, deviceProfile.Configuration(context).ComputerNameTemplate, 0);
                 return Expressions.Expression.TokenizeSingleDynamic(null, deviceProfile.ComputerNameTemplate, 0);
             });
-            System.Collections.IDictionary evaluatorVariables = Expressions.Expression.StandardVariables(null, context, UserBI.UserCache.CurrentUser, System.DateTime.Now, null);
+            System.Collections.IDictionary evaluatorVariables = Expressions.Expression.StandardVariables(null, Database, UserService.CurrentUser, System.DateTime.Now, null);
             string rendered;
             try
             {
@@ -40,12 +42,12 @@ namespace Disco.BI.Extensions
             }
             return rendered.ToString();
         }
-        public static System.Collections.Generic.List<DocumentTemplate> AvailableDocumentTemplates(this Device d, DiscoDataContext Context, User User, System.DateTime TimeStamp)
+        public static System.Collections.Generic.List<DocumentTemplate> AvailableDocumentTemplates(this Device d, DiscoDataContext Database, User User, System.DateTime TimeStamp)
         {
-            List<DocumentTemplate> ats = Context.DocumentTemplates
+            List<DocumentTemplate> ats = Database.DocumentTemplates
                 .Where(at => at.Scope == Disco.Models.Repository.DocumentTemplate.DocumentTemplateScopes.Device).ToList();
 
-            return ats.Where(at => at.FilterExpressionMatches(d, Context, User, TimeStamp, DocumentState.DefaultState())).ToList();
+            return ats.Where(at => at.FilterExpressionMatches(d, Database, User, TimeStamp, DocumentState.DefaultState())).ToList();
         }
 
         public static bool UpdateLastNetworkLogonDate(this Device Device)
@@ -53,7 +55,7 @@ namespace Disco.BI.Extensions
             return ActiveDirectoryUpdateLastNetworkLogonDateJob.UpdateLastNetworkLogonDate(Device);
         }
 
-        public static DeviceAttachment CreateAttachment(this Device Device, DiscoDataContext dbContext, User CreatorUser, string Filename, string MimeType, string Comments, Stream Content, DocumentTemplate DocumentTemplate = null, byte[] PdfThumbnail = null)
+        public static DeviceAttachment CreateAttachment(this Device Device, DiscoDataContext Database, User CreatorUser, string Filename, string MimeType, string Comments, Stream Content, DocumentTemplate DocumentTemplate = null, byte[] PdfThumbnail = null)
         {
             if (string.IsNullOrEmpty(MimeType) || MimeType.Equals("unknown/unknown", StringComparison.InvariantCultureIgnoreCase))
                 MimeType = Interop.MimeTypes.ResolveMimeType(Filename);
@@ -71,20 +73,20 @@ namespace Disco.BI.Extensions
             if (DocumentTemplate != null)
                 da.DocumentTemplateId = DocumentTemplate.Id;
 
-            dbContext.DeviceAttachments.Add(da);
-            dbContext.SaveChanges();
+            Database.DeviceAttachments.Add(da);
+            Database.SaveChanges();
 
-            da.SaveAttachment(dbContext, Content);
+            da.SaveAttachment(Database, Content);
             Content.Position = 0;
             if (PdfThumbnail == null)
-                da.GenerateThumbnail(dbContext, Content);
+                da.GenerateThumbnail(Database, Content);
             else
-                da.SaveThumbnailAttachment(dbContext, PdfThumbnail);
+                da.SaveThumbnailAttachment(Database, PdfThumbnail);
 
             return da;
         }
 
-        public static Device AddOffline(this Device d, DiscoDataContext dbContext)
+        public static Device AddOffline(this Device d, DiscoDataContext Database)
         {
             // Just Include:
             // - Serial Number
@@ -93,17 +95,31 @@ namespace Disco.BI.Extensions
             // - Assigned User Id
             // - Batch
 
+            // Enforce Authorization
+            var auth = UserService.CurrentAuthorization;
+            if (!auth.Has(Claims.Device.Properties.AssetNumber))
+                d.AssetNumber = null;
+            if (!auth.Has(Claims.Device.Properties.Location))
+                d.Location = null;
+            if (!auth.Has(Claims.Device.Properties.DeviceBatch))
+                d.DeviceBatchId = null;
+            if (!auth.Has(Claims.Device.Properties.DeviceProfile))
+                d.DeviceProfileId = Database.DiscoConfiguration.DeviceProfiles.DefaultAddDeviceOfflineDeviceProfileId;
+            if (!auth.Has(Claims.Device.Actions.AssignUser))
+                d.AssignedUserId = null;
+
+
             // Batch
             DeviceBatch db = default(DeviceBatch);
             if (d.DeviceBatchId.HasValue)
-                db = dbContext.DeviceBatches.Find(d.DeviceBatchId.Value);
+                db = Database.DeviceBatches.Find(d.DeviceBatchId.Value);
 
             // Default Device Model
             DeviceModel dm = default(DeviceModel);
             if (db != null && db.DefaultDeviceModelId.HasValue)
-                dm = dbContext.DeviceModels.Find(db.DefaultDeviceModelId); // From Batch
+                dm = Database.DeviceModels.Find(db.DefaultDeviceModelId); // From Batch
             else
-                dm = dbContext.DeviceModels.Find(1); // Default
+                dm = Database.DeviceModels.Find(1); // Default
 
             Device d2 = new Device()
             {
@@ -112,7 +128,7 @@ namespace Disco.BI.Extensions
                 Location = d.Location,
                 CreatedDate = DateTime.Now,
                 DeviceProfileId = d.DeviceProfileId,
-                DeviceProfile = dbContext.DeviceProfiles.Find(d.DeviceProfileId),
+                DeviceProfile = Database.DeviceProfiles.Find(d.DeviceProfileId),
                 AllowUnauthenticatedEnrol = true,
                 DeviceModelId = dm.Id,
                 DeviceModel = dm,
@@ -120,22 +136,22 @@ namespace Disco.BI.Extensions
                 DeviceBatch = db
             };
 
-            dbContext.Devices.Add(d2);
+            Database.Devices.Add(d2);
             if (!string.IsNullOrEmpty(d.AssignedUserId))
             {
-                User u = UserBI.UserCache.GetUser(d.AssignedUserId, dbContext, true);
-                d2.AssignDevice(dbContext, u);
+                User u = UserService.GetUser(d.AssignedUserId, Database, true);
+                d2.AssignDevice(Database, u);
             }
 
             return d2;
         }
 
-        public static DeviceUserAssignment AssignDevice(this Device d, DiscoDataContext dbContext, User u)
+        public static DeviceUserAssignment AssignDevice(this Device d, DiscoDataContext Database, User u)
         {
             DeviceUserAssignment newDua = default(DeviceUserAssignment);
 
             // Mark existing assignments as Unassigned
-            foreach (var dua in dbContext.DeviceUserAssignments.Where(m => m.DeviceSerialNumber == d.SerialNumber && !m.UnassignedDate.HasValue))
+            foreach (var dua in Database.DeviceUserAssignments.Where(m => m.DeviceSerialNumber == d.SerialNumber && !m.UnassignedDate.HasValue))
                 dua.UnassignedDate = DateTime.Now;
 
             if (u != null)
@@ -147,7 +163,7 @@ namespace Disco.BI.Extensions
                     AssignedUserId = u.Id,
                     AssignedDate = DateTime.Now
                 };
-                dbContext.DeviceUserAssignments.Add(newDua);
+                Database.DeviceUserAssignments.Add(newDua);
 
                 d.AssignedUserId = u.Id;
                 d.AssignedUser = u;
@@ -178,10 +194,39 @@ namespace Disco.BI.Extensions
                 return null;
         }
 
+        public static string ReasonMessage(this Disco.Models.Repository.Device.DecommissionReasons r)
+        {
+            switch (r)
+            {
+                case Device.DecommissionReasons.EndOfLife:
+                    return "End of Life";
+                case Device.DecommissionReasons.Sold:
+                    return "Sold";
+                case Device.DecommissionReasons.Stolen:
+                    return "Stolen";
+                case Device.DecommissionReasons.Lost:
+                    return "Lost";
+                case Device.DecommissionReasons.Damaged:
+                    return "Damaged";
+                case Device.DecommissionReasons.Donated:
+                    return "Donated";
+                default:
+                    return "Unknown";
+            }
+        }
+
+        public static string ReasonMessage(this Disco.Models.Repository.Device.DecommissionReasons? r)
+        {
+            if (!r.HasValue)
+                return "Not Decommissioned";
+
+            return r.Value.ReasonMessage();
+        }
+
         public static string Status(this Device Device)
         {
             if (Device.DecommissionedDate.HasValue)
-                return "Decommissioned";
+                return string.Format("Decommissioned ({0})", Device.DecommissionReason.ReasonMessage());
 
             if (!Device.EnrolledDate.HasValue)
                 return "Not Enrolled";

Disco.BI/BI/Extensions/DeviceModelExtensions.cs

@@ -6,6 +6,8 @@ using Disco.Models.Repository;
 using System.IO;
 using System.Drawing;
 using Disco.Data.Repository;
+using Disco.Services.Users;
+using Disco.Services.Authorization;
 
 namespace Disco.BI.Extensions
 {
@@ -73,22 +75,24 @@ namespace Disco.BI.Extensions
         }
 
         #region Actions
-        // Added 2012-11-26 G# - Need ability to delete Device Models
-        public static bool CanDelete(this DeviceModel dm, DiscoDataContext dbContext)
+        public static bool CanDelete(this DeviceModel dm, DiscoDataContext Database)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Config.DeviceModel.Delete))
+                return false;
+
             // Can't Delete Default Model (Id: 1)
             if (dm.Id == 1)
                 return false;
 
             // Can't Delete if Contains Devices
-            if (dbContext.Devices.Count(d => d.DeviceModelId == dm.Id) > 0)
+            if (Database.Devices.Count(d => d.DeviceModelId == dm.Id) > 0)
                 return false;
 
             return true;
         }
-        public static void Delete(this DeviceModel dm, DiscoDataContext dbContext)
+        public static void Delete(this DeviceModel dm, DiscoDataContext Database)
         {
-            if (!dm.CanDelete(dbContext))
+            if (!dm.CanDelete(Database))
                 throw new InvalidOperationException("The state of this Device Model doesn't allow it to be deleted");
 
             // Delete Image
@@ -97,13 +101,13 @@ namespace Disco.BI.Extensions
                 File.Delete(deviceModelImagePath);
 
             // Delete any Device Model Components
-            foreach (var deviceModelComponent in dbContext.DeviceComponents.Where(dc => dc.DeviceModelId == dm.Id).ToList())
+            foreach (var deviceModelComponent in Database.DeviceComponents.Where(dc => dc.DeviceModelId == dm.Id).ToList())
             {
-                dbContext.DeviceComponents.Remove(deviceModelComponent);
+                Database.DeviceComponents.Remove(deviceModelComponent);
             }
 
             // Delete Model
-            dbContext.DeviceModels.Remove(dm);
+            Database.DeviceModels.Remove(dm);
         }
         // End Added 2012-11-26 G#
         #endregion

Disco.BI/BI/Extensions/DeviceProfileExtensions.cs

@@ -6,6 +6,8 @@ using Disco.Models.Repository;
 using Disco.Data.Repository;
 using Disco.Data.Configuration.Modules;
 using Disco.Models.BI.Config;
+using Disco.Services.Users;
+using Disco.Services.Authorization;
 
 namespace Disco.BI.Extensions
 {
@@ -18,11 +20,11 @@ namespace Disco.BI.Extensions
             Expressions.ExpressionCache.InvalidateKey(ComputerNameExpressionCacheModule, deviceProfile.Id.ToString());
         }
 
-        public static OrganisationAddress DefaultOrganisationAddressDetails(this DeviceProfile deviceProfile, DiscoDataContext dbContext)
+        public static OrganisationAddress DefaultOrganisationAddressDetails(this DeviceProfile deviceProfile, DiscoDataContext Database)
         {
             if (deviceProfile.DefaultOrganisationAddress.HasValue)
             {
-                return dbContext.DiscoConfiguration.OrganisationAddresses.GetAddress(deviceProfile.DefaultOrganisationAddress.Value);
+                return Database.DiscoConfiguration.OrganisationAddresses.GetAddress(deviceProfile.DefaultOrganisationAddress.Value);
             }
             else
             {
@@ -30,38 +32,35 @@ namespace Disco.BI.Extensions
             }
         }
 
-        public static bool CanDelete(this DeviceProfile dp, DiscoDataContext dbContext)
+        public static bool CanDelete(this DeviceProfile dp, DiscoDataContext Database)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Config.DeviceProfile.Delete))
+                return false;
+
             // Can't Delete Default Profile (Id: 1)
             if (dp.Id == 1)
                 return false;
 
             // Can't Delete if Contains Devices
-            if (dbContext.Devices.Count(d => d.DeviceProfileId == dp.Id) > 0)
+            if (Database.Devices.Count(d => d.DeviceProfileId == dp.Id) > 0)
                 return false;
 
             return true;
         }
-        public static void Delete(this DeviceProfile dp, DiscoDataContext dbContext)
+        public static void Delete(this DeviceProfile dp, DiscoDataContext Database)
         {
-            if (!dp.CanDelete(dbContext))
+            if (!dp.CanDelete(Database))
                 throw new InvalidOperationException("The state of this Device Profile doesn't allow it to be deleted");
 
             // Update Defaults
-            if (dbContext.DiscoConfiguration.DeviceProfiles.DefaultDeviceProfileId == dp.Id)
-                dbContext.DiscoConfiguration.DeviceProfiles.DefaultDeviceProfileId = 1;
-            if (dbContext.DiscoConfiguration.DeviceProfiles.DefaultAddDeviceOfflineDeviceProfileId == dp.Id)
-                dbContext.DiscoConfiguration.DeviceProfiles.DefaultAddDeviceOfflineDeviceProfileId = 1;
+            if (Database.DiscoConfiguration.DeviceProfiles.DefaultDeviceProfileId == dp.Id)
+                Database.DiscoConfiguration.DeviceProfiles.DefaultDeviceProfileId = 1;
+            if (Database.DiscoConfiguration.DeviceProfiles.DefaultAddDeviceOfflineDeviceProfileId == dp.Id)
+                Database.DiscoConfiguration.DeviceProfiles.DefaultAddDeviceOfflineDeviceProfileId = 1;
 
             // Delete Profile
-            dbContext.DeviceProfiles.Remove(dp);
+            Database.DeviceProfiles.Remove(dp);
         }
 
-        // Removed 2012-06-14 G# - Properties moved to DeviceProfile model & DB Migrated in DBv3.
-        //public static DeviceProfileConfiguration Configuration(this DeviceProfile dp, DiscoDataContext dbContext)
-        //{
-        //    return dbContext.DiscoConfiguration.DeviceProfiles.DeviceProfile(dp);
-        //}
-
     }
 }

Disco.BI/BI/Extensions/DocumentTemplateExtensions.cs

@@ -19,13 +19,13 @@ namespace Disco.BI.Extensions
     {
         private const string DocumentTemplateExpressionCacheTemplate = "DocumentTemplate_{0}";
 
-        public static string RepositoryFilename(this DocumentTemplate dt, DiscoDataContext dbContext)
+        public static string RepositoryFilename(this DocumentTemplate dt, DiscoDataContext Database)
         {
-            return System.IO.Path.Combine(DataStore.CreateLocation(dbContext, "DocumentTemplates"), string.Format("{0}.pdf", dt.Id));
+            return System.IO.Path.Combine(DataStore.CreateLocation(Database, "DocumentTemplates"), string.Format("{0}.pdf", dt.Id));
         }
-        public static string SavePdfTemplate(this DocumentTemplate dt, DiscoDataContext dbContext, Stream TemplateFile)
+        public static string SavePdfTemplate(this DocumentTemplate dt, DiscoDataContext Database, Stream TemplateFile)
         {
-            string filePath = dt.RepositoryFilename(dbContext);
+            string filePath = dt.RepositoryFilename(Database);
             using (FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
             {
                 TemplateFile.CopyTo(fs);
@@ -39,14 +39,14 @@ namespace Disco.BI.Extensions
             return Interop.Pdf.PdfImporter.GetPageImages(pdfReader, PageNumber);
         }
 
-        public static ConcurrentDictionary<string, Expression> PdfExpressionsFromCache(this DocumentTemplate dt, DiscoDataContext dbContext)
+        public static ConcurrentDictionary<string, Expression> PdfExpressionsFromCache(this DocumentTemplate dt, DiscoDataContext Database)
         {
             string cacheModuleKey = string.Format(DocumentTemplateExpressionCacheTemplate, dt.Id);
             var module = Expressions.ExpressionCache.GetModule(cacheModuleKey);
             if (module == null)
             {
                 // Cache
-                string templateFilename = dt.RepositoryFilename(dbContext);
+                string templateFilename = dt.RepositoryFilename(Database);
                 PdfReader pdfReader = new PdfReader(templateFilename);
                 int pdfFieldOrdinal = 0;
                 foreach (string pdfFieldKey in pdfReader.AcroFields.Fields.Keys)
@@ -61,21 +61,21 @@ namespace Disco.BI.Extensions
             return module;
         }
 
-        public static List<BI.Expressions.Expression> ExtractPdfExpressions(this DocumentTemplate dt, DiscoDataContext dbContext)
+        public static List<BI.Expressions.Expression> ExtractPdfExpressions(this DocumentTemplate dt, DiscoDataContext Database)
         {
-            return dt.PdfExpressionsFromCache(dbContext).Values.OrderBy(e => e.Ordinal).ToList();
+            return dt.PdfExpressionsFromCache(Database).Values.OrderBy(e => e.Ordinal).ToList();
         }
-        public static System.IO.Stream GeneratePdfBulk(this DocumentTemplate dt, DiscoDataContext dbContext, User CreatorUser, System.DateTime Timestamp, params string[] DataObjectsIds)
+        public static System.IO.Stream GeneratePdfBulk(this DocumentTemplate dt, DiscoDataContext Database, User CreatorUser, System.DateTime Timestamp, params string[] DataObjectsIds)
         {
-            return Interop.Pdf.PdfGenerator.GenerateBulkFromTemplate(dt, dbContext, CreatorUser, Timestamp, DataObjectsIds);
+            return Interop.Pdf.PdfGenerator.GenerateBulkFromTemplate(dt, Database, CreatorUser, Timestamp, DataObjectsIds);
         }
-        public static System.IO.Stream GeneratePdfBulk(this DocumentTemplate dt, DiscoDataContext dbContext, User CreatorUser, System.DateTime Timestamp, params object[] DataObjects)
+        public static System.IO.Stream GeneratePdfBulk(this DocumentTemplate dt, DiscoDataContext Database, User CreatorUser, System.DateTime Timestamp, params object[] DataObjects)
         {
-            return Interop.Pdf.PdfGenerator.GenerateBulkFromTemplate(dt, dbContext, CreatorUser, Timestamp, DataObjects);
+            return Interop.Pdf.PdfGenerator.GenerateBulkFromTemplate(dt, Database, CreatorUser, Timestamp, DataObjects);
         }
-        public static System.IO.Stream GeneratePdf(this DocumentTemplate dt, DiscoDataContext dbContext, object Data, User CreatorUser, System.DateTime TimeStamp, DocumentState State, bool FlattenFields = false)
+        public static System.IO.Stream GeneratePdf(this DocumentTemplate dt, DiscoDataContext Database, object Data, User CreatorUser, System.DateTime TimeStamp, DocumentState State, bool FlattenFields = false)
         {
-            return Interop.Pdf.PdfGenerator.GenerateFromTemplate(dt, dbContext, Data, CreatorUser, TimeStamp, State, FlattenFields);
+            return Interop.Pdf.PdfGenerator.GenerateFromTemplate(dt, Database, Data, CreatorUser, TimeStamp, State, FlattenFields);
         }
 
         public static Expression FilterExpressionFromCache(this DocumentTemplate dt)
@@ -86,12 +86,12 @@ namespace Disco.BI.Extensions
         {
             ExpressionCache.InvalidateKey("DocumentTemplateFilterExpression", dt.Id);
         }
-        public static bool FilterExpressionMatches(this DocumentTemplate dt, object Data, DiscoDataContext DataContext, User User, System.DateTime TimeStamp, DocumentState State)
+        public static bool FilterExpressionMatches(this DocumentTemplate dt, object Data, DiscoDataContext Database, User User, System.DateTime TimeStamp, DocumentState State)
         {
             if (!string.IsNullOrEmpty(dt.FilterExpression))
             {
                 Expression compiledExpression = dt.FilterExpressionFromCache();
-                System.Collections.IDictionary evaluatorVariables = Expression.StandardVariables(dt, DataContext, User, TimeStamp, State);
+                System.Collections.IDictionary evaluatorVariables = Expression.StandardVariables(dt, Database, User, TimeStamp, State);
                 try
                 {
                     object er = compiledExpression.EvaluateFirst<object>(Data, evaluatorVariables);
@@ -170,14 +170,14 @@ namespace Disco.BI.Extensions
                 Page
             );
         }
-        public static List<RectangleF> QRCodeLocations(this DocumentTemplate dt, DiscoDataContext dbContext)
+        public static List<RectangleF> QRCodeLocations(this DocumentTemplate dt, DiscoDataContext Database)
         {
-            return DocumentTemplateBI.DocumentTemplateQRCodeLocationCache.GetLocations(dt, dbContext);
+            return DocumentTemplateBI.DocumentTemplateQRCodeLocationCache.GetLocations(dt, Database);
         }
-        public static void Delete(this DocumentTemplate dt, DiscoDataContext Context)
+        public static void Delete(this DocumentTemplate dt, DiscoDataContext Database)
         {
             // Find & Rename all references
-            foreach (DeviceAttachment a in Context.DeviceAttachments.Where(a => a.DocumentTemplateId == dt.Id))
+            foreach (DeviceAttachment a in Database.DeviceAttachments.Where(a => a.DocumentTemplateId == dt.Id))
             {
                 a.Comments = string.Format("{0} - {1}", dt.Description, a.Comments);
                 if (a.Comments.Length > 500)
@@ -185,7 +185,7 @@ namespace Disco.BI.Extensions
                 a.DocumentTemplateId = null;
                 a.DocumentTemplate = null;
             }
-            foreach (JobAttachment a in Context.JobAttachments.Where(a => a.DocumentTemplateId == dt.Id))
+            foreach (JobAttachment a in Database.JobAttachments.Where(a => a.DocumentTemplateId == dt.Id))
             {
                 a.Comments = string.Format("{0} - {1}", dt.Description, a.Comments);
                 if (a.Comments.Length > 500)
@@ -193,7 +193,7 @@ namespace Disco.BI.Extensions
                 a.DocumentTemplateId = null;
                 a.DocumentTemplate = null;
             }
-            foreach (UserAttachment a in Context.UserAttachments.Where(a => a.DocumentTemplateId == dt.Id))
+            foreach (UserAttachment a in Database.UserAttachments.Where(a => a.DocumentTemplateId == dt.Id))
             {
                 a.Comments = string.Format("{0} - {1}", dt.Description, a.Comments);
                 if (a.Comments.Length > 500)
@@ -206,7 +206,7 @@ namespace Disco.BI.Extensions
             dt.JobSubTypes.Clear();
 
             // Delete Template
-            string templateRepositoryFilename = dt.RepositoryFilename(Context);
+            string templateRepositoryFilename = dt.RepositoryFilename(Database);
             if (System.IO.File.Exists(templateRepositoryFilename))
                 System.IO.File.Delete(templateRepositoryFilename);
 
@@ -214,7 +214,7 @@ namespace Disco.BI.Extensions
             dt.FilterExpressionInvalidateCache();
 
             // Delete Document Template from Repository
-            Context.DocumentTemplates.Remove(dt);
+            Database.DocumentTemplates.Remove(dt);
         }
     }
 }

Disco.BI/BI/Extensions/JobActionExtensions.cs

@@ -6,6 +6,8 @@ using Disco.Models.BI.Config;
 using Disco.Models.Repository;
 using Disco.Services.Plugins;
 using Disco.Services.Plugins.Features.WarrantyProvider;
+using Disco.Services.Users;
+using Disco.Services.Authorization;
 
 namespace Disco.BI.Extensions
 {
@@ -15,6 +17,9 @@ namespace Disco.BI.Extensions
         #region Device Held
         public static bool CanDeviceHeld(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Properties.DeviceHeld))
+                return false;
+
             return (!j.ClosedDate.HasValue) && (j.DeviceSerialNumber != null) &&
                 (!j.DeviceHeld.HasValue || j.DeviceReturnedDate.HasValue);
         }
@@ -35,6 +40,9 @@ namespace Disco.BI.Extensions
         #region Device Ready for Return
         public static bool CanDeviceReadyForReturn(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Properties.DeviceReadyForReturn))
+                return false;
+
             return (!j.ClosedDate.HasValue) && j.DeviceHeld.HasValue &&
                 !j.DeviceReadyForReturn.HasValue && !j.DeviceReturnedDate.HasValue;
         }
@@ -51,6 +59,9 @@ namespace Disco.BI.Extensions
         #region Device Returned
         public static bool CanDeviceReturned(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Properties.DeviceReturned))
+                return false;
+
             return (!j.ClosedDate.HasValue) && j.DeviceHeld.HasValue &&
                 !j.DeviceReturnedDate.HasValue;
         }
@@ -67,9 +78,12 @@ namespace Disco.BI.Extensions
         #region Waiting For User Action
         public static bool CanWaitingForUserAction(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Properties.WaitingForUserAction))
+                return false;
+
             return !j.ClosedDate.HasValue && (j.UserId != null) && !j.WaitingForUserAction.HasValue;
         }
-        public static void OnWaitingForUserAction(this Job j, DiscoDataContext dbContext, User Technician, string Reason)
+        public static void OnWaitingForUserAction(this Job j, DiscoDataContext Database, User Technician, string Reason)
         {
             if (!j.CanWaitingForUserAction())
                 throw new InvalidOperationException("Waiting for User Action was Denied");
@@ -84,16 +98,19 @@ namespace Disco.BI.Extensions
                 Timestamp = DateTime.Now,
                 Comments = string.Format("Waiting on User Action{0}Reason: {1}", Environment.NewLine, Reason)
             };
-            dbContext.JobLogs.Add(jobLog);
+            Database.JobLogs.Add(jobLog);
         }
         #endregion
 
         #region Not Waiting For User Action
         public static bool CanNotWaitingForUserAction(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Properties.NotWaitingForUserAction))
+                return false;
+
             return j.WaitingForUserAction.HasValue;
         }
-        public static void OnNotWaitingForUserAction(this Job j, DiscoDataContext dbContext, User Technician, string Resolution)
+        public static void OnNotWaitingForUserAction(this Job j, DiscoDataContext Database, User Technician, string Resolution)
         {
             if (!j.CanNotWaitingForUserAction())
                 throw new InvalidOperationException("Not Waiting for User Action was Denied");
@@ -108,31 +125,34 @@ namespace Disco.BI.Extensions
                 Timestamp = DateTime.Now,
                 Comments = string.Format("User Action Resolved{0}Resolution: {1}", Environment.NewLine, Resolution)
             };
-            dbContext.JobLogs.Add(jobLog);
+            Database.JobLogs.Add(jobLog);
         }
         #endregion
 
         #region Log Warranty
         public static bool CanLogWarranty(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Actions.LogWarranty))
+                return false;
+            
             return !j.ClosedDate.HasValue &&
                 (j.DeviceSerialNumber != null) &&
                 j.JobTypeId == JobType.JobTypeIds.HWar &&
                 string.IsNullOrEmpty(j.JobMetaWarranty.ExternalReference);
         }
-        public static void OnLogWarranty(this Job j, DiscoDataContext dbContext, string FaultDescription, PluginFeatureManifest WarrantyProviderDefinition, OrganisationAddress Address, User TechUser, Dictionary<string, string> WarrantyProviderProperties)
+        public static void OnLogWarranty(this Job j, DiscoDataContext Database, string FaultDescription, PluginFeatureManifest WarrantyProviderDefinition, OrganisationAddress Address, User TechUser, Dictionary<string, string> WarrantyProviderProperties)
         {
             if (!j.CanLogWarranty())
                 throw new InvalidOperationException("Log Warranty was Denied");
 
             if (string.IsNullOrWhiteSpace(FaultDescription))
-                FaultDescription = j.GenerateFaultDescriptionFooter(dbContext, WarrantyProviderDefinition);
+                FaultDescription = j.GenerateFaultDescriptionFooter(Database, WarrantyProviderDefinition);
             else
-                FaultDescription = string.Concat(FaultDescription, Environment.NewLine, Environment.NewLine, j.GenerateFaultDescriptionFooter(dbContext, WarrantyProviderDefinition));
+                FaultDescription = string.Concat(FaultDescription, Environment.NewLine, Environment.NewLine, j.GenerateFaultDescriptionFooter(Database, WarrantyProviderDefinition));
 
             using (WarrantyProviderFeature WarrantyProvider = WarrantyProviderDefinition.CreateInstance<WarrantyProviderFeature>())
             {
-                string providerRef = WarrantyProvider.SubmitJob(dbContext, j, Address, TechUser, FaultDescription, WarrantyProviderProperties);
+                string providerRef = WarrantyProvider.SubmitJob(Database, j, Address, TechUser, FaultDescription, WarrantyProviderProperties);
 
                 j.JobMetaWarranty.ExternalLoggedDate = DateTime.Now;
                 j.JobMetaWarranty.ExternalName = WarrantyProvider.WarrantyProviderId;
@@ -150,7 +170,7 @@ namespace Disco.BI.Extensions
                     Timestamp = DateTime.Now,
                     Comments = string.Format("Warranty Claim Submitted{0}{0}Provider: {1}{0}Repair Address: {2}{0}Provider Reference: {3}{0}{0}{4}", Environment.NewLine, WarrantyProvider.Manifest.Name, Address.Name, providerRef, FaultDescription)
                 };
-                dbContext.JobLogs.Add(jobLog);
+                Database.JobLogs.Add(jobLog);
             }
         }
         #endregion
@@ -158,32 +178,35 @@ namespace Disco.BI.Extensions
         #region Convert HWar to HNWar
         public static bool CanConvertHWarToHNWar(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Actions.ConvertHWarToHNWar))
+                return false;
+
             return !j.ClosedDate.HasValue && (j.DeviceSerialNumber != null) &&
                 j.JobTypeId == JobType.JobTypeIds.HWar && string.IsNullOrEmpty(j.JobMetaWarranty.ExternalReference);
         }
-        public static void OnConvertHWarToHNWar(this Job j, DiscoDataContext dbContext)
+        public static void OnConvertHWarToHNWar(this Job j, DiscoDataContext Database)
         {
             if (!j.CanConvertHWarToHNWar())
                 throw new InvalidOperationException("Convert HWar to HNWar was Denied");
 
-            var techUser = UserBI.UserCache.CurrentUser;
+            var techUser = UserService.CurrentUser;
 
             // Remove JobMetaWarranty
             if (j.JobMetaWarranty != null)
-                dbContext.JobMetaWarranties.Remove(j.JobMetaWarranty);
+                Database.JobMetaWarranties.Remove(j.JobMetaWarranty);
 
             // Add JobMetaNonWarranty
             var metaHNWar = new JobMetaNonWarranty() { Job = j };
-            dbContext.JobMetaNonWarranties.Add(metaHNWar);
+            Database.JobMetaNonWarranties.Add(metaHNWar);
 
             // Swap Job Sub Types
             List<string> jobSubTypes = j.JobSubTypes.Select(jst => jst.Id).ToList();
             j.JobSubTypes.Clear();
-            foreach (var jst in dbContext.JobSubTypes.Where(i => i.JobTypeId == JobType.JobTypeIds.HNWar && jobSubTypes.Contains(i.Id)))
+            foreach (var jst in Database.JobSubTypes.Where(i => i.JobTypeId == JobType.JobTypeIds.HNWar && jobSubTypes.Contains(i.Id)))
                 j.JobSubTypes.Add(jst);
 
             // Add Components
-            var components = dbContext.DeviceComponents.Include("JobSubTypes").Where(c => !c.DeviceModelId.HasValue || c.DeviceModelId == j.Device.DeviceModelId);
+            var components = Database.DeviceComponents.Include("JobSubTypes").Where(c => !c.DeviceModelId.HasValue || c.DeviceModelId == j.Device.DeviceModelId);
             var jobComponents = new List<DeviceComponent>();
             foreach (var component in components)
             {
@@ -210,7 +233,7 @@ namespace Disco.BI.Extensions
             }
             foreach (var component in jobComponents)
             {
-                dbContext.JobComponents.Add(new JobComponent()
+                Database.JobComponents.Add(new JobComponent()
                 {
                     Job = j,
                     TechUserId = techUser.Id,
@@ -225,9 +248,9 @@ namespace Disco.BI.Extensions
                 JobId = j.Id,
                 TechUserId = techUser.Id,
                 Timestamp = DateTime.Now,
-                Comments = string.Format("Job Type Converted{0}From: {1}{0}To: {2}", Environment.NewLine, dbContext.JobTypes.Find(JobType.JobTypeIds.HWar), dbContext.JobTypes.Find(JobType.JobTypeIds.HNWar))
+                Comments = string.Format("Job Type Converted{0}From: {1}{0}To: {2}", Environment.NewLine, Database.JobTypes.Find(JobType.JobTypeIds.HWar), Database.JobTypes.Find(JobType.JobTypeIds.HNWar))
             };
-            dbContext.JobLogs.Add(jobLog);
+            Database.JobLogs.Add(jobLog);
 
             j.JobTypeId = JobType.JobTypeIds.HNWar;
         }
@@ -252,6 +275,9 @@ namespace Disco.BI.Extensions
         #region Insurance Claim Form Sent
         public static bool CanInsuranceClaimFormSent(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Properties.NonWarrantyProperties.InsuranceClaimFormSent))
+                return false;
+
             return (j.JobTypeId == JobType.JobTypeIds.HNWar) &&
                 j.JobMetaNonWarranty.IsInsuranceClaim &&
                 !j.JobMetaInsurance.ClaimFormSentDate.HasValue;
@@ -261,7 +287,7 @@ namespace Disco.BI.Extensions
             if (!j.CanInsuranceClaimFormSent())
                 throw new InvalidOperationException("Insurance Claim Form Sent was Denied");
 
-            var techUser = UserBI.UserCache.CurrentUser;
+            var techUser = UserService.CurrentUser;
 
             j.JobMetaInsurance.ClaimFormSentDate = DateTime.Now;
             j.JobMetaInsurance.ClaimFormSentUserId = techUser.Id;
@@ -271,6 +297,9 @@ namespace Disco.BI.Extensions
         #region Log Repair
         public static bool CanLogRepair(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Actions.LogRepair))
+                return false;
+
             return (j.JobTypeId == JobType.JobTypeIds.HNWar) &&
                 (j.DeviceSerialNumber != null) &&
                 !j.JobMetaNonWarranty.RepairerLoggedDate.HasValue &&
@@ -292,6 +321,9 @@ namespace Disco.BI.Extensions
         #region Repair Complete
         public static bool CanRepairComplete(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Properties.NonWarrantyProperties.RepairerCompletedDate))
+                return false;
+
             return (j.JobTypeId == JobType.JobTypeIds.HNWar) &&
                 j.JobMetaNonWarranty.RepairerLoggedDate.HasValue &&
                 !j.JobMetaNonWarranty.RepairerCompletedDate.HasValue;
@@ -308,6 +340,9 @@ namespace Disco.BI.Extensions
         #region Close
         public static bool CanClose(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Actions.Close))
+                return false;
+
             if (j.ClosedDate.HasValue)
                 return false; // Job already Closed
 
@@ -352,6 +387,9 @@ namespace Disco.BI.Extensions
         #region Force Close
         public static bool CanForceClose(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Actions.ForceClose))
+                return false;
+
             var canCloseNormally = j.CanClose();
 
             if (canCloseNormally)
@@ -389,7 +427,7 @@ namespace Disco.BI.Extensions
 
             return false;
         }
-        public static void OnForceClose(this Job j, DiscoDataContext dbContext, User Technician, string Reason)
+        public static void OnForceClose(this Job j, DiscoDataContext Database, User Technician, string Reason)
         {
             if (!j.CanForceClose())
                 throw new InvalidOperationException("Force Close was Denied");
@@ -402,7 +440,7 @@ namespace Disco.BI.Extensions
                 Timestamp = DateTime.Now,
                 Comments = string.Format("Job Forcibly Closed{0}Reason: {1}", Environment.NewLine, Reason)
             };
-            dbContext.JobLogs.Add(jobLog);
+            Database.JobLogs.Add(jobLog);
 
             j.ClosedDate = DateTime.Now;
             j.ClosedTechUserId = Technician.Id;
@@ -412,6 +450,9 @@ namespace Disco.BI.Extensions
         #region Reopen
         public static bool CanReopen(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Actions.Reopen))
+                return false;
+
             return j.ClosedDate.HasValue;
         }
         public static void OnReopen(this Job j)
@@ -427,47 +468,50 @@ namespace Disco.BI.Extensions
         #region Delete
         public static bool CanDelete(this Job j)
         {
+            if (!UserService.CurrentAuthorization.Has(Claims.Job.Actions.Delete))
+                return false;
+
             return j.ClosedDate.HasValue;
         }
-        public static void OnDelete(this Job j, DiscoDataContext dbContext)
+        public static void OnDelete(this Job j, DiscoDataContext Database)
         {
             // Job Sub Types
             j.JobSubTypes.Clear();
 
             // Job Attachments
             foreach (var ja in j.JobAttachments.ToArray())
-                ja.OnDelete(dbContext);
+                ja.OnDelete(Database);
             j.JobAttachments.Clear();
 
             // Job Components
             foreach (var jc in j.JobComponents.ToArray())
-                dbContext.JobComponents.Remove(jc);
+                Database.JobComponents.Remove(jc);
             j.JobComponents.Clear();
 
             // Job Logs
             foreach (var jl in j.JobLogs.ToArray())
-                dbContext.JobLogs.Remove(jl);
+                Database.JobLogs.Remove(jl);
             j.JobLogs.Clear();
 
             // Job Meta
             if (j.JobMetaInsurance != null)
             {
-                dbContext.JobMetaInsurances.Remove(j.JobMetaInsurance);
+                Database.JobMetaInsurances.Remove(j.JobMetaInsurance);
                 j.JobMetaInsurance = null;
             }
             if (j.JobMetaNonWarranty != null)
             {
-                dbContext.JobMetaNonWarranties.Remove(j.JobMetaNonWarranty);
+                Database.JobMetaNonWarranties.Remove(j.JobMetaNonWarranty);
                 j.JobMetaNonWarranty = null;
             }
             if (j.JobMetaWarranty != null)
             {
-                dbContext.JobMetaWarranties.Remove(j.JobMetaWarranty);
+                Database.JobMetaWarranties.Remove(j.JobMetaWarranty);
                 j.JobMetaWarranty = null;
             }
 
             // Job
-            dbContext.Jobs.Remove(j);
+            Database.Jobs.Remove(j);
         }
         #endregion
     }

Disco.BI/BI/Extensions/JobExtensions.cs

@@ -13,7 +13,7 @@ namespace Disco.BI.Extensions
 {
     public static class JobExtensions
     {
-        public static JobAttachment CreateAttachment(this Job Job, DiscoDataContext dbContext, User CreatorUser, string Filename, string MimeType, string Comments, Stream Content, DocumentTemplate DocumentTemplate = null, byte[] PdfThumbnail = null)
+        public static JobAttachment CreateAttachment(this Job Job, DiscoDataContext Database, User CreatorUser, string Filename, string MimeType, string Comments, Stream Content, DocumentTemplate DocumentTemplate = null, byte[] PdfThumbnail = null)
         {
             if (string.IsNullOrEmpty(MimeType) || MimeType.Equals("unknown/unknown", StringComparison.InvariantCultureIgnoreCase))
                 MimeType = Interop.MimeTypes.ResolveMimeType(Filename);
@@ -31,15 +31,15 @@ namespace Disco.BI.Extensions
             if (DocumentTemplate != null)
                 ja.DocumentTemplateId = DocumentTemplate.Id;
 
-            dbContext.JobAttachments.Add(ja);
-            dbContext.SaveChanges();
+            Database.JobAttachments.Add(ja);
+            Database.SaveChanges();
 
-            ja.SaveAttachment(dbContext, Content);
+            ja.SaveAttachment(Database, Content);
             Content.Position = 0;
             if (PdfThumbnail == null)
-                ja.GenerateThumbnail(dbContext, Content);
+                ja.GenerateThumbnail(Database, Content);
             else
-                ja.SaveThumbnailAttachment(dbContext, PdfThumbnail);
+                ja.SaveThumbnailAttachment(Database, PdfThumbnail);
 
             return ja;
         }
@@ -146,9 +146,9 @@ namespace Disco.BI.Extensions
             return Job.JobStatusIds.Open;
         }
 
-        public static List<DocumentTemplate> AvailableDocumentTemplates(this Job j, DiscoDataContext dbContext, User User, DateTime TimeStamp)
+        public static List<DocumentTemplate> AvailableDocumentTemplates(this Job j, DiscoDataContext Database, User User, DateTime TimeStamp)
         {
-            var dts = dbContext.DocumentTemplates.Include("JobSubTypes")
+            var dts = Database.DocumentTemplates.Include("JobSubTypes")
                 .Where(dt => dt.Scope == DocumentTemplate.DocumentTemplateScopes.Job)
                 .ToList();
 
@@ -171,7 +171,7 @@ namespace Disco.BI.Extensions
             }
 
             // Evaluate Filters
-            dts = dts.Where(dt => dt.FilterExpressionMatches(j, dbContext, User, TimeStamp, DocumentState.DefaultState())).ToList();
+            dts = dts.Where(dt => dt.FilterExpressionMatches(j, Database, User, TimeStamp, DocumentState.DefaultState())).ToList();
 
             return dts;
         }
@@ -188,7 +188,7 @@ namespace Disco.BI.Extensions
             return d;
         }
 
-        public static string GenerateFaultDescription(this Job j, DiscoDataContext dbContext)
+        public static string GenerateFaultDescription(this Job j, DiscoDataContext Database)
         {
             StringBuilder sb = new StringBuilder();
 
@@ -199,14 +199,14 @@ namespace Disco.BI.Extensions
             return sb.ToString();
         }
 
-        public static string GenerateFaultDescriptionFooter(this Job j, DiscoDataContext dbContext, PluginFeatureManifest WarrantyProviderDefinition)
+        public static string GenerateFaultDescriptionFooter(this Job j, DiscoDataContext Database, PluginFeatureManifest WarrantyProviderDefinition)
         {
             var versionDisco = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
             return string.Format("Automation by Disco v{0}.{1}.{2:0000}.{3:0000} (Provider: {4} v{5})",
                 versionDisco.Major, versionDisco.Minor, versionDisco.Build, versionDisco.Revision, WarrantyProviderDefinition.Id, WarrantyProviderDefinition.PluginManifest.Version.ToString(4));
         }
 
-        public static void UpdateSubTypes(this Job j, DiscoDataContext dbContext, List<JobSubType> SubTypes, bool AddComponents, User TechUser)
+        public static void UpdateSubTypes(this Job j, DiscoDataContext Database, List<JobSubType> SubTypes, bool AddComponents, User TechUser)
         {
             if (SubTypes == null || SubTypes.Count == 0)
                 throw new ArgumentException("The Job must contain at least one Sub Type");
@@ -246,7 +246,7 @@ namespace Disco.BI.Extensions
                     foreach (var t in addedSubTypes)
                         logBuilder.Append("- ").AppendLine(t.ToString());
                 }
-                dbContext.JobLogs.Add(new JobLog()
+                Database.JobLogs.Add(new JobLog()
                 {
                     JobId = j.Id,
                     TechUserId = TechUser.Id,
@@ -258,7 +258,7 @@ namespace Disco.BI.Extensions
             // Add Components
             if (AddComponents && addedSubTypes.Count > 0 && j.DeviceSerialNumber != null)
             {
-                var components = dbContext.DeviceComponents.Include("JobSubTypes").Where(c => !c.DeviceModelId.HasValue || c.DeviceModelId == j.Device.DeviceModelId);
+                var components = Database.DeviceComponents.Include("JobSubTypes").Where(c => !c.DeviceModelId.HasValue || c.DeviceModelId == j.Device.DeviceModelId);
                 var addedComponents = new List<DeviceComponent>();
                 foreach (var c in components)
                 {
@@ -280,7 +280,7 @@ namespace Disco.BI.Extensions
                 {
                     if (!j.JobComponents.Any(jc => jc.Description.Equals(c.Description, StringComparison.InvariantCultureIgnoreCase)))
                     { // Job Component with matching Description doesn't exist.
-                        dbContext.JobComponents.Add(new JobComponent()
+                        Database.JobComponents.Add(new JobComponent()
                         {
                             Job = j,
                             TechUserId = TechUser.Id,

Disco.BI/BI/Extensions/JobFlagExtensions.cs

@@ -41,7 +41,7 @@ namespace Disco.BI.Extensions
 
             CacheAllFlags();
 
-            var currentFlags = j.Flags ?? 0;
+            var currentFlags = (long)(j.Flags ?? 0);
 
             foreach (var jt in j.JobSubTypes)
             {
@@ -63,7 +63,7 @@ namespace Disco.BI.Extensions
 
             CacheAllFlags();
 
-            var currentFlags = j.Flags ?? 0;
+            var currentFlags = (long)(j.Flags ?? 0);
 
             foreach (var jt in j.JobSubTypes)
             {

Disco.BI/BI/Extensions/JobTableExtensions.cs

@@ -5,16 +5,94 @@ using System.Text;
 using Disco.Models.BI.Job;
 using Disco.Models.Repository;
 using Disco.Data.Repository;
+using Disco.Services.Users;
+using Disco.Services.Authorization;
 
 namespace Disco.BI.Extensions
 {
     public static class JobTableExtensions
     {
+        private static List<string> FilterAllowedTypes(AuthorizationToken Authorization)
+        {
+            if (!Authorization.HasAll(Claims.Job.Types.ShowHMisc, Claims.Job.Types.ShowHNWar, Claims.Job.Types.ShowHWar, Claims.Job.Types.ShowSApp, Claims.Job.Types.ShowSImg, Claims.Job.Types.ShowSOS, Claims.Job.Types.ShowUMgmt))
+            {
+                // Must Filter
+                List<string> allowedTypes = new List<string>(6);
+                if (Authorization.Has(Claims.Job.Types.ShowHMisc))
+                    allowedTypes.Add(JobType.JobTypeIds.HMisc);
+                if (Authorization.Has(Claims.Job.Types.ShowHNWar))
+                    allowedTypes.Add(JobType.JobTypeIds.HNWar);
+                if (Authorization.Has(Claims.Job.Types.ShowHWar))
+                    allowedTypes.Add(JobType.JobTypeIds.HWar);
+                if (Authorization.Has(Claims.Job.Types.ShowSApp))
+                    allowedTypes.Add(JobType.JobTypeIds.SApp);
+                if (Authorization.Has(Claims.Job.Types.ShowSImg))
+                    allowedTypes.Add(JobType.JobTypeIds.SImg);
+                if (Authorization.Has(Claims.Job.Types.ShowSOS))
+                    allowedTypes.Add(JobType.JobTypeIds.SOS);
+                if (Authorization.Has(Claims.Job.Types.ShowUMgmt))
+                    allowedTypes.Add(JobType.JobTypeIds.UMgmt);
 
-        public static List<JobTableModel.JobTableItemModel> DetermineItems(this JobTableModel model, DiscoDataContext dbContext, IQueryable<Job> Jobs)
+                return allowedTypes;
+            }
+            return null;
+        }
+
+        public static IQueryable<Job> FilterPermissions(this JobTableModel model, IQueryable<Job> Jobs, AuthorizationToken Authorization)
+        {
+            var allowedTypes = FilterAllowedTypes(Authorization);
+
+            if (allowedTypes != null)
+            {
+                return Jobs.Where(j => allowedTypes.Contains(j.JobTypeId));
+            }
+
+            return Jobs;
+        }
+
+        public static List<JobTableModel.JobTableItemModel> PermissionsFiltered(this List<JobTableModel.JobTableItemModel> Items, AuthorizationToken Authorization)
+        {
+            if (Items != null && Items.Count > 0)
+            {
+                var allowedTypes = FilterAllowedTypes(Authorization);
+
+                if (allowedTypes != null)
+                {
+                    return Items.Where(j => allowedTypes.Contains(j.TypeId)).ToList();
+                }
+            }
+
+            return Items;
+        }
+
+        public static List<JobTableModel.JobTableItemModel> DetermineItems(this JobTableModel model, DiscoDataContext Database, IQueryable<Job> Jobs)
         {
             List<JobTableModel.JobTableItemModel> items;
 
+            // Permissions
+            var auth = UserService.CurrentAuthorization;
+            if (!auth.HasAll(Claims.Job.Types.ShowHMisc, Claims.Job.Types.ShowHNWar, Claims.Job.Types.ShowHWar, Claims.Job.Types.ShowSApp, Claims.Job.Types.ShowSImg, Claims.Job.Types.ShowSOS, Claims.Job.Types.ShowUMgmt))
+            {
+                // Must Filter
+                List<string> allowedTypes = new List<string>(6);
+                if (auth.Has(Claims.Job.Types.ShowHMisc))
+                    allowedTypes.Add(JobType.JobTypeIds.HMisc);
+                if (auth.Has(Claims.Job.Types.ShowHNWar))
+                    allowedTypes.Add(JobType.JobTypeIds.HNWar);
+                if (auth.Has(Claims.Job.Types.ShowHWar))
+                    allowedTypes.Add(JobType.JobTypeIds.HWar);
+                if (auth.Has(Claims.Job.Types.ShowSApp))
+                    allowedTypes.Add(JobType.JobTypeIds.SApp);
+                if (auth.Has(Claims.Job.Types.ShowSImg))
+                    allowedTypes.Add(JobType.JobTypeIds.SImg);
+                if (auth.Has(Claims.Job.Types.ShowSOS))
+                    allowedTypes.Add(JobType.JobTypeIds.SOS);
+                if (auth.Has(Claims.Job.Types.ShowUMgmt))
+                    allowedTypes.Add(JobType.JobTypeIds.UMgmt);
+
+                Jobs = Jobs.Where(j => allowedTypes.Contains(j.JobTypeId));
+            }
+
             if (model.ShowStatus)
             {
 
@@ -86,18 +164,18 @@ namespace Disco.BI.Extensions
             }
 
             if (!model.ShowDeviceAddress.HasValue)
-                model.ShowDeviceAddress = dbContext.DiscoConfiguration.MultiSiteMode;
+                model.ShowDeviceAddress = Database.DiscoConfiguration.MultiSiteMode;
 
             foreach (var j in items)
                 if (j.DeviceAddressId.HasValue)
-                    j.DeviceAddress = dbContext.DiscoConfiguration.OrganisationAddresses.GetAddress(j.DeviceAddressId.Value).Name;
+                    j.DeviceAddress = Database.DiscoConfiguration.OrganisationAddresses.GetAddress(j.DeviceAddressId.Value).Name;
 
             return items;
         }
 
-        public static void Fill(this JobTableModel model, DiscoDataContext dbContext, IQueryable<Job> Jobs)
+        public static void Fill(this JobTableModel model, DiscoDataContext Database, IQueryable<Job> Jobs)
         {
-            model.Items = model.DetermineItems(dbContext, Jobs);
+            model.Items = model.DetermineItems(Database, Jobs);
         }
     }
 }

Disco.BI/BI/Extensions/UserExtensions.cs

@@ -12,7 +12,7 @@ namespace Disco.BI.Extensions
 {
     public static class UserExtensions
     {
-        public static UserAttachment CreateAttachment(this User User, DiscoDataContext dbContext, User CreatorUser, string Filename, string MimeType, string Comments, Stream Content, DocumentTemplate DocumentTemplate = null, byte[] PdfThumbnail = null)
+        public static UserAttachment CreateAttachment(this User User, DiscoDataContext Database, User CreatorUser, string Filename, string MimeType, string Comments, Stream Content, DocumentTemplate DocumentTemplate = null, byte[] PdfThumbnail = null)
         {
             if (string.IsNullOrEmpty(MimeType) || MimeType.Equals("unknown/unknown", StringComparison.InvariantCultureIgnoreCase))
                 MimeType = Interop.MimeTypes.ResolveMimeType(Filename);
@@ -30,25 +30,25 @@ namespace Disco.BI.Extensions
             if (DocumentTemplate != null)
                 ua.DocumentTemplateId = DocumentTemplate.Id;
 
-            dbContext.UserAttachments.Add(ua);
-            dbContext.SaveChanges();
+            Database.UserAttachments.Add(ua);
+            Database.SaveChanges();
 
-            ua.SaveAttachment(dbContext, Content);
+            ua.SaveAttachment(Database, Content);
             Content.Position = 0;
             if (PdfThumbnail == null)
-                ua.GenerateThumbnail(dbContext, Content);
+                ua.GenerateThumbnail(Database, Content);
             else
-                ua.SaveThumbnailAttachment(dbContext, PdfThumbnail);
+                ua.SaveThumbnailAttachment(Database, PdfThumbnail);
 
             return ua;
         }
 
-        public static List<DocumentTemplate> AvailableDocumentTemplates(this User u, DiscoDataContext dbContext, User User, DateTime TimeStamp)
+        public static List<DocumentTemplate> AvailableDocumentTemplates(this User u, DiscoDataContext Database, User User, DateTime TimeStamp)
         {
-            var dts = dbContext.DocumentTemplates.Include("JobSubTypes")
+            var dts = Database.DocumentTemplates.Include("JobSubTypes")
                .Where(dt => dt.Scope == DocumentTemplate.DocumentTemplateScopes.User)
                .ToArray()
-               .Where(dt => dt.FilterExpressionMatches(u, dbContext, User, TimeStamp, DocumentState.DefaultState())).ToList();
+               .Where(dt => dt.FilterExpressionMatches(u, Database, User, TimeStamp, DocumentState.DefaultState())).ToList();
 
             return dts;
         }

Disco.BI/BI/Interop/ActiveDirectory/ActiveDirectory.cs

@@ -12,6 +12,17 @@ namespace Disco.BI.Interop.ActiveDirectory
 {
     public static class ActiveDirectory
     {
+        #region Machine Accounts
+
+        private static readonly string[] MachineLoadProperties = {
+                                                                     "name",
+                                                                     "distinguishedName",
+                                                                     "sAMAccountName",
+                                                                     "objectSid",
+                                                                     "dNSHostName",
+                                                                     "netbootGUID",
+                                                                     "isCriticalSystemObject"
+                                                                 };
         public static ActiveDirectoryMachineAccount GetMachineAccount(string ComputerName, System.Guid? UUIDNetbootGUID = null, System.Guid? MacAddressNetbootGUID = null, params string[] AdditionalProperties)
         {
             if (string.IsNullOrWhiteSpace(ComputerName))
@@ -26,36 +37,36 @@ namespace Disco.BI.Interop.ActiveDirectory
 
             using (DirectoryEntry dRootEntry = ActiveDirectoryHelpers.DefaultLdapRoot)
             {
-                var loadProperties = new List<string> { "name", "distinguishedName", "sAMAccountName", "objectSid", "dNSHostName", "netbootGUID", "isCriticalSystemObject" };
-                loadProperties.AddRange(AdditionalProperties);
-                using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectClass=computer)(sAMAccountName={0}))", ActiveDirectoryHelpers.EscapeLdapQuery(sAMAccountName)), loadProperties.ToArray(), SearchScope.Subtree))
+                var loadProperties = AdditionalProperties == null ? MachineLoadProperties : MachineLoadProperties.Concat(AdditionalProperties).ToArray();
+                
+                using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectCategory=computer)(sAMAccountName={0}))", ActiveDirectoryHelpers.EscapeLdapQuery(sAMAccountName)), loadProperties, SearchScope.Subtree))
                 {
                     SearchResult dResult = dSearcher.FindOne();
                     if (dResult != null)
                     {
-                        return ActiveDirectory.DirectorySearchResultToMachineAccount(dResult, AdditionalProperties);
+                        return ActiveDirectory.ActiveDirectoryMachineAccountFromSearchResult(dResult, AdditionalProperties);
                     }
                 }
 
                 if (UUIDNetbootGUID.HasValue)
                 {
-                    using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectClass=computer)(netbootGUID={0}))", ActiveDirectoryHelpers.FormatGuidForLdapQuery(UUIDNetbootGUID.Value)), loadProperties.ToArray(), SearchScope.Subtree))
+                    using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectCategory=computer)(netbootGUID={0}))", ActiveDirectoryHelpers.FormatGuidForLdapQuery(UUIDNetbootGUID.Value)), loadProperties, SearchScope.Subtree))
                     {
                         SearchResult dResult = dSearcher.FindOne();
                         if (dResult != null)
                         {
-                            return ActiveDirectory.DirectorySearchResultToMachineAccount(dResult, AdditionalProperties);
+                            return ActiveDirectory.ActiveDirectoryMachineAccountFromSearchResult(dResult, AdditionalProperties);
                         }
                     }
                 }
                 if (MacAddressNetbootGUID.HasValue)
                 {
-                    using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectClass=computer)(netbootGUID={0}))", ActiveDirectoryHelpers.FormatGuidForLdapQuery(MacAddressNetbootGUID.Value)), loadProperties.ToArray(), SearchScope.Subtree))
+                    using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectCategory=computer)(netbootGUID={0}))", ActiveDirectoryHelpers.FormatGuidForLdapQuery(MacAddressNetbootGUID.Value)), loadProperties, SearchScope.Subtree))
                     {
                         SearchResult dResult = dSearcher.FindOne();
                         if (dResult != null)
                         {
-                            return ActiveDirectory.DirectorySearchResultToMachineAccount(dResult, AdditionalProperties);
+                            return ActiveDirectory.ActiveDirectoryMachineAccountFromSearchResult(dResult, AdditionalProperties);
                         }
                     }
                 }
@@ -64,12 +75,12 @@ namespace Disco.BI.Interop.ActiveDirectory
 
             return null;
         }
-        private static ActiveDirectoryMachineAccount DirectorySearchResultToMachineAccount(SearchResult result, params string[] AdditionalProperties)
+        private static ActiveDirectoryMachineAccount ActiveDirectoryMachineAccountFromSearchResult(SearchResult result, params string[] AdditionalProperties)
         {
             string name = result.Properties["name"][0].ToString();
             string sAMAccountName = result.Properties["sAMAccountName"][0].ToString();
             string distinguishedName = result.Properties["distinguishedName"][0].ToString();
-            string objectSid = ActiveDirectoryHelpers.ConvertBytesToSIDString((byte[])result.Properties["objectSid"][0]);
+            string objectSid = ActiveDirectoryHelpers.ConvertBytesToSDDLString((byte[])result.Properties["objectSid"][0]);
 
             var dNSNameProperty = result.Properties["dNSHostName"];
             string dNSName = null;
@@ -89,21 +100,22 @@ namespace Disco.BI.Interop.ActiveDirectory
 
             // Additional Properties
             Dictionary<string, object[]> additionalProperties = new Dictionary<string, object[]>();
-            foreach (string propertyName in AdditionalProperties)
-            {
-                var property = result.Properties[propertyName];
-                var propertyValues = new List<object>();
-                for (int index = 0; index < property.Count; index++)
-                    propertyValues.Add(property[index]);
-                additionalProperties.Add(propertyName, propertyValues.ToArray());
-            }
+            if (AdditionalProperties != null)
+                foreach (string propertyName in AdditionalProperties)
+                {
+                    var property = result.Properties[propertyName];
+                    var propertyValues = new List<object>();
+                    for (int index = 0; index < property.Count; index++)
+                        propertyValues.Add(property[index]);
+                    additionalProperties.Add(propertyName, propertyValues.ToArray());
+                }
 
             return new ActiveDirectoryMachineAccount
             {
                 Name = name,
                 DistinguishedName = distinguishedName,
-                sAMAccountName = sAMAccountName,
-                ObjectSid = objectSid,
+                SamAccountName = sAMAccountName,
+                SecurityIdentifier = objectSid,
                 NetbootGUID = netbootGUIDResult,
                 Path = result.Path,
                 Domain = ActiveDirectoryHelpers.DefaultDomainNetBiosName,
@@ -112,127 +124,9 @@ namespace Disco.BI.Interop.ActiveDirectory
                 LoadedProperties = additionalProperties
             };
         }
-        private static ActiveDirectoryUserAccount SearchResultToActiveDirectoryUserAccount(SearchResult result, params string[] AdditionalProperties)
-        {
-            string name = result.Properties["name"][0].ToString();
-            string username = result.Properties["sAMAccountName"][0].ToString();
-            string distinguishedName = result.Properties["distinguishedName"][0].ToString();
-            string objectSid = ActiveDirectoryHelpers.ConvertBytesToSIDString((byte[])result.Properties["objectSid"][0]);
 
-            ResultPropertyValueCollection displayNameProp = result.Properties["displayName"];
-            string displayName = username;
-            if (displayNameProp.Count > 0)
-                displayName = displayNameProp[0].ToString();
-            string surname = null;
-            ResultPropertyValueCollection surnameProp = result.Properties["sn"];
-            if (surnameProp.Count > 0)
-                surname = surnameProp[0].ToString();
-            string givenName = null;
-            ResultPropertyValueCollection givenNameProp = result.Properties["givenName"];
-            if (givenNameProp.Count > 0)
-                givenName = givenNameProp[0].ToString();
-            string email = null;
-            ResultPropertyValueCollection emailProp = result.Properties["mail"];
-            if (emailProp.Count > 0)
-                email = emailProp[0].ToString();
-            string phone = null;
-            ResultPropertyValueCollection phoneProp = result.Properties["telephoneNumber"];
-            if (phoneProp.Count > 0)
-                phone = phoneProp[0].ToString();
+        #endregion
 
-            IEnumerable<string> groupCNs = result.Properties["memberOf"].Cast<string>();
-            List<string> groups = ActiveDirectoryCachedGroups.GetGroups(groupCNs).Select(g => g.ToLower()).ToList();
-
-            //foreach (string groupCN in result.Properties["memberOf"])
-            //{
-            // Removed 2012-11-30 G# - Moved to Recursive Cache
-            //var groupCNlower = groupCN.ToLower();
-            //if (groupCNlower.StartsWith("cn="))
-            //    groups.Add(groupCNlower.Substring(3, groupCNlower.IndexOf(",") - 3));
-            // End Removed 2012-11-30 G#
-            //}
-
-            string type = null;
-            if (groups.Contains("domain admins") || groups.Contains("disco admins"))
-            {
-                type = "Admin";
-            }
-            else
-            {
-                if (groups.Contains("staff"))
-                {
-                    type = "Staff";
-                }
-                else
-                {
-                    if (groups.Contains("students"))
-                    {
-                        type = "Student";
-                    }
-                }
-            }
-
-            // Additional Properties
-            Dictionary<string, object[]> additionalProperties = new Dictionary<string, object[]>();
-            foreach (string propertyName in AdditionalProperties)
-            {
-                var property = result.Properties[propertyName];
-                var propertyValues = new List<object>();
-                for (int index = 0; index < property.Count; index++)
-                    propertyValues.Add(property[index]);
-                additionalProperties.Add(propertyName, propertyValues.ToArray());
-            }
-
-            return new ActiveDirectoryUserAccount
-            {
-                Domain = ActiveDirectoryHelpers.DefaultDomainNetBiosName,
-                Name = name,
-                Surname = surname,
-                GivenName = givenName,
-                Email = email,
-                Phone = phone,
-                DistinguishedName = distinguishedName,
-                sAMAccountName = username,
-                DisplayName = displayName,
-                ObjectSid = objectSid,
-                Type = type,
-                Path = result.Path,
-                LoadedProperties = additionalProperties
-            };
-        }
-        public static ActiveDirectoryUserAccount GetUserAccount(string Username, params string[] AdditionalProperties)
-        {
-            if (string.IsNullOrWhiteSpace(Username))
-                throw new System.ArgumentException("Invalid User Account", "Username");
-            string sAMAccountName = Username;
-            if (sAMAccountName.Contains("\\"))
-                sAMAccountName = sAMAccountName.Substring(checked(sAMAccountName.IndexOf("\\") + 1));
-
-            using (DirectoryEntry dRootEntry = ActiveDirectoryHelpers.DefaultLdapRoot)
-            {
-                var loadProperties = new List<string> {
-                    "name", 
-					"distinguishedName", 
-					"sAMAccountName", 
-					"objectSid", 
-					"displayName", 
-					"sn", 
-					"givenName", 
-					"memberOf", 
-					"mail", 
-					"telephoneNumber"
-                };
-                loadProperties.AddRange(AdditionalProperties);
-                using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectClass=user)(sAMAccountName={0}))", ActiveDirectoryHelpers.EscapeLdapQuery(sAMAccountName)), loadProperties.ToArray(), SearchScope.Subtree))
-                {
-                    SearchResult dResult = dSearcher.FindOne();
-                    if (dResult != null)
-                        return ActiveDirectory.SearchResultToActiveDirectoryUserAccount(dResult, AdditionalProperties);
-                    else
-                        return null;
-                }
-            }
-        }
         public static string OfflineDomainJoinProvision(ref ActiveDirectoryMachineAccount ExistingAccount, string ComputerName, string OrganisationalUnit = null, string EnrolSessionId = null)
         {
             if (ExistingAccount != null && ExistingAccount.IsCriticalSystemObject)
@@ -318,6 +212,21 @@ namespace Disco.BI.Interop.ActiveDirectory
             return DJoinResult;
         }
 
+        #region Users
+
+        private static readonly string[] UserLoadProperties = {
+                                                                   "name", 
+                                                                   "distinguishedName", 
+                                                                   "sAMAccountName", 
+                                                                   "objectSid", 
+                                                                   "displayName", 
+                                                                   "sn", 
+                                                                   "givenName", 
+                                                                   "memberOf", 
+                                                                   "primaryGroupID",
+                                                                   "mail", 
+                                                                   "telephoneNumber"
+                                                               };
         public static List<ActiveDirectoryUserAccount> SearchUsers(string term)
         {
             List<ActiveDirectoryUserAccount> users = new List<ActiveDirectoryUserAccount>();
@@ -326,30 +235,118 @@ namespace Disco.BI.Interop.ActiveDirectory
             term = ActiveDirectoryHelpers.EscapeLdapQuery(term);
             using (DirectoryEntry entry = new DirectoryEntry(string.Format("LDAP://{0}", defaultQualifiedDomainName)))
             {
-                using (DirectorySearcher searcher = new DirectorySearcher(entry, string.Format("(&(objectClass=User)(objectCategory=Person)(|(sAMAccountName=*{0}*)(displayName=*{0}*)))", term), new string[]
-				{
-					"name", 
-					"distinguishedName", 
-					"sAMAccountName", 
-					"objectSid", 
-					"displayName", 
-					"sn", 
-					"givenName", 
-					"memberOf", 
-					"mail", 
-					"telephoneNumber"
-				}, SearchScope.Subtree))
+                using (DirectorySearcher searcher = new DirectorySearcher(entry, string.Format("(&(objectCategory=Person)(objectCategory=Person)(|(sAMAccountName=*{0}*)(displayName=*{0}*)))", term), UserLoadProperties, SearchScope.Subtree))
                 {
                     searcher.SizeLimit = 30;
                     SearchResultCollection results = searcher.FindAll();
                     foreach (SearchResult result in results)
                     {
-                        users.Add(ActiveDirectory.SearchResultToActiveDirectoryUserAccount(result));
+                        users.Add(ActiveDirectory.ActiveDirectoryUserAccountFromSearchResult(result));
                     }
                 }
             }
             return users;
         }
+        private static ActiveDirectoryUserAccount ActiveDirectoryUserAccountFromSearchResult(SearchResult result, params string[] AdditionalProperties)
+        {
+            string name = result.Properties["name"][0].ToString();
+            string username = result.Properties["sAMAccountName"][0].ToString();
+            string distinguishedName = result.Properties["distinguishedName"][0].ToString();
+            byte[] objectSid = (byte[])result.Properties["objectSid"][0];
+            string objectSidSDDL = ActiveDirectoryHelpers.ConvertBytesToSDDLString(objectSid);
+
+            ResultPropertyValueCollection displayNameProp = result.Properties["displayName"];
+            string displayName = username;
+            if (displayNameProp.Count > 0)
+                displayName = displayNameProp[0].ToString();
+            string surname = null;
+            ResultPropertyValueCollection surnameProp = result.Properties["sn"];
+            if (surnameProp.Count > 0)
+                surname = surnameProp[0].ToString();
+            string givenName = null;
+            ResultPropertyValueCollection givenNameProp = result.Properties["givenName"];
+            if (givenNameProp.Count > 0)
+                givenName = givenNameProp[0].ToString();
+            string email = null;
+            ResultPropertyValueCollection emailProp = result.Properties["mail"];
+            if (emailProp.Count > 0)
+                email = emailProp[0].ToString();
+            string phone = null;
+            ResultPropertyValueCollection phoneProp = result.Properties["telephoneNumber"];
+            if (phoneProp.Count > 0)
+                phone = phoneProp[0].ToString();
+
+            int primaryGroupID = (int)result.Properties["primaryGroupID"][0];
+            string primaryGroupSid = ActiveDirectoryHelpers.ConvertBytesToSDDLString(ActiveDirectoryHelpers.BuildPrimaryGroupSid(objectSid, primaryGroupID));
+            var groupDistinguishedNames = result.Properties["memberOf"].Cast<string>().ToList();
+            groupDistinguishedNames.Add(ActiveDirectoryCachedGroups.GetGroupsDistinguishedNameForSecurityIdentifier(primaryGroupSid));
+            List<string> groups = ActiveDirectoryCachedGroups.GetGroups(groupDistinguishedNames).ToList();
+
+            //foreach (string groupCN in result.Properties["memberOf"])
+            //{
+            // Removed 2012-11-30 G# - Moved to Recursive Cache
+            //var groupCNlower = groupCN.ToLower();
+            //if (groupCNlower.StartsWith("cn="))
+            //    groups.Add(groupCNlower.Substring(3, groupCNlower.IndexOf(",") - 3));
+            // End Removed 2012-11-30 G#
+            //}
+
+            // Additional Properties
+            Dictionary<string, object[]> additionalProperties = new Dictionary<string, object[]>();
+            if (AdditionalProperties != null)
+                foreach (string propertyName in AdditionalProperties)
+                {
+                    var property = result.Properties[propertyName];
+                    var propertyValues = new List<object>();
+                    for (int index = 0; index < property.Count; index++)
+                        propertyValues.Add(property[index]);
+                    additionalProperties.Add(propertyName, propertyValues.ToArray());
+                }
+
+            return new ActiveDirectoryUserAccount
+            {
+                Domain = ActiveDirectoryHelpers.DefaultDomainNetBiosName,
+                Name = name,
+                Surname = surname,
+                GivenName = givenName,
+                Email = email,
+                Phone = phone,
+                DistinguishedName = distinguishedName,
+                SamAccountName = username,
+                DisplayName = displayName,
+                SecurityIdentifier = objectSidSDDL,
+                Groups = groups,
+                Path = result.Path,
+                LoadedProperties = additionalProperties
+            };
+        }
+        public static ActiveDirectoryUserAccount GetUserAccount(string Username, params string[] AdditionalProperties)
+        {
+            if (string.IsNullOrWhiteSpace(Username))
+                throw new System.ArgumentException("Invalid User Account", "Username");
+            string sAMAccountName = Username;
+            if (sAMAccountName.Contains("\\"))
+                sAMAccountName = sAMAccountName.Substring(checked(sAMAccountName.IndexOf("\\") + 1));
+
+            using (DirectoryEntry dRootEntry = ActiveDirectoryHelpers.DefaultLdapRoot)
+            {
+                var loadProperties = AdditionalProperties == null ? UserLoadProperties : UserLoadProperties.Concat(AdditionalProperties).ToArray();
+
+                using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectCategory=Person)(sAMAccountName={0}))", ActiveDirectoryHelpers.EscapeLdapQuery(sAMAccountName)), loadProperties, SearchScope.Subtree))
+                {
+                    SearchResult dResult = dSearcher.FindOne();
+                    if (dResult != null)
+                        return ActiveDirectory.ActiveDirectoryUserAccountFromSearchResult(dResult, AdditionalProperties);
+                    else
+                        return null;
+                }
+            }
+        }
+
+        #endregion
+
+        #region Organisation Units
+
         public static List<ActiveDirectoryOrganisationalUnit> GetOrganisationalUnitStructure()
         {
             ActiveDirectoryOrganisationalUnit DomainOUs = new ActiveDirectoryOrganisationalUnit
@@ -393,5 +390,173 @@ namespace Disco.BI.Interop.ActiveDirectory
             }
 
         }
+
+        #endregion
+
+        #region Groups
+
+        private static readonly string[] GroupLoadProperties = {
+                                                                   "name", 
+                                                                   "distinguishedName", 
+                                                                   "cn", 
+                                                                   "sAMAccountName", 
+                                                                   "objectSid", 
+                                                                   "memberOf"
+                                                               };
+        public static ActiveDirectoryGroup GetGroup(string SamAccountName)
+        {
+            if (string.IsNullOrWhiteSpace(SamAccountName))
+                throw new System.ArgumentException("Invalid Group Account", "SamAccountName");
+            string sAMAccountName = SamAccountName;
+            if (sAMAccountName.Contains("\\"))
+                sAMAccountName = sAMAccountName.Substring(checked(sAMAccountName.IndexOf("\\") + 1));
+
+            using (DirectoryEntry dRootEntry = ActiveDirectoryHelpers.DefaultLdapRoot)
+            {
+                using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectCategory=Group)(objectSid={0}))", ActiveDirectoryHelpers.EscapeLdapQuery(sAMAccountName)), GroupLoadProperties, SearchScope.Subtree))
+                {
+                    SearchResult dResult = dSearcher.FindOne();
+                    if (dResult != null)
+                    {
+                        return ActiveDirectoryGroupFromSearchResult(dResult);
+                    }
+                    else
+                        return null;
+                }
+            }
+        }
+        public static ActiveDirectoryGroup GetGroupFromDistinguishedName(string DistinguishedName)
+        {
+            ActiveDirectoryGroup group = null;
+
+            using (DirectoryEntry groupDE = new DirectoryEntry(string.Concat(ActiveDirectoryHelpers.DefaultLdapPath, DistinguishedName)))
+            {
+                if (groupDE != null)
+                {
+                    return ActiveDirectoryGroupFromDirectoryEntry(groupDE);
+                }
+            }
+
+            return group;
+        }
+        public static ActiveDirectoryGroup GetGroupFromSecurityIdentifier(string SecurityIdentifier)
+        {
+            using (DirectoryEntry dRootEntry = ActiveDirectoryHelpers.DefaultLdapRoot)
+            {
+                var sidBytes = ActiveDirectoryHelpers.ConvertSDDLStringToBytes(SecurityIdentifier);
+                var sidBinaryString = ActiveDirectoryHelpers.ConvertBytesToBinarySidString(sidBytes);
+
+                using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectCategory=Group)(objectSid={0}))", sidBinaryString), GroupLoadProperties, SearchScope.Subtree))
+                {
+                    SearchResult dResult = dSearcher.FindOne();
+                    if (dResult != null)
+                    {
+                        return ActiveDirectoryGroupFromSearchResult(dResult);
+                    }
+                    else
+                        return null;
+                }
+            }
+        }
+
+        public static List<ActiveDirectoryGroup> SearchGroups(string term)
+        {
+            List<ActiveDirectoryGroup> results = new List<ActiveDirectoryGroup>();
+            string defaultQualifiedDomainName = ActiveDirectoryHelpers.DefaultDomainQualifiedName;
+            string defaultNetBiosDomainName = ActiveDirectoryHelpers.DefaultDomainNetBiosName;
+            term = ActiveDirectoryHelpers.EscapeLdapQuery(term);
+            using (DirectoryEntry entry = new DirectoryEntry(string.Format("LDAP://{0}", defaultQualifiedDomainName)))
+            {
+                using (DirectorySearcher searcher = new DirectorySearcher(entry, string.Format("(&(objectCategory=Group)(|(sAMAccountName=*{0}*)(name=*{0}*)(cn=*{0}*)))", term), GroupLoadProperties, SearchScope.Subtree))
+                {
+                    searcher.SizeLimit = 30;
+                    SearchResultCollection searchResults = searcher.FindAll();
+                    foreach (SearchResult result in searchResults)
+                    {
+                        results.Add(ActiveDirectory.ActiveDirectoryGroupFromSearchResult(result));
+                    }
+                }
+            }
+            return results;
+        }
+
+        private static ActiveDirectoryGroup ActiveDirectoryGroupFromDirectoryEntry(DirectoryEntry entry)
+        {
+            var name = (string)entry.Properties["name"].Value;
+            var distinguishedName = (string)entry.Properties["distinguishedName"].Value;
+            var cn = (string)entry.Properties["cn"].Value;
+            var sAMAccountName = (string)entry.Properties["sAMAccountName"].Value;
+            var objectSid = ActiveDirectoryHelpers.ConvertBytesToSDDLString((byte[])entry.Properties["objectSid"].Value);
+            var memberOf = entry.Properties["memberOf"].Cast<string>().ToList();
+
+            return new ActiveDirectoryGroup()
+            {
+                Name = name,
+                DistinguishedName = distinguishedName,
+                CommonName = cn,
+                SamAccountName = sAMAccountName,
+                SecurityIdentifier = objectSid,
+                MemberOf = memberOf
+            };
+        }
+        private static ActiveDirectoryGroup ActiveDirectoryGroupFromSearchResult(SearchResult result)
+        {
+            var name = (string)result.Properties["name"][0];
+            var distinguishedName = (string)result.Properties["distinguishedName"][0];
+            var cn = (string)result.Properties["cn"][0];
+            var sAMAccountName = (string)result.Properties["sAMAccountName"][0];
+            var objectSid = ActiveDirectoryHelpers.ConvertBytesToSDDLString((byte[])result.Properties["objectSid"][0]);
+            var memberOf = result.Properties["memberOf"].Cast<string>().ToList();
+
+            return new ActiveDirectoryGroup()
+            {
+                Name = name,
+                DistinguishedName = distinguishedName,
+                CommonName = cn,
+                SamAccountName = sAMAccountName,
+                SecurityIdentifier = objectSid,
+                MemberOf = memberOf
+            };
+        }
+
+        #endregion
+
+        private static readonly string[] ObjectLoadProperties = { "objectCategory" };
+        private static readonly string[] ObjectLoadPropertiesAll = ObjectLoadProperties.Concat(UserLoadProperties).Concat(MachineLoadProperties).Concat(GroupLoadProperties).Distinct().ToArray();
+
+        public static IActiveDirectoryObject GetObject(string SamAccountName)
+        {
+            if (string.IsNullOrWhiteSpace(SamAccountName))
+                throw new System.ArgumentException("Invalid Object Account Name", "SamAccountName");
+            string sAMAccountName = SamAccountName;
+            if (sAMAccountName.Contains("\\"))
+                sAMAccountName = sAMAccountName.Substring(checked(sAMAccountName.IndexOf("\\") + 1));
+
+            using (DirectoryEntry dRootEntry = ActiveDirectoryHelpers.DefaultLdapRoot)
+            {
+                using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(|(objectCategory=Person)(objectCategory=Computer)(objectCategory=Group))(sAMAccountName={0}))", ActiveDirectoryHelpers.EscapeLdapQuery(sAMAccountName)), ObjectLoadPropertiesAll, SearchScope.Subtree))
+                {
+                    SearchResult dResult = dSearcher.FindOne();
+                    if (dResult != null)
+                    {
+                        var objectCategory = (string)dResult.Properties["objectCategory"][0];
+                        objectCategory = objectCategory.Substring(0, objectCategory.IndexOf(',')).ToLower();
+                        switch (objectCategory)
+                        {
+                            case "cn=person":
+                                return ActiveDirectoryUserAccountFromSearchResult(dResult);
+                            case "cn=computer":
+                                return ActiveDirectoryMachineAccountFromSearchResult(dResult);
+                            case "cn=group":
+                                return ActiveDirectoryGroupFromSearchResult(dResult);
+                            default:
+                                throw new InvalidOperationException("Unexpected objectCategory");
+                        }
+                    }
+                    else
+                        return null;
+                }
+            }
+        }
     }
 }

Disco.BI/BI/Interop/ActiveDirectory/ActiveDirectoryCachedGroups.cs

@@ -8,34 +8,44 @@ using System.Threading.Tasks;
 using Disco.Data.Repository;
 using Disco.Services.Tasks;
 using Quartz;
+using Disco.Models.Interop.ActiveDirectory;
 
 namespace Disco.BI.Interop.ActiveDirectory
 {
     public class ActiveDirectoryCachedGroups : ScheduledTask
     {
-        private static ConcurrentDictionary<string, Tuple<ADCachedGroup, DateTime>> _Cache = new ConcurrentDictionary<string, Tuple<ADCachedGroup, DateTime>>();
+        private static ConcurrentDictionary<string, Tuple<ActiveDirectoryGroup, DateTime>> _SecurityIdentifierCache = new ConcurrentDictionary<string, Tuple<ActiveDirectoryGroup, DateTime>>();
+        private static ConcurrentDictionary<string, Tuple<ActiveDirectoryGroup, DateTime>> _DistinguishedNameCache = new ConcurrentDictionary<string, Tuple<ActiveDirectoryGroup, DateTime>>();
         private const long CacheTimeoutTicks = 6000000000; // 10 Minutes
 
-        public static IEnumerable<string> GetGroups(IEnumerable<string> GroupCNs)
+        public static IEnumerable<string> GetGroups(IEnumerable<string> DistinguishedNames)
         {
-            List<ADCachedGroup> groups = new List<ADCachedGroup>();
+            List<ActiveDirectoryGroup> groups = new List<ActiveDirectoryGroup>();
 
-            foreach (var groupCN in GroupCNs)
-                foreach (var group in GetGroupsRecursive(groupCN, new Stack<ADCachedGroup>()))
+            foreach (var distinguishedName in DistinguishedNames)
+                foreach (var group in GetGroupsRecursive(distinguishedName, new Stack<ActiveDirectoryGroup>()))
                     if (!groups.Contains(group))
                     {
                         groups.Add(group);
-                        yield return group.FriendlyName;
+                        yield return group.SamAccountName;
                     }
         }
-        public static IEnumerable<string> GetGroups(string GroupCN)
+        public static IEnumerable<string> GetGroups(string DistinguishedName)
         {
-            foreach (var group in GetGroupsRecursive(GroupCN, new Stack<ADCachedGroup>()))
-                yield return group.FriendlyName;
+            foreach (var group in GetGroupsRecursive(DistinguishedName, new Stack<ActiveDirectoryGroup>()))
+                yield return group.SamAccountName;
         }
-        private static IEnumerable<ADCachedGroup> GetGroupsRecursive(string GroupCN, Stack<ADCachedGroup> RecursiveTree)
+        public static string GetGroupsDistinguishedNameForSecurityIdentifier(string SecurityIdentifier)
         {
-            var group = GetGroup(GroupCN);
+            var group = GetGroupBySecurityIdentifier(SecurityIdentifier);
+            if (group == null)
+                return null;
+            else
+                return group.DistinguishedName;
+        }
+        private static IEnumerable<ActiveDirectoryGroup> GetGroupsRecursive(string DistinguishedName, Stack<ActiveDirectoryGroup> RecursiveTree)
+        {
+            var group = GetGroup(DistinguishedName);
 
             if (group != null && !RecursiveTree.Contains(group))
             {
@@ -45,25 +55,44 @@ namespace Disco.BI.Interop.ActiveDirectory
                 {
                     RecursiveTree.Push(group);
 
-                    foreach (var memberOfGroupCN in group.MemberOf)
-                        foreach (var memberOfGroup in GetGroupsRecursive(memberOfGroupCN, RecursiveTree))
-                            yield return memberOfGroup;
+                    foreach (var parentDistinguishedName in group.MemberOf)
+                        foreach (var parentGroup in GetGroupsRecursive(parentDistinguishedName, RecursiveTree))
+                            yield return parentGroup;
 
                     RecursiveTree.Pop();
                 }
             }
         }
 
-        private static ADCachedGroup GetGroup(string GroupCN)
+        private static ActiveDirectoryGroup GetGroup(string DistinguishedName)
         {
             // Check Cache
-            Tuple<ADCachedGroup, DateTime> groupRecord = TryCache(GroupCN);
+            Tuple<ActiveDirectoryGroup, DateTime> groupRecord = TryCache(DistinguishedName);
 
             if (groupRecord == null)
             {
                 // Load from AD
-                var group = ADCachedGroup.LoadFromAD(GroupCN);
-                SetValue(GroupCN, group);
+                var group = ActiveDirectory.GetGroupFromDistinguishedName(DistinguishedName);
+                SetValue(group);
+
+                return group;
+            }
+            else
+            {
+                // Return from Cache
+                return groupRecord.Item1;
+            }
+        }
+        private static ActiveDirectoryGroup GetGroupBySecurityIdentifier(string SecurityIdentifier)
+        {
+            // Check Cache
+            Tuple<ActiveDirectoryGroup, DateTime> groupRecord = TrySecurityIdentifierCache(SecurityIdentifier);
+
+            if (groupRecord == null)
+            {
+                // Load from AD
+                var group = ActiveDirectory.GetGroupFromSecurityIdentifier(SecurityIdentifier);
+                SetValue(group);
 
                 return group;
             }
@@ -74,83 +103,97 @@ namespace Disco.BI.Interop.ActiveDirectory
             }
         }
 
-        private static Tuple<ADCachedGroup, DateTime> TryCache(string GroupCN)
+        private static Tuple<ActiveDirectoryGroup, DateTime> TryCache(string DistinguishedName)
         {
-            string groupCN = GroupCN.ToLower();
-            Tuple<ADCachedGroup, DateTime> groupRecord;
-            if (_Cache.TryGetValue(groupCN, out groupRecord))
+            string distinguishedName = DistinguishedName.ToLower();
+            Tuple<ActiveDirectoryGroup, DateTime> groupRecord;
+            if (_DistinguishedNameCache.TryGetValue(distinguishedName, out groupRecord))
             {
                 if (groupRecord.Item2 > DateTime.Now)
                     return groupRecord;
                 else
-                    _Cache.TryRemove(groupCN, out groupRecord);
+                {
+                    if (_DistinguishedNameCache.TryRemove(distinguishedName, out groupRecord))
+                        _SecurityIdentifierCache.TryRemove(groupRecord.Item1.SecurityIdentifier, out groupRecord);
+                }
             }
             return null;
         }
-        private static bool SetValue(string GroupCN, ADCachedGroup GroupRecord)
+        private static Tuple<ActiveDirectoryGroup, DateTime> TrySecurityIdentifierCache(string SecurityIdentifier)
         {
-            string key = GroupCN.ToLower();
-            Tuple<ADCachedGroup, DateTime> groupRecord = new Tuple<ADCachedGroup, DateTime>(GroupRecord, DateTime.Now.AddTicks(CacheTimeoutTicks));
-            if (_Cache.ContainsKey(key))
+            Tuple<ActiveDirectoryGroup, DateTime> groupRecord;
+            if (_SecurityIdentifierCache.TryGetValue(SecurityIdentifier, out groupRecord))
             {
-                Tuple<ADCachedGroup, DateTime> oldGroupRecord;
-                if (_Cache.TryGetValue(key, out oldGroupRecord))
+                if (groupRecord.Item2 > DateTime.Now)
+                    return groupRecord;
+                else
                 {
-                    return _Cache.TryUpdate(key, groupRecord, oldGroupRecord);
+                    if (_SecurityIdentifierCache.TryRemove(SecurityIdentifier, out groupRecord))
+                        _DistinguishedNameCache.TryRemove(groupRecord.Item1.DistinguishedName.ToLower(), out groupRecord);
                 }
             }
-            return _Cache.TryAdd(key, groupRecord);
+            return null;
         }
-
-        private class ADCachedGroup
+        private static bool SetValue(ActiveDirectoryGroup Group)
         {
-            public string CN { get; private set; }
-            public string FriendlyName { get; private set; }
+            Tuple<ActiveDirectoryGroup, DateTime> groupRecord = new Tuple<ActiveDirectoryGroup, DateTime>(Group, DateTime.Now.AddTicks(CacheTimeoutTicks));
+            Tuple<ActiveDirectoryGroup, DateTime> oldGroupRecord;
 
-            public List<string> MemberOf { get; private set; }
-
-            public static ADCachedGroup LoadFromAD(string CN)
+            string key = Group.DistinguishedName.ToLower();
+            if (_DistinguishedNameCache.ContainsKey(key))
             {
-                ADCachedGroup group = null;
-
-                using (DirectoryEntry groupDE = new DirectoryEntry(string.Concat(ActiveDirectoryHelpers.DefaultLdapPath, CN)))
+                if (_DistinguishedNameCache.TryGetValue(key, out oldGroupRecord))
                 {
-                    if (groupDE != null)
-                    {
-                        group = new ADCachedGroup()
-                        {
-                            CN = CN
-                        };
-
-                        group.FriendlyName = (string)groupDE.Properties["sAMAccountName"].Value;
-
-                        var groupMemberOf = groupDE.Properties["memberOf"];
-                        if (groupMemberOf != null && groupMemberOf.Count > 0)
-                        {
-                            group.MemberOf = groupMemberOf.Cast<string>().ToList();
-                        }
-                    }
+                    _DistinguishedNameCache.TryUpdate(key, groupRecord, oldGroupRecord);
                 }
-
-                return group;
             }
-
-            private ADCachedGroup()
+            else
             {
-                // Private Constructor
+                _DistinguishedNameCache.TryAdd(key, groupRecord);
             }
+
+            string securityIdentifier = Group.SecurityIdentifier;
+            if (_SecurityIdentifierCache.ContainsKey(securityIdentifier))
+            {
+                if (_SecurityIdentifierCache.TryGetValue(securityIdentifier, out oldGroupRecord))
+                {
+                    _SecurityIdentifierCache.TryUpdate(securityIdentifier, groupRecord, oldGroupRecord);
+                }
+            }
+            else
+            {
+                _SecurityIdentifierCache.TryAdd(securityIdentifier, groupRecord);
+            }
+            return true;
         }
 
         private static void CleanStaleCache()
         {
-            var groupKeys = _Cache.Keys.ToArray();
+            // Clean Cache
+            var groupKeys = _DistinguishedNameCache.Keys.ToArray();
             foreach (string groupKey in groupKeys)
             {
-                Tuple<ADCachedGroup, DateTime> groupRecord;
-                if (_Cache.TryGetValue(groupKey, out groupRecord))
+                Tuple<ActiveDirectoryGroup, DateTime> groupRecord;
+                if (_DistinguishedNameCache.TryGetValue(groupKey, out groupRecord))
                 {
                     if (groupRecord.Item2 <= DateTime.Now)
-                        _Cache.TryRemove(groupKey, out groupRecord);
+                    {
+                        _DistinguishedNameCache.TryRemove(groupKey, out groupRecord);
+                    }
+                }
+            }
+
+            // Clean SID Cache
+            groupKeys = _SecurityIdentifierCache.Keys.ToArray();
+            foreach (string groupKey in groupKeys)
+            {
+                Tuple<ActiveDirectoryGroup, DateTime> groupRecord;
+                if (_SecurityIdentifierCache.TryGetValue(groupKey, out groupRecord))
+                {
+                    if (groupRecord.Item2 <= DateTime.Now)
+                    {
+                        _SecurityIdentifierCache.TryRemove(groupKey, out groupRecord);
+                    }
                 }
             }
         }
@@ -161,7 +204,7 @@ namespace Disco.BI.Interop.ActiveDirectory
         public override bool CancelInitiallySupported { get { return false; } }
         public override bool LogExceptionsOnly { get { return true; } }
 
-        public override void InitalizeScheduledTask(DiscoDataContext dbContext)
+        public override void InitalizeScheduledTask(DiscoDataContext Database)
         {
             // Run @ every 15mins
 

Disco.BI/BI/Interop/ActiveDirectory/ActiveDirectoryGroupExtensions.cs

@@ -0,0 +1,19 @@
+using Disco.Models.Interop.ActiveDirectory;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Disco.BI.Interop.ActiveDirectory
+{
+    public static class ActiveDirectoryGroupExtensions
+    {
+
+        public static IEnumerable<Tuple<string, string>> GetMembers(ActiveDirectoryGroup group)
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}

Disco.BI/BI/Interop/ActiveDirectory/ActiveDirectoryHelpers.cs

@@ -5,6 +5,7 @@ using System.DirectoryServices;
 using System.DirectoryServices.ActiveDirectory;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Security.Principal;
 using System.Text;
 using System.Threading;
 
@@ -128,22 +129,50 @@ namespace Disco.BI.Interop.ActiveDirectory
         }
         #endregion
 
-        [System.Runtime.InteropServices.DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
-        private static extern bool ConvertSidToStringSid(byte[] pSID, ref System.Text.StringBuilder ptrSid);
-        internal static string ConvertBytesToSIDString(byte[] SID)
+        internal static string ConvertBytesToSDDLString(byte[] SID)
         {
-            System.Text.StringBuilder sidString = new System.Text.StringBuilder();
-            bool flag = ActiveDirectoryHelpers.ConvertSidToStringSid(SID, ref sidString);
-            string ConvertBytesToSIDString;
-            if (flag)
+            SecurityIdentifier sID = new SecurityIdentifier(SID, 0);
+
+            return sID.ToString();
+        }
+
+        internal static byte[] ConvertSDDLStringToBytes(string SidSsdlString)
+        {
+            SecurityIdentifier sID = new SecurityIdentifier(SidSsdlString);
+
+            var sidBytes = new byte[sID.BinaryLength];
+
+            sID.GetBinaryForm(sidBytes, 0);
+
+            return sidBytes;
+        }
+
+        internal static byte[] BuildPrimaryGroupSid(byte[] UserSID, int PrimaryGroupId)
+        {
+            var groupSid = (byte[])UserSID.Clone();
+
+            int ridOffset = groupSid.Length - 4;
+            int groupId = PrimaryGroupId;
+            for (int i = 0; i < 4; i++)
             {
-                ConvertBytesToSIDString = sidString.ToString();
+                groupSid[ridOffset + i] = (byte)(groupId & 0xFF);
+                groupId >>= 8;
             }
-            else
+
+            return groupSid;
+        }
+
+        internal static string ConvertBytesToBinarySidString(byte[] SID)
+        {
+            StringBuilder escapedSid = new StringBuilder();
+
+            foreach (var sidByte in SID)
             {
-                ConvertBytesToSIDString = null;
+                escapedSid.Append('\\');
+                escapedSid.Append(sidByte.ToString("x2"));
             }
-            return ConvertBytesToSIDString;
+
+            return escapedSid.ToString();
         }
 
         internal static string EscapeLdapQuery(string query)

Disco.BI/BI/Interop/ActiveDirectory/ActiveDirectoryMachineAccountExtensions.cs

@@ -191,11 +191,11 @@ namespace Disco.BI.Interop.ActiveDirectory
                 case "name":
                     return account.Name;
                 case "samaccountname":
-                    return account.sAMAccountName;
+                    return account.SamAccountName;
                 case "distinguishedname":
                     return account.DistinguishedName;
                 case "objectsid":
-                    return account.ObjectSid;
+                    return account.SecurityIdentifier;
                 case "netbootguid":
                     return account.NetbootGUID;
                 default:
@@ -268,7 +268,9 @@ namespace Disco.BI.Interop.ActiveDirectory
             if (account.IsCriticalSystemObject)
                 throw new InvalidOperationException(string.Format("This account {0} is a Critical System Active Directory Object and Disco refuses to modify it", account.DistinguishedName));
 
-            if (!account.ParentDistinguishedName.Equals(NewOrganisationUnit, StringComparison.InvariantCultureIgnoreCase))
+            var parentDistinguishedName = account.ParentDistinguishedName();
+
+            if (parentDistinguishedName != null && !parentDistinguishedName.Equals(NewOrganisationUnit, StringComparison.InvariantCultureIgnoreCase))
             {
                 string ouPath;
                 if (string.IsNullOrWhiteSpace(NewOrganisationUnit))
@@ -286,5 +288,14 @@ namespace Disco.BI.Interop.ActiveDirectory
             }
         }
 
+        public static string ParentDistinguishedName(this ActiveDirectoryMachineAccount account)
+        {
+            // Determine Parent
+            if (!string.IsNullOrWhiteSpace(account.DistinguishedName))
+                return account.DistinguishedName.Substring(0, account.DistinguishedName.IndexOf(",DC=")).Substring(account.DistinguishedName.IndexOf(",") + 1);
+            else
+                return null;
+        }
+
     }
 }

Disco.BI/BI/Interop/ActiveDirectory/ActiveDirectoryUpdateLastNetworkLogonDateJob.cs

@@ -21,7 +21,7 @@ namespace Disco.BI.Interop.ActiveDirectory
         public override bool SingleInstanceTask { get { return true; } }
         public override bool CancelInitiallySupported { get { return false; } }
 
-        public override void InitalizeScheduledTask(DiscoDataContext dbContext)
+        public override void InitalizeScheduledTask(DiscoDataContext Database)
         {
             // ActiveDirectoryUpdateLastNetworkLogonDateJob @ 11:30pm
             TriggerBuilder triggerBuilder = TriggerBuilder.Create().
@@ -35,11 +35,11 @@ namespace Disco.BI.Interop.ActiveDirectory
             int changeCount;
 
             this.Status.UpdateStatus(1, "Starting", "Connecting to the Database and initializing the environment");
-            using (DiscoDataContext dbContext = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
-                UpdateLastNetworkLogonDates(dbContext, this.Status);
+                UpdateLastNetworkLogonDates(database, this.Status);
                 this.Status.UpdateStatus(95, "Updating Database", "Writing last network logon dates to the Database");
-                changeCount = dbContext.SaveChanges();
+                changeCount = database.SaveChanges();
                 this.Status.Finished(string.Format("{0} Device last network logon dates updated", changeCount), "/Config/SystemConfig");
             }
 
@@ -86,7 +86,7 @@ namespace Disco.BI.Interop.ActiveDirectory
                         {
                             using (DirectoryEntry dRootEntry = ActiveDirectoryHelpers.DefaultDCLdapRoot(dcName))
                             {
-                                DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectClass=computer)(sAMAccountName={0}$))", ActiveDirectoryHelpers.EscapeLdapQuery(Device.ComputerName)), new string[]
+                                DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, string.Format("(&(objectCategory=Computer)(sAMAccountName={0}$))", ActiveDirectoryHelpers.EscapeLdapQuery(Device.ComputerName)), new string[]
 									{
 										"lastLogon"
 									}, SearchScope.Subtree);
@@ -150,7 +150,7 @@ namespace Disco.BI.Interop.ActiveDirectory
             UpdateLastNetworkLogonDate = false;
             return UpdateLastNetworkLogonDate;
         }
-        private static void UpdateLastNetworkLogonDates(DiscoDataContext context, ScheduledTaskStatus status)
+        private static void UpdateLastNetworkLogonDates(DiscoDataContext Database, ScheduledTaskStatus status)
         {
             System.Collections.Generic.Dictionary<string, System.DateTime> computerLastLogonDates = new System.Collections.Generic.Dictionary<string, System.DateTime>();
 
@@ -176,7 +176,7 @@ namespace Disco.BI.Interop.ActiveDirectory
                             double progressDCStart = 5 + (progressDCCount * progressDCProgress);
                             status.UpdateStatus(progressDCStart, string.Format("Querying Domain Controller: {0}", dcName), "Searching...");
 
-                            using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, "(objectClass=computer)", new string[] { "sAMAccountName", "lastLogon" }, SearchScope.Subtree))
+                            using (DirectorySearcher dSearcher = new DirectorySearcher(dRootEntry, "(objectCategory=Computer)", new string[] { "sAMAccountName", "lastLogon" }, SearchScope.Subtree))
                             {
                                 using (SearchResultCollection dResults = dSearcher.FindAll())
                                 {
@@ -238,7 +238,7 @@ namespace Disco.BI.Interop.ActiveDirectory
             }
 
 
-            foreach (Device d in context.Devices.Where(device => device.ComputerName != null))
+            foreach (Device d in Database.Devices.Where(device => device.ComputerName != null))
             {
                 DateTime computerLastLogonDate;
                 if (computerLastLogonDates.TryGetValue(d.ComputerName.ToUpper(), out computerLastLogonDate))

Disco.BI/BI/Interop/ActiveDirectory/ActiveDirectoryUserAccountExtensions.cs

@@ -5,11 +5,6 @@ namespace Disco.BI.Interop.ActiveDirectory
 {
     internal static class ActiveDirectoryUserAccountExtensions
     {
-        public static bool HasRole(this ActiveDirectoryUserAccount account, string Role)
-        {
-            return account.Groups != null && account.Groups.Contains(Role.ToLower());
-        }
-
         public static object GetPropertyValue(this ActiveDirectoryUserAccount account, string PropertyName, int Index = 0)
         {
             switch (PropertyName.ToLower())
@@ -17,11 +12,11 @@ namespace Disco.BI.Interop.ActiveDirectory
                 case "name":
                     return account.Name;
                 case "samaccountname":
-                    return account.sAMAccountName;
+                    return account.SamAccountName;
                 case "distinguishedname":
                     return account.DistinguishedName;
                 case "objectsid":
-                    return account.ObjectSid;
+                    return account.SecurityIdentifier;
                 case "sn":
                     return account.Surname;
                 case "givenname":

Disco.BI/BI/Interop/Community/UpdateCheck.cs

@@ -1,16 +1,14 @@
-using System;
+using Disco.Data.Repository;
+using Disco.Models.BI.Interop.Community;
+using Disco.Models.Repository;
+using Disco.Services.Tasks;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net;
-using System.Text;
-using System.Threading.Tasks;
 using System.Xml.Linq;
 using System.Xml.Serialization;
-using Disco.Data.Repository;
-using Disco.Models.BI.Interop.Community;
-using Disco.Services.Tasks;
-using Newtonsoft.Json;
 
 namespace Disco.BI.Interop.Community
 {
@@ -31,12 +29,12 @@ namespace Disco.BI.Interop.Community
             return string.Format("{0}.{1}.{2:0000}.{3:0000}", v.Major, v.Minor, v.Build, v.Revision);
         }
 
-        public static UpdateResponse Check(DiscoDataContext db, bool UseProxy, ScheduledTaskStatus status = null)
+        public static UpdateResponse Check(DiscoDataContext Database, bool UseProxy, ScheduledTaskStatus status = null)
         {
             if (status != null)
                 status.UpdateStatus(10, "Building Update Request");
 
-            var request = BuildRequest(db);
+            var request = BuildRequest(Database);
             //var requestJson = JsonConvert.SerializeObject(request);
 
             if (status != null)
@@ -78,8 +76,8 @@ namespace Disco.BI.Interop.Community
                         result = (UpdateResponse)xml.Deserialize(wResStream);
                     }
                     //var result = JsonConvert.DeserializeObject<UpdateResponse>(responseContent);
-                    db.DiscoConfiguration.UpdateLastCheck = result;
-                    db.SaveChanges();
+                    Database.DiscoConfiguration.UpdateLastCheck = result;
+                    Database.SaveChanges();
 
                     status.SetFinishedMessage(string.Format("The update server reported Version {0} is the latest.", result.Version));
 
@@ -94,23 +92,31 @@ namespace Disco.BI.Interop.Community
             }
         }
 
-        private static UpdateRequestV1 BuildRequest(DiscoDataContext db)
+        private static UpdateRequestV1 BuildRequest(DiscoDataContext Database)
         {
             var m = new UpdateRequestV1();
 
-            m.DeploymentId = db.DiscoConfiguration.DeploymentId;
+            m.DeploymentId = Database.DiscoConfiguration.DeploymentId;
 
             m.CurrentDiscoVersion = CurrentDiscoVersionFormatted();
 
-            m.OrganisationName = db.DiscoConfiguration.OrganisationName;
+            m.OrganisationName = Database.DiscoConfiguration.OrganisationName;
             m.BroadbandDoeWanId = GetBroadbandDoeWanId();
-            m.BetaDeployment = db.DiscoConfiguration.UpdateBetaDeployment;
+            m.BetaDeployment = Database.DiscoConfiguration.UpdateBetaDeployment;
 
-            m.Stat_JobCounts = db.Jobs.GroupBy(j => j.JobTypeId).Select(g => new Disco.Models.BI.Interop.Community.UpdateRequestV1.Stat { Key = g.Key, Count = g.Count() }).ToList();
-            m.Stat_OpenJobCounts = db.Jobs.Where(j => j.ClosedDate == null).GroupBy(j => j.JobTypeId).Select(g => new Disco.Models.BI.Interop.Community.UpdateRequestV1.Stat { Key = g.Key, Count = g.Count() }).ToList();
+            m.Stat_JobCounts = Database.Jobs.GroupBy(j => j.JobTypeId).Select(g => new Disco.Models.BI.Interop.Community.UpdateRequestV1.Stat { Key = g.Key, Count = g.Count() }).ToList();
+            m.Stat_OpenJobCounts = Database.Jobs.Where(j => j.ClosedDate == null).GroupBy(j => j.JobTypeId).Select(g => new Disco.Models.BI.Interop.Community.UpdateRequestV1.Stat { Key = g.Key, Count = g.Count() }).ToList();
+            m.Stat_DeviceModelCounts = Database.DeviceModels.Select(dm => new Disco.Models.BI.Interop.Community.UpdateRequestV1.Stat { Key = dm.Manufacturer + ";" + dm.Model, Count = dm.Devices.Count(d => d.DecommissionedDate == null) }).ToList();
             var activeThreshold = DateTime.Now.AddDays(-60);
-            m.Stat_ActiveDeviceModelCounts = db.DeviceModels.Select(dm => new Disco.Models.BI.Interop.Community.UpdateRequestV1.Stat { Key = dm.Manufacturer + ";" + dm.Model, Count = dm.Devices.Count(d => d.DecommissionedDate == null && (d.LastNetworkLogonDate == null || d.LastNetworkLogonDate > activeThreshold)) }).ToList();
-            m.Stat_UserCounts = db.Users.GroupBy(u => u.Type).Select(g => new Disco.Models.BI.Interop.Community.UpdateRequestV1.Stat { Key = g.Key, Count = g.Count() }).ToList();
+            m.Stat_ActiveDeviceModelCounts = Database.DeviceModels.Select(dm => new Disco.Models.BI.Interop.Community.UpdateRequestV1.Stat { Key = dm.Manufacturer + ";" + dm.Model, Count = dm.Devices.Count(d => d.DecommissionedDate == null && (d.LastNetworkLogonDate == null || d.LastNetworkLogonDate > activeThreshold)) }).ToList();
+            m.Stat_UserCounts = new List<UpdateRequestV1.Stat>() {
+                new UpdateRequestV1.Stat(){
+                     Key = "All Users",
+                     Count = Database.Users.Count()
+                }
+            };
+
+            m.Stat_JobWarrantyVendorCounts = Database.Jobs.Where(j => j.JobTypeId == JobType.JobTypeIds.HWar && j.JobMetaWarranty.ExternalLoggedDate.HasValue && j.JobMetaWarranty.ExternalName != null).GroupBy(j => j.JobMetaWarranty.ExternalName).Select(g => new Disco.Models.BI.Interop.Community.UpdateRequestV1.Stat { Key = g.Key ?? "<Unknown>", Count = g.Count() }).ToList();
 
             m.InstalledPlugins = Disco.Services.Plugins.Plugins.GetPlugins().Select(manifest => new Disco.Models.BI.Interop.Community.UpdateRequestV1.PluginRef { Id = manifest.Id, Version = manifest.VersionFormatted }).ToList();
 

Disco.BI/BI/Interop/Community/UpdateCheckTask.cs

@@ -1,12 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Disco.Data.Repository;
-using Disco.Services.Logging;
+using Disco.Data.Repository;
 using Disco.Services.Tasks;
 using Quartz;
+using System;
+using System.Linq;
 
 namespace Disco.BI.Interop.Community
 {
@@ -53,7 +49,7 @@ namespace Disco.BI.Interop.Community
             }
         }
 
-        public override void InitalizeScheduledTask(Data.Repository.DiscoDataContext dbContext)
+        public override void InitalizeScheduledTask(Data.Repository.DiscoDataContext Database)
         {
             // Random time between midday and midnight.
             var rnd = new Random();
@@ -69,17 +65,17 @@ namespace Disco.BI.Interop.Community
 
         protected override void ExecuteTask()
         {
-            using (DiscoDataContext db = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
                 try
                 {
-                    UpdateCheck.Check(db, true, this.Status);
+                    UpdateCheck.Check(database, true, this.Status);
                 }
                 catch (Exception ex)
                 {
                     ScheduledTasksLog.LogScheduledTaskException(this.Status.TaskName, this.Status.SessionId, this.Status.TaskType, ex);
                     // Could be proxy error - try again without proxy:
-                    UpdateCheck.Check(db, false, this.Status);
+                    UpdateCheck.Check(database, false, this.Status);
                 }
             }
         }

Disco.BI/BI/Interop/Pdf/PdfGenerator.cs

@@ -12,13 +12,14 @@ using Disco.BI.Expressions;
 using System.Collections;
 using Disco.BI.Extensions;
 using Disco.Models.BI.Expressions;
+using Disco.Services.Users;
 
 namespace Disco.BI.Interop.Pdf
 {
     public static class PdfGenerator
     {
 
-        public static System.IO.Stream GenerateBulkFromTemplate(DocumentTemplate dt, DiscoDataContext dbContext, User CreatorUser, System.DateTime Timestamp, params object[] DataObjects)
+        public static System.IO.Stream GenerateBulkFromTemplate(DocumentTemplate dt, DiscoDataContext Database, User CreatorUser, System.DateTime Timestamp, params object[] DataObjects)
         {
             if (DataObjects.Length > 0)
             {
@@ -27,7 +28,7 @@ namespace Disco.BI.Interop.Pdf
                 {
                     foreach (object d in DataObjects)
                     {
-                        generatedPdfs.Add(dt.GeneratePdf(dbContext, d, CreatorUser, Timestamp, state, true));
+                        generatedPdfs.Add(dt.GeneratePdf(Database, d, CreatorUser, Timestamp, state, true));
                         state.SequenceNumber++;
                         state.FlushScopeCache();
                     }
@@ -47,24 +48,24 @@ namespace Disco.BI.Interop.Pdf
             return null;
         }
 
-        public static System.IO.Stream GenerateBulkFromTemplate(DocumentTemplate dt, DiscoDataContext dbContext, User CreatorUser, System.DateTime Timestamp, params string[] DataObjectsIds)
+        public static System.IO.Stream GenerateBulkFromTemplate(DocumentTemplate dt, DiscoDataContext Database, User CreatorUser, System.DateTime Timestamp, params string[] DataObjectsIds)
         {
             object[] DataObjects;
 
             switch (dt.Scope)
             {
                 case DocumentTemplate.DocumentTemplateScopes.Device:
-                    DataObjects = dbContext.Devices.Where(d => DataObjectsIds.Contains(d.SerialNumber)).ToArray();
+                    DataObjects = Database.Devices.Where(d => DataObjectsIds.Contains(d.SerialNumber)).ToArray();
                     break;
                 case DocumentTemplate.DocumentTemplateScopes.Job:
                     int[] intDataObjectsIds = DataObjectsIds.Select(i => int.Parse(i)).ToArray();
-                    DataObjects = dbContext.Jobs.Where(j => intDataObjectsIds.Contains(j.Id)).ToArray();
+                    DataObjects = Database.Jobs.Where(j => intDataObjectsIds.Contains(j.Id)).ToArray();
                     break;
                 case DocumentTemplate.DocumentTemplateScopes.User:
                     DataObjects = new object[DataObjectsIds.Length];
                     for (int idIndex = 0; idIndex < DataObjectsIds.Length; idIndex++)
                     {
-                        DataObjects[idIndex] = UserBI.UserCache.GetUser(DataObjectsIds[idIndex], dbContext, true);
+                        DataObjects[idIndex] = UserService.GetUser(DataObjectsIds[idIndex], Database, true);
                         if (DataObjects[idIndex] == null)
                             throw new Exception(string.Format("Unknown Username specified: {0}", DataObjectsIds[idIndex]));
                     }
@@ -73,10 +74,10 @@ namespace Disco.BI.Interop.Pdf
                     throw new InvalidOperationException("Invalid DocumentType Scope");
             }
 
-            return GenerateBulkFromTemplate(dt, dbContext, CreatorUser, Timestamp, DataObjects);
+            return GenerateBulkFromTemplate(dt, Database, CreatorUser, Timestamp, DataObjects);
         }
 
-        public static System.IO.Stream GenerateFromTemplate(DocumentTemplate dt, DiscoDataContext dbContext, object Data, User CreatorUser, System.DateTime TimeStamp, DocumentState State, bool FlattenFields = false)
+        public static System.IO.Stream GenerateFromTemplate(DocumentTemplate dt, DiscoDataContext Database, object Data, User CreatorUser, System.DateTime TimeStamp, DocumentState State, bool FlattenFields = false)
         {
             // Validate Data
             switch (dt.Scope)
@@ -97,15 +98,15 @@ namespace Disco.BI.Interop.Pdf
                     throw new InvalidOperationException("Invalid AttachmentType Scope");
             }
 
-            dbContext.Configuration.LazyLoadingEnabled = true;
+            Database.Configuration.LazyLoadingEnabled = true;
 
             // Override FlattenFields if Document Template instructs.
             if (dt.FlattenForm)
                 FlattenFields = true;
 
-            ConcurrentDictionary<string, Expression> expressionCache = dt.PdfExpressionsFromCache(dbContext);
+            ConcurrentDictionary<string, Expression> expressionCache = dt.PdfExpressionsFromCache(Database);
 
-            string templateFilename = dt.RepositoryFilename(dbContext);
+            string templateFilename = dt.RepositoryFilename(Database);
             PdfReader pdfReader = new PdfReader(templateFilename);
 
             MemoryStream pdfGeneratedStream = new MemoryStream();
@@ -114,7 +115,7 @@ namespace Disco.BI.Interop.Pdf
             pdfStamper.FormFlattening = FlattenFields;
             pdfStamper.Writer.CloseStream = false;
 
-            IDictionary expressionVariables = Expression.StandardVariables(dt, dbContext, CreatorUser, TimeStamp, State);
+            IDictionary expressionVariables = Expression.StandardVariables(dt, Database, CreatorUser, TimeStamp, State);
 
             foreach (string pdfFieldKey in pdfStamper.AcroFields.Fields.Keys)
             {
@@ -240,7 +241,7 @@ namespace Disco.BI.Interop.Pdf
                     Timestamp = DateTime.Now
                 };
                 jl.Comments = string.Format("Document Generated{0}{1} [{2}]", Environment.NewLine, dt.Description, dt.Id);
-                dbContext.JobLogs.Add(jl);
+                Database.JobLogs.Add(jl);
             }
 
             pdfGeneratedStream.Position = 0;

Disco.BI/BI/Interop/Pdf/PdfImporter.cs

@@ -205,7 +205,7 @@ namespace Disco.BI.Interop.Pdf
             return null;
         }
 
-        private static DetectImageResult DetectImage(DiscoDataContext dbContext, Bitmap pageImageOriginal, string SessionId, IEnumerable<DocumentTemplate> detectDocumentTemplates, DetectStateHints StateHints)
+        private static DetectImageResult DetectImage(DiscoDataContext Database, Bitmap pageImageOriginal, string SessionId, IEnumerable<DocumentTemplate> detectDocumentTemplates, DetectStateHints StateHints)
         {
             Bitmap pageImage = pageImageOriginal;
             double pageImageModifiedScale = 1;
@@ -270,7 +270,7 @@ namespace Disco.BI.Interop.Pdf
                     {
                         foreach (DocumentTemplate dt in detectDocumentTemplates)
                         {
-                            var locationBag = dt.QRCodeLocations(dbContext);
+                            var locationBag = dt.QRCodeLocations(Database);
                             foreach (var location in locationBag)
                             {
                                 result = DetectImageFromSegment(pageImage, zxingMfr, zxingMfrHints,
@@ -303,7 +303,7 @@ namespace Disco.BI.Interop.Pdf
             }
         }
 
-        private static DetectPageResult DetectPage(DiscoDataContext dbContext, PdfReader pdfReader, int PageNumber, string SessionId, string DataStoreSessionCacheLocation, IEnumerable<DocumentTemplate> detectDocumentTemplates, DetectStateHints StateHints)
+        private static DetectPageResult DetectPage(DiscoDataContext Database, PdfReader pdfReader, int PageNumber, string SessionId, string DataStoreSessionCacheLocation, IEnumerable<DocumentTemplate> detectDocumentTemplates, DetectStateHints StateHints)
         {
             DetectPageResult result = new DetectPageResult() { PageNumber = PageNumber };
 
@@ -325,7 +325,7 @@ namespace Disco.BI.Interop.Pdf
                     {
                         DocumentImporterLog.LogImportPageProgress(SessionId, PageNumber, (int)(10 + (pageProgressInterval * pageImages.IndexOf(pageImageOriginal))), String.Format("Processing Page Image {0} of {1}", pageImages.IndexOf(pageImageOriginal) + 1, pageImages.Count));
 
-                        using (var zxingResult = DetectImage(dbContext, pageImageOriginal, SessionId, detectDocumentTemplates, StateHints))
+                        using (var zxingResult = DetectImage(Database, pageImageOriginal, SessionId, detectDocumentTemplates, StateHints))
                         {
                             if (zxingResult != null)
                             {
@@ -377,9 +377,9 @@ namespace Disco.BI.Interop.Pdf
             }
         }
 
-        public static bool ProcessPdfAttachment(string Filename, DiscoDataContext dbContext, string SessionId, Cache HttpCache)
+        public static bool ProcessPdfAttachment(string Filename, DiscoDataContext Database, string SessionId, Cache HttpCache)
         {
-            var dataStoreUnassignedLocation = DataStore.CreateLocation(dbContext, "DocumentDropBox_Unassigned");
+            var dataStoreUnassignedLocation = DataStore.CreateLocation(Database, "DocumentDropBox_Unassigned");
 
             DocumentImporterLog.LogImportProgress(SessionId, 0, "Reading File");
 
@@ -389,8 +389,8 @@ namespace Disco.BI.Interop.Pdf
 
                 var pdfPagesAssigned = new Dictionary<int, Tuple<DocumentUniqueIdentifier, byte[]>>();
 
-                var dataStoreSessionPagesCacheLocation = DataStore.CreateLocation(dbContext, "Cache\\DocumentDropBox_SessionPages");
-                var detectDocumentTemplates = dbContext.DocumentTemplates.ToArray();
+                var dataStoreSessionPagesCacheLocation = DataStore.CreateLocation(Database, "Cache\\DocumentDropBox_SessionPages");
+                var detectDocumentTemplates = Database.DocumentTemplates.ToArray();
 
                 double progressInterval = 70 / pdfReader.NumberOfPages;
 
@@ -401,14 +401,14 @@ namespace Disco.BI.Interop.Pdf
                     DocumentImporterLog.LogImportProgress(SessionId, (int)(PageNumber * progressInterval), string.Format("Processing Page {0} of {1}", PageNumber, pdfReader.NumberOfPages));
                     DocumentImporterLog.LogImportPageStarting(SessionId, PageNumber);
 
-                    using (var pageResult = DetectPage(dbContext, pdfReader, PageNumber, SessionId, dataStoreSessionPagesCacheLocation, detectDocumentTemplates, detectStateHints))
+                    using (var pageResult = DetectPage(Database, pdfReader, PageNumber, SessionId, dataStoreSessionPagesCacheLocation, detectDocumentTemplates, detectStateHints))
                     {
                         if (pageResult.DetectedIdentifier != null)
                         {
                             var docId = pageResult.DetectedIdentifier;
                             pdfPagesAssigned.Add(PageNumber, new Tuple<DocumentUniqueIdentifier, byte[]>(docId, pageResult.AttachmentThumbnailImage.ToArray()));
 
-                            docId.LoadComponents(dbContext);
+                            docId.LoadComponents(Database);
                             DocumentImporterLog.LogImportPageDetected(SessionId, PageNumber, docId.DocumentUniqueId, docId.DocumentTemplate.Description, docId.DocumentTemplate.Scope, docId.DataId, docId.DataDescription);
                         }
                         else
@@ -441,7 +441,7 @@ namespace Disco.BI.Interop.Pdf
                         var documentPortionIdentifier = documentPortionInfo.Item1;
                         var documentPortionThumbnail = documentPortionInfo.Item2;
 
-                        if (!documentPortionIdentifier.LoadComponents(dbContext))
+                        if (!documentPortionIdentifier.LoadComponents(Database))
                         {
                             // Unknown Document Unique Id
                             foreach (var dp in documentPortion)
@@ -477,7 +477,7 @@ namespace Disco.BI.Interop.Pdf
 
                                 msBuilder.Position = 0;
 
-                                var attachmentSuccess = documentPortionIdentifier.ImportPdfAttachment(dbContext, msBuilder, documentPortionThumbnail);
+                                var attachmentSuccess = documentPortionIdentifier.ImportPdfAttachment(Database, msBuilder, documentPortionThumbnail);
 
                                 if (!attachmentSuccess)
                                 { // Unable to add Attachment
@@ -538,13 +538,13 @@ namespace Disco.BI.Interop.Pdf
 
             return true;
         }
-        public static bool ProcessPdfAttachment(string Filename, DiscoDataContext dbContext, string DocumentTemplateId, string DataId, string UserId, DateTime Timestamp)
+        public static bool ProcessPdfAttachment(string Filename, DiscoDataContext Database, string DocumentTemplateId, string DataId, string UserId, DateTime Timestamp)
         {
             using (FileStream fs = new FileStream(Filename, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
             {
                 DocumentUniqueIdentifier identifier = new DocumentUniqueIdentifier(DocumentTemplateId, DataId, UserId, Timestamp);
-                identifier.LoadComponents(dbContext);
-                return identifier.ImportPdfAttachment(dbContext, fs, null);
+                identifier.LoadComponents(Database);
+                return identifier.ImportPdfAttachment(Database, fs, null);
             }
         }
 

Disco.BI/BI/Interop/PluginServices/IDiscoScheduledTask.cs

@@ -1,14 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using System.Text;
-//using Disco.Data.Repository;
-//using Quartz;
-
-//namespace Disco.BI.Interop.PluginServices
-//{
-//    interface IDiscoScheduledTask
-//    {
-//        void InitalizeScheduledTask(DiscoDataContext dbContext, IScheduler Scheduler);
-//    }
-//}

Disco.BI/BI/Interop/PluginServices/Utilities.cs

@@ -1,45 +0,0 @@
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using System.Text;
-//using Disco.Data.Repository;
-//using Quartz;
-
-//namespace Disco.BI.Interop.PluginServices
-//{
-//    public static class Utilities
-//    {
-
-//        public static void InitalizeScheduledTasks(DiscoDataContext dbContext, ISchedulerFactory SchedulerFactory)
-//        {
-
-//            var scheduler = SchedulerFactory.GetScheduler();
-
-//            // Discover IDiscoScheduledTasks (Only from Disco Assemblies)
-//            var appDomain = AppDomain.CurrentDomain;
-
-//            var scheduledTaskTypes = (from a in appDomain.GetAssemblies()
-//                                      where !a.GlobalAssemblyCache && !a.IsDynamic && a.FullName.StartsWith("Disco.", StringComparison.InvariantCultureIgnoreCase)
-//                                      from type in a.GetTypes()
-//                                      where typeof(IDiscoScheduledTask).IsAssignableFrom(type) && !type.IsAbstract
-//                                      select type);
-//            foreach (Type scheduledTaskType in scheduledTaskTypes)
-//            {
-//                IDiscoScheduledTask instance = (IDiscoScheduledTask)Activator.CreateInstance(scheduledTaskType);
-//                try
-//                {
-//                    instance.InitalizeScheduledTask(dbContext, scheduler);
-//                }
-//                catch (Exception ex)
-//                {
-//                    if (instance == null)
-//                        Logging.SystemLog.LogException("Initializing Scheduled Task; Disco.BI.Interop.Plugins.Utilities.InitalizeScheduledTasks()", ex);
-//                    else
-//                        Logging.SystemLog.LogException(string.Format("Initializing Scheduled Task: '{0}'; Disco.BI.Interop.Plugins.Utilities.InitalizeScheduledTasks()", instance.GetType().Name), ex);
-//                }
-//            }
-
-//        }
-
-//    }
-//}

Disco.BI/BI/Interop/SignalRHandlers/AdminAuthorizedPersistentConnection.cs

@@ -1,16 +0,0 @@
-using Disco.Models.Repository;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Disco.BI.Interop.SignalRHandlers
-{
-    public class AdminAuthorizedPersistentConnection : AuthorizedPersistentConnection
-    {
-        private string[] authorizedUserTypes = { User.Types.Admin };
-
-        protected override string[] AuthorizedUserTypes { get { return authorizedUserTypes; } }
-    }
-}

Disco.BI/BI/Interop/SignalRHandlers/AuthorizedPersistentConnection.cs

@@ -1,4 +1,5 @@
-using Microsoft.AspNet.SignalR;
+using Disco.Services.Users;
+using Microsoft.AspNet.SignalR;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -9,9 +10,9 @@ namespace Disco.BI.Interop.SignalRHandlers
 {
     public class AuthorizedPersistentConnection : PersistentConnection
     {
-        private string[] authorizedUserTypes = null;
+        private string authorizedClaim = null;
 
-        protected virtual string[] AuthorizedUserTypes { get { return authorizedUserTypes; } }
+        protected virtual string AuthorizedClaim { get { return authorizedClaim; } }
 
         protected override bool AuthorizeRequest(IRequest request)
         {
@@ -19,17 +20,15 @@ namespace Disco.BI.Interop.SignalRHandlers
                 return false;
             else
             {
-                var user = UserBI.UserCache.CurrentUser;
-                if (user == null)
-                    return false;
+                var authToken = UserService.CurrentAuthorization;
+                
+                if (authToken == null)
+                    return false; // No Current User
 
-                if (AuthorizedUserTypes == null || AuthorizedUserTypes.Length == 0)
-                    return true;
-
-                if (AuthorizedUserTypes.Contains(user.Type))
-                    return true;
-
-                return false;
+                if (authorizedClaim == null)
+                    return true; // Just Authenticate - no Authorization
+                else
+                    return authToken.Has(authorizedClaim);
             }
         }
     }

Disco.BI/BI/Interop/SignalRHandlers/HeldDeviceNotifications.cs

@@ -61,7 +61,7 @@ namespace Disco.BI.Interop.SignalRHandlers
         {
             User u = (User)e.Entity;
 
-            var userDevices = e.dbContext.Devices.Where(d => d.AssignedUserId == u.Id);
+            var userDevices = e.Database.Devices.Where(d => d.AssignedUserId == u.Id);
 
             foreach (var userDevice in userDevices)
             {

Disco.BI/BI/Interop/SignalRHandlers/LogNotifications.cs

@@ -1,4 +1,5 @@
-using Disco.Services.Logging;
+using Disco.Services.Authorization;
+using Disco.Services.Logging;
 using Disco.Services.Logging.Models;
 using Microsoft.AspNet.SignalR;
 using System;
@@ -9,10 +10,12 @@ using System.Threading.Tasks;
 
 namespace Disco.BI.Interop.SignalRHandlers
 {
-    public class LogNotifications : AdminAuthorizedPersistentConnection
+    public class LogNotifications : AuthorizedPersistentConnection
     {
         public static bool initialized = false;
 
+        protected override string AuthorizedClaim { get { return Claims.DiscoAdminAccount; } }
+
         public LogNotifications()
         {
             if (!initialized)

Disco.BI/BI/Interop/SignalRHandlers/RepositoryMonitorNotifications.cs

@@ -1,4 +1,5 @@
 using Disco.Data.Repository.Monitor;
+using Disco.Services.Authorization;
 using Microsoft.AspNet.SignalR;
 using System;
 using System.Collections.Generic;
@@ -8,8 +9,10 @@ using System.Threading.Tasks;
 
 namespace Disco.BI.Interop.SignalRHandlers
 {
-    public class RepositoryMonitorNotifications : AdminAuthorizedPersistentConnection
+    public class RepositoryMonitorNotifications : AuthorizedPersistentConnection
     {
+        protected override string AuthorizedClaim { get { return Claims.DiscoAdminAccount; } }
+
         public static void Initialize()
         {
             RepositoryMonitor.StreamAfterCommit.Subscribe(AfterCommit);

Disco.BI/BI/Interop/SignalRHandlers/ScheduledTasksStatusNotifications.cs

@@ -1,4 +1,5 @@
-using Disco.Services.Tasks;
+using Disco.Services.Authorization;
+using Disco.Services.Tasks;
 using Microsoft.AspNet.SignalR;
 using System;
 using System.Collections.Generic;
@@ -8,10 +9,12 @@ using System.Threading.Tasks;
 
 namespace Disco.BI.Interop.SignalRHandlers
 {
-    public class ScheduledTasksStatusNotifications : AdminAuthorizedPersistentConnection
+    public class ScheduledTasksStatusNotifications : AuthorizedPersistentConnection
     {
         public static bool initialized = false;
 
+        protected override string AuthorizedClaim { get { return Claims.DiscoAdminAccount; } }
+
         public ScheduledTasksStatusNotifications()
         {
             if (!initialized)

Disco.BI/BI/Interop/SignalRHandlers/UserHeldDeviceNotifications.cs

@@ -48,7 +48,7 @@ namespace Disco.BI.Interop.SignalRHandlers
 
             if (j.DeviceSerialNumber != null)
             {
-                var jobDevice = e.dbContext.Devices.Where(d => d.SerialNumber == j.DeviceSerialNumber).FirstOrDefault();
+                var jobDevice = e.Database.Devices.Where(d => d.SerialNumber == j.DeviceSerialNumber).FirstOrDefault();
 
                 if (jobDevice.AssignedUserId != null)
                     notificationContext.Connection.Broadcast(jobDevice.AssignedUserId);

Disco.BI/BI/JobBI/ManagedJobList.cs

@@ -9,42 +9,95 @@ using System.Text;
 using System.Threading.Tasks;
 using Disco.BI.Extensions;
 using System.Reactive.Linq;
+using Disco.Services.Users;
 
 namespace Disco.BI.JobBI
 {
+    using FilterFunc = Func<IQueryable<Job>, IQueryable<Job>>;
+    using SortFunc = Func<IEnumerable<Disco.Models.BI.Job.JobTableModel.JobTableItemModel>, IEnumerable<Disco.Models.BI.Job.JobTableModel.JobTableItemModel>>;
+    using Disco.Services.Logging;
+
     public class ManagedJobList : JobTableModel, IDisposable
     {
         public string Name { get; set; }
-        public Func<IQueryable<Job>, IQueryable<Job>> FilterFunction { get; set; }
-        public Func<IEnumerable<JobTableItemModel>, IEnumerable<JobTableItemModel>> SortFunction { get; set; }
+        public FilterFunc FilterFunction { get; set; }
+        public SortFunc SortFunction { get; set; }
         private IDisposable unsubscribeToken;
         private object updateLock = new object();
-
-        public ManagedJobList Initialize(DiscoDataContext dbContext)
+        
+        public override List<JobTableItemModel> Items
         {
-            // Initially fill table
-            this.Items = this.SortFunction(this.DetermineItems(dbContext, this.FilterFunction(dbContext.Jobs))).ToList();
+            get
+            {
+                return base.Items.PermissionsFiltered(UserService.CurrentAuthorization);
+            }
+            set
+            {
+                throw new InvalidOperationException("Items cannot be manually set in a Managed Job List");
+            }
+        }
 
-            // Subscribe for Changes
-            // - Job (or Job Meta) Changes
-            // - Device Profile Address Changes (for multi-campus Schools)
-            // - Device Model Description Changes
-            // - Device's Profile or Model Changes
-            unsubscribeToken = RepositoryMonitor.StreamAfterCommit
-                .Where(n => n.EntityType == typeof(Job) ||
-                    n.EntityType == typeof(JobMetaWarranty) ||
-                    n.EntityType == typeof(JobMetaNonWarranty) ||
-                    n.EntityType == typeof(JobMetaInsurance) ||
-                    (n.EventType == RepositoryMonitorEventType.Modified && (
-                        (n.EntityType == typeof(DeviceProfile) && n.ModifiedProperties.Contains("DefaultOrganisationAddress")) ||
-                        (n.EntityType == typeof(DeviceModel) && n.ModifiedProperties.Contains("Description")) ||
-                        (n.EntityType == typeof(Device) && n.ModifiedProperties.Contains("DeviceProfileId") || n.ModifiedProperties.Contains("DeviceModelId"))
-                    )))
-                .Subscribe(JobNotification);
+        public ManagedJobList Initialize(DiscoDataContext Database)
+        {
+            // Can only Initialize once
+            if (base.Items != null)
+                return ReInitialize(Database);
 
+            lock (updateLock)
+            {
+                // Subscribe for Changes
+                // - Job (or Job Meta) Changes
+                // - Device Profile Address Changes (for multi-campus Schools)
+                // - Device Model Description Changes
+                // - Device's Profile or Model Changes
+                unsubscribeToken = RepositoryMonitor.StreamAfterCommit
+                    .Where(n => n.EntityType == typeof(Job) ||
+                        n.EntityType == typeof(JobMetaWarranty) ||
+                        n.EntityType == typeof(JobMetaNonWarranty) ||
+                        n.EntityType == typeof(JobMetaInsurance) ||
+                        (n.EventType == RepositoryMonitorEventType.Modified && (
+                            (n.EntityType == typeof(DeviceProfile) && n.ModifiedProperties.Contains("DefaultOrganisationAddress")) ||
+                            (n.EntityType == typeof(DeviceModel) && n.ModifiedProperties.Contains("Description")) ||
+                            (n.EntityType == typeof(Device) && n.ModifiedProperties.Contains("DeviceProfileId") || n.ModifiedProperties.Contains("DeviceModelId"))
+                        )))
+                    .Subscribe(JobNotification, NotificationError);
+
+                // Initially fill table
+                base.Items = this.SortFunction(this.DetermineItems(Database, this.FilterFunction(Database.Jobs))).ToList();
+            }
             return this;
         }
 
+        public ManagedJobList ReInitialize(DiscoDataContext Database)
+        {
+            return ReInitialize(Database, null, null);
+        }
+        public ManagedJobList ReInitialize(DiscoDataContext Database, FilterFunc FilterFunction)
+        {
+            return ReInitialize(Database, FilterFunction, null);
+        }
+        public ManagedJobList ReInitialize(DiscoDataContext Database, FilterFunc FilterFunction, SortFunc SortFunction)
+        {
+            if (Database == null)
+                throw new ArgumentNullException("Database");
+
+            lock (updateLock)
+            {
+                if (FilterFunction != null)
+                    this.FilterFunction = FilterFunction;
+                if (SortFunction != null)
+                    this.SortFunction = SortFunction;
+
+                base.Items = this.SortFunction(this.DetermineItems(Database, this.FilterFunction(Database.Jobs))).ToList();
+            }
+            return this;
+        }
+
+        private void NotificationError(Exception ex)
+        {
+            SystemLog.LogException(string.Format("Disco.BI.JobBI.ManagedJobList: [{0}]", this.Name), ex);
+        }
+
         private void JobNotification(RepositoryMonitorEvent e)
         {
             List<int> jobIds = null;
@@ -65,19 +118,19 @@ namespace Disco.BI.JobBI
                             if (e.EntityType == typeof(DeviceProfile))
                             {
                                 int deviceProfileId = ((DeviceProfile)e.Entity).Id;
-                                existingItems = this.Items.Where(i => i.DeviceProfileId == deviceProfileId).ToArray();
+                                existingItems = base.Items.Where(i => i.DeviceProfileId == deviceProfileId).ToArray();
                             }
                             else
                                 if (e.EntityType == typeof(DeviceModel))
                                 {
                                     int deviceModelId = ((DeviceModel)e.Entity).Id;
-                                    existingItems = this.Items.Where(i => i.DeviceModelId == deviceModelId).ToArray();
+                                    existingItems = base.Items.Where(i => i.DeviceModelId == deviceModelId).ToArray();
                                 }
                                 else
                                     if (e.EntityType == typeof(Device))
                                     {
                                         string deviceSerialNumber = ((Device)e.Entity).SerialNumber;
-                                        existingItems = this.Items.Where(i => i.DeviceSerialNumber == deviceSerialNumber).ToArray();
+                                        existingItems = base.Items.Where(i => i.DeviceSerialNumber == deviceSerialNumber).ToArray();
                                     }
                                     else
                                         return;  // Subscription should never reach
@@ -93,20 +146,20 @@ namespace Disco.BI.JobBI
             if (jobIds.Count == 0)
                 return;
             else
-                UpdateJobs(e.dbContext, jobIds, existingItems);
+                UpdateJobs(e.Database, jobIds, existingItems);
         }
 
-        private void UpdateJobs(DiscoDataContext dbContext, List<int> jobIds, JobTableItemModel[] existingItems = null)
+        private void UpdateJobs(DiscoDataContext Database, List<int> jobIds, JobTableItemModel[] existingItems = null)
         {
             lock (updateLock)
             {
                 // Check for existing items, if not handed them
                 if (existingItems == null)
-                    existingItems = this.Items.Where(i => jobIds.Contains(i.Id)).ToArray();
+                    existingItems = base.Items.Where(i => jobIds.Contains(i.Id)).ToArray();
+                
+                var updatedItems = this.DetermineItems(Database, this.FilterFunction(Database.Jobs.Where(j => jobIds.Contains(j.Id))));
 
-                var updatedItems = this.DetermineItems(dbContext, this.FilterFunction(dbContext.Jobs.Where(j => jobIds.Contains(j.Id))));
-
-                var refreshedList = this.Items.ToList();
+                var refreshedList = base.Items.ToList();
 
                 // Remove Existing
                 if (existingItems.Length > 0)
@@ -119,7 +172,7 @@ namespace Disco.BI.JobBI
                         refreshedList.Add(updatedItem);
 
                 // Reorder
-                this.Items = this.SortFunction(refreshedList).ToList();
+                base.Items = this.SortFunction(refreshedList).ToList();
             }
         }
 

Disco.BI/BI/JobBI/Searching.cs

@@ -11,7 +11,7 @@ namespace Disco.BI.JobBI
 {
     public static class Searching
     {
-        public static JobTableModel Search(DiscoDataContext dbContext, string Term, int? LimitCount = null, bool IncludeJobStatus = true, bool SearchDetails = false)
+        public static JobTableModel Search(DiscoDataContext Database, string Term, int? LimitCount = null, bool IncludeJobStatus = true, bool SearchDetails = false)
         {
             int termInt = default(int);
 
@@ -22,7 +22,7 @@ namespace Disco.BI.JobBI
                 // Term is a Number (int)
                 if (SearchDetails)
                 {
-                    query = BuildJobTableModel(dbContext).Where(j =>
+                    query = BuildJobTableModel(Database).Where(j =>
                         j.Id == termInt ||
                         j.DeviceHeldLocation.Contains(Term) ||
                         j.Device.SerialNumber.Contains(Term) ||
@@ -36,7 +36,7 @@ namespace Disco.BI.JobBI
                 }
                 else
                 {
-                    query = BuildJobTableModel(dbContext).Where(j =>
+                    query = BuildJobTableModel(Database).Where(j =>
                         j.Id == termInt ||
                         j.DeviceHeldLocation.Contains(Term) ||
                         j.Device.SerialNumber.Contains(Term) ||
@@ -51,7 +51,7 @@ namespace Disco.BI.JobBI
             {
                 if (SearchDetails)
                 {
-                    query = BuildJobTableModel(dbContext).Where(j =>
+                    query = BuildJobTableModel(Database).Where(j =>
                         j.DeviceHeldLocation.Contains(Term) ||
                         j.Device.SerialNumber.Contains(Term) ||
                         j.Device.AssetNumber.Contains(Term) ||
@@ -64,7 +64,7 @@ namespace Disco.BI.JobBI
                 }
                 else
                 {
-                    query = BuildJobTableModel(dbContext).Where(j =>
+                    query = BuildJobTableModel(Database).Where(j =>
                         j.DeviceHeldLocation.Contains(Term) ||
                         j.Device.SerialNumber.Contains(Term) ||
                         j.Device.AssetNumber.Contains(Term) ||
@@ -79,14 +79,14 @@ namespace Disco.BI.JobBI
                 query = query.Take(LimitCount.Value);
 
             JobTableModel model = new JobTableModel() { ShowStatus = IncludeJobStatus };
-            model.Fill(dbContext, query);
+            model.Fill(Database, query);
 
             return model;
         }
 
-        public static IQueryable<Job> BuildJobTableModel(DiscoDataContext dbContext)
+        public static IQueryable<Job> BuildJobTableModel(DiscoDataContext Database)
         {
-            return dbContext.Jobs.Include("JobType").Include("Device").Include("User").Include("OpenedTechUser");
+            return Database.Jobs.Include("JobType").Include("Device").Include("User").Include("OpenedTechUser");
         }
 
     }

Disco.BI/BI/JobBI/Statistics/DailyOpenedClosed.cs

@@ -25,7 +25,7 @@ namespace Disco.BI.JobBI.Statistics
         public override bool SingleInstanceTask { get { return true; } }
         public override bool CancelInitiallySupported { get { return false; } }
 
-        public override void InitalizeScheduledTask(DiscoDataContext dbContext)
+        public override void InitalizeScheduledTask(DiscoDataContext Database)
         {
             // Trigger Daily @ 12:29am
             TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithSchedule(CronScheduleBuilder.DailyAtHourAndMinute(0, 29));
@@ -34,40 +34,13 @@ namespace Disco.BI.JobBI.Statistics
         }
         protected override void ExecuteTask()
         {
-            using (var dbContext = new DiscoDataContext())
+            using (var database = new DiscoDataContext())
             {
-                UpdateDataHistory(dbContext, true);
+                UpdateDataHistory(database, true);
             }
         }
 
-        //public void InitalizeScheduledTask(DiscoDataContext dbContext, IScheduler Scheduler)
-        //{
-        //    // Run @ 12:29am
-        //    IJobDetail jobDetail = new JobDetailImpl("JobStatisticsDailyOpenedClosed", typeof(DailyOpenedClosed));
-        //    ITrigger trigger = TriggerBuilder.Create().
-        //        WithIdentity("JobStatisticsDailyOpenedClosedTrigger").
-        //        StartNow().
-        //        WithSchedule(CronScheduleBuilder.DailyAtHourAndMinute(0, 29)).
-        //        Build();
-        //    Scheduler.ScheduleJob(jobDetail, trigger);
-        //}
-
-        //public void Execute(IJobExecutionContext context)
-        //{
-        //    try
-        //    {
-        //        using (var dbContext = new DiscoDataContext())
-        //        {
-        //            UpdateDataHistory(dbContext, true);
-        //        }
-        //    }
-        //    catch (Exception ex)
-        //    {
-        //        Logging.SystemLog.LogException("Disco.BI.JobBI.Statistics.DailyOpenedClosed", ex);
-        //    }
-        //}
-
-        private static void UpdateDataHistory(DiscoDataContext dbContext, bool Refresh = false)
+        private static void UpdateDataHistory(DiscoDataContext Database, bool Refresh = false)
         {
             DateTime historyEnd = DateTime.Now.Date;
 
@@ -98,7 +71,7 @@ namespace Disco.BI.JobBI.Statistics
                         // Cache Data
                         while (processDate <= historyEnd)
                         {
-                            resultData.Add(Data(dbContext, processDate));
+                            resultData.Add(Data(Database, processDate));
                             processDate = processDate.AddDays(1);
                         }
                         _data = resultData;
@@ -162,14 +135,14 @@ namespace Disco.BI.JobBI.Statistics
             }
         }
 
-        private static DailyOpenedClosedItem Data(DiscoDataContext dbContext, DateTime ProcessDate)
+        private static DailyOpenedClosedItem Data(DiscoDataContext Database, DateTime ProcessDate)
         {
             DateTime processDateStart = ProcessDate;
             DateTime processDateEnd = ProcessDate.AddDays(1);
 
-            int totalJobs = dbContext.Jobs.Where(j => j.OpenedDate < processDateEnd && (!j.ClosedDate.HasValue || j.ClosedDate > processDateEnd)).Count();
-            int openedJobs = dbContext.Jobs.Where(j => j.OpenedDate > processDateStart && j.OpenedDate < processDateEnd).Count();
-            int closedJobs = dbContext.Jobs.Where(j => j.ClosedDate > processDateStart && j.ClosedDate < processDateEnd).Count();
+            int totalJobs = Database.Jobs.Where(j => j.OpenedDate < processDateEnd && (!j.ClosedDate.HasValue || j.ClosedDate > processDateEnd)).Count();
+            int openedJobs = Database.Jobs.Where(j => j.OpenedDate > processDateStart && j.OpenedDate < processDateEnd).Count();
+            int closedJobs = Database.Jobs.Where(j => j.ClosedDate > processDateStart && j.ClosedDate < processDateEnd).Count();
 
             return new DailyOpenedClosedItem()
             {
@@ -180,11 +153,11 @@ namespace Disco.BI.JobBI.Statistics
             };
         }
 
-        public static List<DailyOpenedClosedItem> Data(DiscoDataContext dbContext, bool FilterUnimportantWeekends = false)
+        public static List<DailyOpenedClosedItem> Data(DiscoDataContext Database, bool FilterUnimportantWeekends = false)
         {
             List<DailyOpenedClosedItem> resultData;
 
-            UpdateDataHistory(dbContext);
+            UpdateDataHistory(Database);
 
             if (FilterUnimportantWeekends)
                 resultData = _data.Where(i => (i.Timestamp.DayOfWeek != DayOfWeek.Saturday && i.Timestamp.DayOfWeek != DayOfWeek.Sunday) ||
@@ -192,9 +165,6 @@ namespace Disco.BI.JobBI.Statistics
             else
                 resultData = _data.ToList();
 
-            // Removed - Live Updated via Repository Monitor; See: RepositoryEvent_JobChange
-            //resultData.Add(Data(dbContext, DateTime.Today));
-
             return resultData;
         }
     }

Disco.BI/BI/JobBI/Utilities.cs

@@ -10,7 +10,7 @@ namespace Disco.BI.JobBI
 {
     public static class Utilities
     {
-        public static Job Create(DiscoDataContext dbContext, Device device, User user, JobType type, List<JobSubType> subTypes, User initialTech)
+        public static Job Create(DiscoDataContext Database, Device device, User user, JobType type, List<JobSubType> subTypes, User initialTech)
         {
             Job j = new Job()
             {
@@ -38,19 +38,19 @@ namespace Disco.BI.JobBI
             List<JobSubType> jobSubTypes = subTypes.ToList();
             j.JobSubTypes = jobSubTypes;
 
-            dbContext.Jobs.Add(j);
+            Database.Jobs.Add(j);
 
             switch (type.Id)
             {
                 case JobType.JobTypeIds.HWar:
-                    dbContext.JobMetaWarranties.Add(new JobMetaWarranty() { Job = j });
+                    Database.JobMetaWarranties.Add(new JobMetaWarranty() { Job = j });
                     break;
                 case JobType.JobTypeIds.HNWar:
-                    dbContext.JobMetaNonWarranties.Add(new JobMetaNonWarranty() { Job = j });
+                    Database.JobMetaNonWarranties.Add(new JobMetaNonWarranty() { Job = j });
                     if (device != null)
                     {
                         // Add Job Components
-                        var components = dbContext.DeviceComponents.Include("JobSubTypes").Where(c => !c.DeviceModelId.HasValue || c.DeviceModelId == j.Device.DeviceModelId);
+                        var components = Database.DeviceComponents.Include("JobSubTypes").Where(c => !c.DeviceModelId.HasValue || c.DeviceModelId == j.Device.DeviceModelId);
                         var addedComponents = new List<DeviceComponent>();
                         foreach (var c in components)
                         {
@@ -76,7 +76,7 @@ namespace Disco.BI.JobBI
                             }
                         }
                         foreach (var c in addedComponents)
-                            dbContext.JobComponents.Add(new JobComponent()
+                            Database.JobComponents.Add(new JobComponent()
                             {
                                 Job = j,
                                 TechUserId = initialTech.Id,

Disco.BI/BI/UserBI/Searching.cs

@@ -5,6 +5,7 @@ using System.Text;
 using Disco.Models.BI.Search;
 using Disco.Models.Repository;
 using Disco.Data.Repository;
+using Disco.Services.Users;
 
 namespace Disco.BI.UserBI
 {
@@ -32,7 +33,7 @@ namespace Disco.BI.UserBI
             }).ToList();
         }
 
-        public static List<UserSearchResultItem> Search(DiscoDataContext dbContext, string Term, int? LimitCount = null)
+        public static List<UserSearchResultItem> Search(DiscoDataContext Database, string Term, int? LimitCount = null)
         {
             if (string.IsNullOrWhiteSpace(Term) || Term.Length < 2)
                 throw new ArgumentException("Search Term must contain at least two characters", "Term");
@@ -41,16 +42,16 @@ namespace Disco.BI.UserBI
             var adImportedUsers = Interop.ActiveDirectory.ActiveDirectory.SearchUsers(Term).Select(adU => adU.ToRepositoryUser());
             foreach (var adU in adImportedUsers)
             {
-                var existingUser = dbContext.Users.Find(adU.Id);
+                var existingUser = Database.Users.Find(adU.Id);
                 if (existingUser != null)
                     existingUser.UpdateSelf(adU);
                 else
-                    dbContext.Users.Add(adU);
-                dbContext.SaveChanges();
-                UserCache.InvalidateValue(adU.Id);
+                    Database.Users.Add(adU);
+                Database.SaveChanges();
+                UserService.InvalidateCachedUser(adU.Id);
             }
 
-            return Search_SelectUserSearchResultItems(dbContext.Users.Where(u =>
+            return Search_SelectUserSearchResultItems(Database.Users.Where(u =>
                 u.Id.Contains(Term) ||
                 u.Surname.Contains(Term) ||
                 u.GivenName.Contains(Term) ||

Disco.BI/BI/UserBI/UserCache.cs

@@ -1,146 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Collections.Concurrent;
-using Disco.Models.Repository;
-using Disco.Data.Repository;
-using System.Web;
-using Quartz;
-using Quartz.Impl;
-using Disco.Services.Tasks;
-
-namespace Disco.BI.UserBI
-{
-    public class UserCache
-    {
-        private static ConcurrentDictionary<string, Tuple<User, DateTime>> _Cache = new ConcurrentDictionary<string, Tuple<User, DateTime>>();
-        private const long CacheTimeoutTicks = 6000000000; // 10 Minutes
-        private const string CacheHttpRequestKey = "Disco_CurrentUser";
-
-        public static User CurrentUser
-        {
-            get
-            {
-                string username = null;
-                User user;
-
-                // Check for ASP.NET
-                if (HttpContext.Current != null)
-                {
-                    if (HttpContext.Current.Request.IsAuthenticated)
-                    {
-                        user = (User)HttpContext.Current.Items[CacheHttpRequestKey];
-                        if (user != null)
-                            return user;
-
-                        username = HttpContext.Current.User.Identity.Name;
-                    }
-                    else
-                    {
-                        return null;
-                        //throw new PlatformNotSupportedException("ASP.NET Authentication is not correctly configured");
-                    }
-                }
-
-                // User default User
-                if (username == null)
-                {
-                    username = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
-                }
-
-                user = GetUser(username);
-
-                if (HttpContext.Current != null && HttpContext.Current.Request.IsAuthenticated)
-                {
-                    // Cache in current request
-                    HttpContext.Current.Items[CacheHttpRequestKey] = user;
-                }
-
-                return user;
-            }
-        }
-
-        public static User GetUser(string Username)
-        {
-            // Check Cache
-            User u = TryUserCache(Username);
-
-            if (u == null)
-            {
-                // Load from Repository
-                using (DiscoDataContext dbContext = new DiscoDataContext())
-                {
-                    u = GetUser(Username, dbContext, true);
-                }
-            }
-            return u;
-        }
-
-        public static User GetUser(string Username, DiscoDataContext dbContext, bool ForceRefresh = false)
-        {
-            User u = null;
-
-            // Check Cache
-            if (!ForceRefresh)
-                u = TryUserCache(Username);
-
-            if (u == null)
-            {
-                string username = Username.ToLower();
-                u = UserBI.Utilities.LoadUser(dbContext, username);
-                SetValue(username, u);
-            }
-            return u;
-        }
-
-        private static User TryUserCache(string Username)
-        {
-            string username = Username.ToLower();
-            Tuple<User, DateTime> userRecord;
-            if (_Cache.TryGetValue(username, out userRecord))
-            {
-                if (userRecord.Item2 > DateTime.Now)
-                    return userRecord.Item1;
-                else
-                    _Cache.TryRemove(username, out userRecord);
-            }
-            return null;
-        }
-
-        public static bool InvalidateValue(string Key)
-        {
-            Tuple<User, DateTime> userRecord;
-            return _Cache.TryRemove(Key.ToLower(), out userRecord);
-        }
-
-        private static bool SetValue(string Key, User User)
-        {
-            string key = Key.ToLower();
-            Tuple<User, DateTime> userRecord = new Tuple<User, DateTime>(User, DateTime.Now.AddTicks(CacheTimeoutTicks));
-            if (_Cache.ContainsKey(key))
-            {
-                Tuple<User, DateTime> oldUser;
-                if (_Cache.TryGetValue(key, out oldUser))
-                {
-                    return _Cache.TryUpdate(key, userRecord, oldUser);
-                }
-            }
-            return _Cache.TryAdd(key, userRecord);
-        }
-
-        internal static void CleanStaleCache()
-        {
-            var usernames = _Cache.Keys.ToArray();
-            foreach (string username in usernames)
-            {
-                Tuple<User, DateTime> userRecord;
-                if (_Cache.TryGetValue(username, out userRecord))
-                {
-                    if (userRecord.Item2 <= DateTime.Now)
-                        _Cache.TryRemove(username, out userRecord);
-                }   
-            }
-        }
-    }
-}

Disco.BI/BI/UserBI/Utilities.cs

@@ -1,76 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Disco.Models.Repository;
-using Disco.Data.Repository;
-using Disco.Models.BI.Search;
-using System.Runtime.InteropServices;
-using System.DirectoryServices.ActiveDirectory;
-using Disco.Services.Logging;
-
-namespace Disco.BI.UserBI
-{
-    public static class Utilities
-    {
-
-        public static User LoadUser(DiscoDataContext dbContext, string Username)
-        {
-            // Machine Account ?
-            if (Username.EndsWith("$"))
-            {
-                return Interop.ActiveDirectory.ActiveDirectory.GetMachineAccount(Username).ToRepositoryUser();
-            }
-
-            // User Account
-            User user = null;
-            try
-            {
-                var ADUser = Interop.ActiveDirectory.ActiveDirectory.GetUserAccount(Username);
-                if (ADUser == null)
-                    throw new ArgumentException(string.Format("Invalid Username: '{0}'", Username), "Username");
-                user = ADUser.ToRepositoryUser();
-            }
-            catch (COMException ex)
-            {
-                // If "Server is not operational" then Try Cache
-                if (ex.ErrorCode != -2147016646)
-                {
-                    throw ex;
-                }
-                SystemLog.LogException("Primary Domain Controller Down? Disco.BI.UserBI.Utilities.LoadUser", ex);
-            }
-            catch (ActiveDirectoryOperationException ex)
-            {
-                // Try From Cache...
-                SystemLog.LogException("Primary Domain Controller Down? Disco.BI.UserBI.Utilities.LoadUser", ex);
-            }
-
-            // Update Repository
-            User existingUser;
-            if (user == null)
-            {
-                string username = Username.Contains(@"\") ? Username.Substring(Username.IndexOf(@"\") + 1) : Username;
-                existingUser = dbContext.Users.Find(username);
-                if (existingUser == null)
-                    throw new ArgumentException(string.Format("Invalid User - Not In Disco DB: '{0}'", Username), "Username");
-                else
-                    return existingUser;
-            }
-            existingUser = dbContext.Users.Find(user.Id);
-            if (existingUser == null)
-            {
-                dbContext.Users.Add(user);
-            }
-            else
-            {
-                existingUser.UpdateSelf(user);
-                user = existingUser;
-            }
-            dbContext.SaveChanges();
-
-            return user;
-        }
-
-    }
-}

Disco.BI/Disco.BI.csproj

@@ -46,8 +46,9 @@
     <Reference Include="itextsharp">
       <HintPath>..\Resources\Libraries\iTextSharp\itextsharp.dll</HintPath>
     </Reference>
-    <Reference Include="LumenWorks.Framework.IO">
-      <HintPath>..\..\..\Resources\Libraries\LumenWorks.Framework.IO\LumenWorks.Framework.IO.dll</HintPath>
+    <Reference Include="LumenWorks.Framework.IO, Version=3.8.0.0, Culture=neutral, PublicKeyToken=5ad3ea2f85776344, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\Resources\Libraries\LumenWorks.Framework.IO\LumenWorks.Framework.IO.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.AspNet.SignalR.Core, Version=1.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -70,7 +71,7 @@
     </Reference>
     <Reference Include="Newtonsoft.Json, Version=4.5.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\Newtonsoft.Json.5.0.5\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <HintPath>..\packages\Newtonsoft.Json.5.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="Owin">
       <HintPath>..\packages\Owin.1.0\lib\net40\Owin.dll</HintPath>
@@ -127,6 +128,7 @@
     <Compile Include="BI\DeviceBI\Importing\Import.cs" />
     <Compile Include="BI\DeviceBI\Importing\ImportParseTask.cs" />
     <Compile Include="BI\DeviceBI\Importing\ImportProcessTask.cs" />
+    <Compile Include="BI\DeviceBI\Migration\LogMacAddressImporting.cs" />
     <Compile Include="BI\DeviceBI\Searching.cs" />
     <Compile Include="BI\DisposableImageCollection.cs" />
     <Compile Include="BI\DocumentTemplateBI\DocumentTemplateQRCodeLocationCache.cs" />
@@ -142,10 +144,12 @@
     <Compile Include="BI\Expressions\Extensions\UserExt.cs" />
     <Compile Include="BI\Extensions\AttachmentActionExtensions.cs" />
     <Compile Include="BI\Extensions\AttachmentExtensions.cs" />
+    <Compile Include="BI\Extensions\AuthorizationRoleExtensions.cs" />
     <Compile Include="BI\Extensions\ClientServicesExtensions.cs" />
     <Compile Include="BI\Extensions\DeviceActionExtensions.cs" />
     <Compile Include="BI\Extensions\DeviceBatchExtensions.cs" />
     <Compile Include="BI\Extensions\DeviceCertificateExtensions.cs" />
+    <Compile Include="BI\Extensions\DeviceDetailExtensions.cs" />
     <Compile Include="BI\Extensions\DeviceModelExtensions.cs" />
     <Compile Include="BI\Extensions\DeviceProfileExtensions.cs" />
     <Compile Include="BI\Extensions\JobActionExtensions.cs" />
@@ -173,6 +177,7 @@
     <Compile Include="BI\DocumentTemplateBI\Importer\DocumentImporterLog.cs" />
     <Compile Include="BI\Interop\ActiveDirectory\ActiveDirectory.cs" />
     <Compile Include="BI\Interop\ActiveDirectory\ActiveDirectoryCachedGroups.cs" />
+    <Compile Include="BI\Interop\ActiveDirectory\ActiveDirectoryGroupExtensions.cs" />
     <Compile Include="BI\Interop\ActiveDirectory\ActiveDirectoryHelpers.cs" />
     <Compile Include="BI\Interop\ActiveDirectory\ActiveDirectoryMachineAccountExtensions.cs" />
     <Compile Include="BI\Interop\ActiveDirectory\ActiveDirectoryOrganisationalUnit.cs" />
@@ -184,9 +189,6 @@
     <Compile Include="BI\Interop\MimeTypes.cs" />
     <Compile Include="BI\Interop\Pdf\PdfGenerator.cs" />
     <Compile Include="BI\Interop\Pdf\PdfImporter.cs" />
-    <Compile Include="BI\Interop\PluginServices\IDiscoScheduledTask.cs" />
-    <Compile Include="BI\Interop\PluginServices\Utilities.cs" />
-    <Compile Include="BI\Interop\SignalRHandlers\AdminAuthorizedPersistentConnection.cs" />
     <Compile Include="BI\Interop\SignalRHandlers\AuthorizedPersistentConnection.cs" />
     <Compile Include="BI\Interop\SignalRHandlers\HeldDeviceNotifications.cs" />
     <Compile Include="BI\Interop\SignalRHandlers\LogNotifications.cs" />
@@ -199,9 +201,6 @@
     <Compile Include="BI\JobBI\Statistics\DailyOpenedClosed.cs" />
     <Compile Include="BI\JobBI\Utilities.cs" />
     <Compile Include="BI\UserBI\Searching.cs" />
-    <Compile Include="BI\UserBI\UserCache.cs" />
-    <Compile Include="BI\UserBI\UserCachePruneTask.cs" />
-    <Compile Include="BI\UserBI\Utilities.cs" />
     <Compile Include="BI\Extensions\UtilityExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Properties\Resources.Designer.cs">

Disco.BI/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.2.0725.2249")]
-[assembly: AssemblyFileVersion("1.2.0725.2249")]
+[assembly: AssemblyVersion("1.2.1128.1503")]
+[assembly: AssemblyFileVersion("1.2.1128.1503")]

Disco.BI/packages.config

@@ -6,7 +6,7 @@
   <package id="Microsoft.AspNet.SignalR.SystemWeb" version="1.1.2" targetFramework="net45" />
   <package id="Microsoft.Owin.Host.SystemWeb" version="1.0.1" targetFramework="net45" />
   <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" />
-  <package id="Newtonsoft.Json" version="5.0.5" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="5.0.8" targetFramework="net45" />
   <package id="Owin" version="1.0" targetFramework="net45" />
   <package id="Rx-Core" version="2.1.30214.0" targetFramework="net45" />
   <package id="Rx-Interfaces" version="2.1.30214.0" targetFramework="net45" />

Disco.Client/Disco.Client.csproj

@@ -50,7 +50,7 @@
   <ItemGroup>
     <Reference Include="Newtonsoft.Json, Version=4.5.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\Newtonsoft.Json.5.0.5\lib\net40\Newtonsoft.Json.dll</HintPath>
+      <HintPath>..\packages\Newtonsoft.Json.5.0.8\lib\net40\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -122,7 +122,7 @@
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>
-      <UserProperties BuildVersion_UpdateFileVersion="True" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_BuildVersioningStyle="None.DeltaBaseYear.MonthAndDayStamp.TimeStamp" BuildVersion_BuildAction="Both" BuildVersion_StartDate="2011/7/1" BuildVersion_DetectChanges="False" BuildVersion_UseGlobalSettings="False" />
+      <UserProperties BuildVersion_UseGlobalSettings="False" BuildVersion_DetectChanges="False" BuildVersion_StartDate="2011/7/1" BuildVersion_BuildAction="Both" BuildVersion_BuildVersioningStyle="None.DeltaBaseYear.MonthAndDayStamp.TimeStamp" BuildVersion_UpdateAssemblyVersion="True" BuildVersion_UpdateFileVersion="True" />
     </VisualStudio>
   </ProjectExtensions>
   <PropertyGroup>

Disco.Client/Extensions/EnrolExtensions.cs

@@ -43,7 +43,7 @@ namespace Disco.Client.Extensions
                 throw new ClientServiceException("Enrolment", "Server denied enrolment (Empty Response)");
 
             ErrorReporting.EnrolmentSessionId = enrolResponse.SessionId;
-            
+
             if (!string.IsNullOrEmpty(enrolResponse.ErrorMessage))
                 throw new ClientServiceException("Enrolment", enrolResponse.ErrorMessage);
 
@@ -102,7 +102,8 @@ namespace Disco.Client.Extensions
                 // Flush Logged-On History
                 if (!string.IsNullOrEmpty(enrolResponse.DeviceDomainName))
                 {
-                    using (RegistryKey regWinlogon  = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon", true)){
+                    using (RegistryKey regWinlogon = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon", true))
+                    {
                         regWinlogon.SetValue("DefaultDomainName", enrolResponse.DeviceDomainName, RegistryValueKind.String);
                         regWinlogon.SetValue("DefaultUserName", String.Empty, RegistryValueKind.String);
                     }
@@ -130,9 +131,10 @@ namespace Disco.Client.Extensions
             // Only run task if Assigned User was specified
             if (!string.IsNullOrWhiteSpace(enrolResponse.DeviceAssignedUserSID))
             {
-                Presentation.UpdateStatus("Enrolling Device", string.Format(@"Configuring permissions for the device owner:{0}{1} ({2}\{3})", Environment.NewLine, enrolResponse.DeviceAssignedUserName, enrolResponse.DeviceAssignedUserDomain, enrolResponse.DeviceAssignedUserUsername), true, -1, 3000);
+                Presentation.UpdateStatus("Enrolling Device", string.Format(@"Configuring the device owner:{0}{1} ({2}\{3})", Environment.NewLine, enrolResponse.DeviceAssignedUserName, enrolResponse.DeviceAssignedUserDomain, enrolResponse.DeviceAssignedUserUsername), true, -1, 3000);
 
-                Interop.LocalAuthentication.AddLocalGroupMembership("Administrators", enrolResponse.DeviceAssignedUserSID, enrolResponse.DeviceAssignedUserUsername, enrolResponse.DeviceAssignedUserDomain);
+                if (enrolResponse.DeviceAssignedUserIsLocalAdmin)
+                    Interop.LocalAuthentication.AddLocalGroupMembership("Administrators", enrolResponse.DeviceAssignedUserSID, enrolResponse.DeviceAssignedUserUsername, enrolResponse.DeviceAssignedUserDomain);
 
                 // Make Windows think this user was the last to logon
                 using (RegistryKey regWinlogon = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon", true))
@@ -183,6 +185,6 @@ namespace Disco.Client.Extensions
                 Interop.Certificates.AddCertificate(StoreName.My, StoreLocation.LocalMachine, certPersonal);
             }
         }
-        
+
     }
 }

Disco.Client/Interop/Network.cs

@@ -13,7 +13,7 @@ namespace Disco.Client.Interop
         private static NetworkAdapterInfo PrimaryLanNetworkAdapter { get; set; }
         private static NetworkAdapterInfo PrimaryWlanNetworkAdapter { get; set; }
 
-        static Network()
+        public static void Initialize()
         {
             // Get All Adapters
             RetrieveLanAdapters();
@@ -21,7 +21,15 @@ namespace Disco.Client.Interop
             if (NetworkAdapters.Count > 0)
             {
                 // Only Retrieve Wlan Adapters if at least one adapter was found by WMI
-                RetrieveWlanAdapters();
+                try
+                {
+                    RetrieveWlanAdapters();
+                }
+                catch (DllNotFoundException)
+                {
+                    // Ignore DllNotFoundException
+                    // This which indicates 'Wlanapi.dll' isn't present (eg. Windows Servers)
+                }
 
                 // Determine Primary Adapters
 

Disco.Client/Interop/SystemAudit.cs

@@ -18,7 +18,7 @@ namespace Disco.Client.Interop
         public static string DeviceUUID { get; private set; }
         public static bool DeviceIsPartOfDomain { get; private set; }
 
-        static SystemAudit()
+        public static void Initialize()
         {
             // Get BIOS Information
             try

Disco.Client/Program.cs

@@ -44,7 +44,7 @@ namespace Disco.Client
 
             // Ignore Local Proxies
             WebRequest.DefaultWebProxy = new WebProxy();
-            // Override Http 100 Continue Behavour
+            // Override Http 100 Continue Behaviour
             ServicePointManager.Expect100Continue = false;
 
             // Assume success unless otherwise notified
@@ -59,6 +59,10 @@ namespace Disco.Client
             {
                 Presentation.DelayUI = true; // Add Delays on Error
             }
+
+            // Initialize Interop
+            Interop.SystemAudit.Initialize();
+            Interop.Network.Initialize();
         }
 
         public static bool WhoAmI()

Disco.Client/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.2.0725.2102")]
-[assembly: AssemblyFileVersion("1.2.0725.2102")]
+[assembly: AssemblyVersion("1.2.1128.1503")]
+[assembly: AssemblyFileVersion("1.2.1128.1503")]

Disco.Client/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Newtonsoft.Json" version="5.0.5" targetFramework="net40-Client" />
+  <package id="Newtonsoft.Json" version="5.0.8" targetFramework="net40-Client" />
 </packages>

Disco.ClientBootstrapper/BootstrapperLoop.cs

@@ -149,8 +149,10 @@ namespace Disco.ClientBootstrapper
             // Unzip Client
             statusUI.UpdateStatus(null, "Extracting", "Retrieving Preparation Client, Please wait...", true, -1);
             string clientLocation = Path.Combine(tempWorkingDirectory, "PreparationClient");
-            if (!Directory.Exists(clientLocation))
-                Directory.CreateDirectory(clientLocation);
+            if (Directory.Exists(clientLocation))
+                Directory.Delete(clientLocation, true);
+
+            Directory.CreateDirectory(clientLocation);
             using (var clientSource = Ionic.Zip.ZipFile.Read(clientSourceLocation))
             {
                 clientSource.ExtractAll(clientLocation, Ionic.Zip.ExtractExistingFileAction.OverwriteSilently);

Disco.ClientBootstrapper/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.2.0725.2102")]
-[assembly: AssemblyFileVersion("1.2.0725.2102")]
+[assembly: AssemblyVersion("1.2.1128.1503")]
+[assembly: AssemblyFileVersion("1.2.1128.1503")]

Disco.Data/Configuration/CommunityHelpers.cs

@@ -26,7 +26,7 @@ namespace Disco.Data.Configuration
             catch (Exception)
             { } // Ignore Errors
 
-            return "http://discoict.com.au/base/";
+            return "https://discoict.com.au/base/";
         }
     }
 }

Disco.Data/Configuration/ConfigurationBase.cs

@@ -11,30 +11,30 @@ namespace Disco.Data.Configuration
 {
     public abstract class ConfigurationBase
     {
-        private DiscoDataContext dbContext;
+        private DiscoDataContext Database;
 
         public abstract string Scope { get; }
 
-        public ConfigurationBase(DiscoDataContext dbContext)
+        public ConfigurationBase(DiscoDataContext Database)
         {
-            this.dbContext = dbContext;
+            this.Database = Database;
         }
 
         protected List<ConfigurationItem> Items
         {
             get
             {
-                return ConfigurationCache.GetConfigurationItems(dbContext, this.Scope);
+                return ConfigurationCache.GetConfigurationItems(Database, this.Scope);
             }
         }
 
         private void SetValue<ValueType>(string Key, ValueType Value)
         {
-            ConfigurationCache.SetConfigurationValue(dbContext, this.Scope, Key, Value);
+            ConfigurationCache.SetConfigurationValue(Database, this.Scope, Key, Value);
         }
         private ValueType GetValue<ValueType>(string Key, ValueType Default)
         {
-            return ConfigurationCache.GetConfigurationValue(dbContext, this.Scope, Key, Default);
+            return ConfigurationCache.GetConfigurationValue(Database, this.Scope, Key, Default);
         }
 
         protected void Set<ValueType>(ValueType Value, [CallerMemberName] string Key = null)

Disco.Data/Configuration/ConfigurationCache.cs

@@ -16,7 +16,7 @@ namespace Disco.Data.Configuration
         private static List<ConfigurationItem> configurationItems = new List<ConfigurationItem>();
         private static object configurationItemsLock = new object();
 
-        private static void LoadConfigurationItems(DiscoDataContext dbContext, string Scope, bool Reload)
+        private static void LoadConfigurationItems(DiscoDataContext Database, string Scope, bool Reload)
         {
             if (Reload || !configDictionary.ContainsKey(Scope))
             {
@@ -24,10 +24,10 @@ namespace Disco.Data.Configuration
                 {
                     if (Reload || !configDictionary.ContainsKey(Scope))
                     {
-                        if (dbContext == null)
+                        if (Database == null)
                             throw new InvalidOperationException("Cache-miss where Configuration Item requested from Cache-Only Configuration Context");
 
-                        var newItems = dbContext.ConfigurationItems.Where(ci => ci.Scope == Scope).ToArray();
+                        var newItems = Database.ConfigurationItems.Where(ci => ci.Scope == Scope).ToArray();
 
                         if (configDictionary.ContainsKey(Scope))
                         {
@@ -43,15 +43,15 @@ namespace Disco.Data.Configuration
                 }
             }
         }
-        private static Dictionary<string, Dictionary<string, ConfigurationItem>> ConfigurationDictionary(DiscoDataContext dbContext, string IncludingScope)
+        private static Dictionary<string, Dictionary<string, ConfigurationItem>> ConfigurationDictionary(DiscoDataContext Database, string IncludingScope)
         {
-            LoadConfigurationItems(dbContext, IncludingScope, false);
+            LoadConfigurationItems(Database, IncludingScope, false);
             return configDictionary;
         }
-        private static ConfigurationItem ConfigurationItem(DiscoDataContext dbContext, string Scope, string Key)
+        private static ConfigurationItem ConfigurationItem(DiscoDataContext Database, string Scope, string Key)
         {
             Dictionary<string, ConfigurationItem> scopeDict = default(Dictionary<string, ConfigurationItem>);
-            if (ConfigurationDictionary(dbContext, Scope).TryGetValue(Scope, out scopeDict))
+            if (ConfigurationDictionary(Database, Scope).TryGetValue(Scope, out scopeDict))
             {
                 ConfigurationItem item = default(ConfigurationItem);
                 if (scopeDict.TryGetValue(Key, out item))
@@ -59,42 +59,42 @@ namespace Disco.Data.Configuration
             }
             return null;
         }
-        private static List<ConfigurationItem> ConfigurationItems(DiscoDataContext dbContext, string IncludingScope)
+        private static List<ConfigurationItem> ConfigurationItems(DiscoDataContext Database, string IncludingScope)
         {
-            LoadConfigurationItems(dbContext, IncludingScope, false);
+            LoadConfigurationItems(Database, IncludingScope, false);
             return configurationItems;
         }
 
         #endregion
 
         #region Public Helpers
-        internal static ValueType GetConfigurationValue<ValueType>(DiscoDataContext dbContext, string Scope, string Key, ValueType Default)
+        internal static ValueType GetConfigurationValue<ValueType>(DiscoDataContext Database, string Scope, string Key, ValueType Default)
         {
-            var ci = ConfigurationItem(dbContext, Scope, Key);
+            var ci = ConfigurationItem(Database, Scope, Key);
             if (ci == null)
                 return Default;
             else
                 return (ValueType)Convert.ChangeType(ci.Value, typeof(ValueType));
         }
-        internal static void SetConfigurationValue<ValueType>(DiscoDataContext dbContext, string Scope, string Key, ValueType Value)
+        internal static void SetConfigurationValue<ValueType>(DiscoDataContext Database, string Scope, string Key, ValueType Value)
         {
-            if (dbContext == null)
+            if (Database == null)
                 throw new InvalidOperationException("Cannot save changes with a CacheOnly Context");
 
-            var ci = ConfigurationItem(dbContext, Scope, Key);
+            var ci = ConfigurationItem(Database, Scope, Key);
             if (ci == null && Value != null)
             {
                 lock (configurationItemsLock)
                 {
-                    ci = ConfigurationItem(dbContext, Scope, Key);
+                    ci = ConfigurationItem(Database, Scope, Key);
                     if (ci == null)
                     {
                         // Create Configuration Item
                         ci = new ConfigurationItem() { Scope = Scope, Key = Key, Value = Value.ToString() };
                         // Add Item to DB & Internal Collections
-                        dbContext.ConfigurationItems.Add(ci);
-                        ConfigurationItems(dbContext, Scope).Add(ci);
-                        ConfigurationDictionary(dbContext, Scope)[Scope].Add(Key, ci);
+                        Database.ConfigurationItems.Add(ci);
+                        ConfigurationItems(Database, Scope).Add(ci);
+                        ConfigurationDictionary(Database, Scope)[Scope].Add(Key, ci);
                         ci = null;
                     }
                 }
@@ -103,17 +103,17 @@ namespace Disco.Data.Configuration
             {
                 lock (configurationItemsLock)
                 {
-                    var entityInfo = dbContext.Entry(ci);
+                    var entityInfo = Database.Entry(ci);
                     if (entityInfo.State == System.Data.EntityState.Detached)
                     {
                         // Reload Scope from DB
-                        LoadConfigurationItems(dbContext, Scope, true);
-                        ci = ConfigurationItem(dbContext, Scope, Key);
+                        LoadConfigurationItems(Database, Scope, true);
+                        ci = ConfigurationItem(Database, Scope, Key);
                     }
 
                     if (Value == null)
                     {
-                        dbContext.ConfigurationItems.Remove(ci);
+                        Database.ConfigurationItems.Remove(ci);
                         configurationItems.Remove(ci);
                         configDictionary[Scope].Remove(Key);
                     }
@@ -125,9 +125,9 @@ namespace Disco.Data.Configuration
             }
         }
 
-        internal static List<ConfigurationItem> GetConfigurationItems(DiscoDataContext dbContext, string Scope)
+        internal static List<ConfigurationItem> GetConfigurationItems(DiscoDataContext Database, string Scope)
         {
-            return ConfigurationDictionary(dbContext, Scope)[Scope].Values.ToList();
+            return ConfigurationDictionary(Database, Scope)[Scope].Values.ToList();
         }
 
         internal static string ObsfucateValue(string Value)

Disco.Data/Configuration/Modules/BootstrapperConfiguration.cs

@@ -8,7 +8,7 @@ namespace Disco.Data.Configuration.Modules
 {
     public class BootstrapperConfiguration : ConfigurationBase
     {
-        public BootstrapperConfiguration(DiscoDataContext dbContext) : base(dbContext) { }
+        public BootstrapperConfiguration(DiscoDataContext Database) : base(Database) { }
 
         public override string Scope
         {

Disco.Data/Configuration/Modules/DeviceProfilesConfiguration.cs

@@ -9,7 +9,7 @@ namespace Disco.Data.Configuration.Modules
 {
     public class DeviceProfilesConfiguration : ConfigurationBase
     {
-        public DeviceProfilesConfiguration(DiscoDataContext dbContext) : base(dbContext) { }
+        public DeviceProfilesConfiguration(DiscoDataContext Database) : base(Database) { }
 
         public override string Scope { get { return "DeviceProfiles"; } }
 

Disco.Data/Configuration/Modules/JobPreferencesConfiguration.cs

@@ -0,0 +1,31 @@
+using Disco.Data.Repository;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Disco.Data.Configuration.Modules
+{
+    public class JobPreferencesConfiguration : ConfigurationBase
+    {
+        public JobPreferencesConfiguration(DiscoDataContext Database) : base(Database) { }
+
+        public override string Scope { get { return "JobPreferences"; } }
+
+        /// <summary>
+        /// Number of days a job is open before it is considered 'Long Running'
+        /// </summary>
+        public int LongRunningJobDaysThreshold
+        {
+            get { return Get<int>(7); }
+            set
+            {
+                if (value < 0)
+                    throw new ArgumentOutOfRangeException("value", "The Long Running Job Days Threshold cannot be less than zero");
+
+                Set(value);
+            }
+        }
+    }
+}

Disco.Data/Configuration/Modules/OrganisationAddressesConfiguration.cs

@@ -11,7 +11,7 @@ namespace Disco.Data.Configuration.Modules
 {
     public class OrganisationAddressesConfiguration : ConfigurationBase
     {
-        public OrganisationAddressesConfiguration(DiscoDataContext dbContext) : base(dbContext) { }
+        public OrganisationAddressesConfiguration(DiscoDataContext Database) : base(Database) { }
 
         public override string Scope { get { return "OrganisationAddresses"; } }
 

Disco.Data/Configuration/SystemConfiguration.cs

@@ -13,13 +13,14 @@ namespace Disco.Data.Configuration
 {
     public class SystemConfiguration : ConfigurationBase
     {
-        public SystemConfiguration(DiscoDataContext dbContext)
-            : base(dbContext)
+        public SystemConfiguration(DiscoDataContext Database)
+            : base(Database)
         {
             // Init Modules
-            this.moduleBootstrapperConfiguration = new Lazy<Modules.BootstrapperConfiguration>(() => new Modules.BootstrapperConfiguration(dbContext));
-            this.moduleDeviceProfilesConfiguration = new Lazy<Modules.DeviceProfilesConfiguration>(() => new Modules.DeviceProfilesConfiguration(dbContext));
-            this.moduleOrganisationAddressesConfiguration = new Lazy<Modules.OrganisationAddressesConfiguration>(() => new Modules.OrganisationAddressesConfiguration(dbContext));
+            this.moduleBootstrapperConfiguration = new Lazy<Modules.BootstrapperConfiguration>(() => new Modules.BootstrapperConfiguration(Database));
+            this.moduleDeviceProfilesConfiguration = new Lazy<Modules.DeviceProfilesConfiguration>(() => new Modules.DeviceProfilesConfiguration(Database));
+            this.moduleOrganisationAddressesConfiguration = new Lazy<Modules.OrganisationAddressesConfiguration>(() => new Modules.OrganisationAddressesConfiguration(Database));
+            this.moduleJobPreferencesConfiguration = new Lazy<Modules.JobPreferencesConfiguration>(() => new Modules.JobPreferencesConfiguration(Database));
         }
 
         #region Configuration Modules
@@ -27,6 +28,7 @@ namespace Disco.Data.Configuration
         private Lazy<Modules.BootstrapperConfiguration> moduleBootstrapperConfiguration;
         private Lazy<Modules.DeviceProfilesConfiguration> moduleDeviceProfilesConfiguration;
         private Lazy<Modules.OrganisationAddressesConfiguration> moduleOrganisationAddressesConfiguration;
+        private Lazy<Modules.JobPreferencesConfiguration> moduleJobPreferencesConfiguration;
 
         public Modules.BootstrapperConfiguration Bootstrapper
         {
@@ -49,6 +51,13 @@ namespace Disco.Data.Configuration
                 return moduleOrganisationAddressesConfiguration.Value;
             }
         }
+        public Modules.JobPreferencesConfiguration JobPreferences
+        {
+            get
+            {
+                return moduleJobPreferencesConfiguration.Value;
+            }
+        }
 
         #endregion
 

Disco.Data/Disco.Data.csproj

@@ -42,7 +42,7 @@
     </Reference>
     <Reference Include="Newtonsoft.Json, Version=4.5.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\packages\Newtonsoft.Json.5.0.5\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <HintPath>..\packages\Newtonsoft.Json.5.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.ComponentModel.DataAnnotations" />
@@ -72,6 +72,7 @@
     <Compile Include="Configuration\CommunityHelpers.cs" />
     <Compile Include="Configuration\ConfigurationBase.cs" />
     <Compile Include="Configuration\ConfigurationCache.cs" />
+    <Compile Include="Configuration\Modules\JobPreferencesConfiguration.cs" />
     <Compile Include="Configuration\SystemConfiguration.cs" />
     <Compile Include="Configuration\Modules\BootstrapperConfiguration.cs" />
     <Compile Include="Configuration\Modules\DeviceProfileConfiguration.cs" />
@@ -109,6 +110,22 @@
     <Compile Include="Migrations\201302210057463_DBv7.Designer.cs">
       <DependentUpon>201302210057463_DBv7.cs</DependentUpon>
     </Compile>
+    <Compile Include="Migrations\201309050648129_DBv8.cs" />
+    <Compile Include="Migrations\201309050648129_DBv8.Designer.cs">
+      <DependentUpon>201309050648129_DBv8.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Migrations\201310010352238_DBv9.cs" />
+    <Compile Include="Migrations\201310010352238_DBv9.Designer.cs">
+      <DependentUpon>201310010352238_DBv9.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Migrations\201310280657528_DBv10.cs" />
+    <Compile Include="Migrations\201310280657528_DBv10.Designer.cs">
+      <DependentUpon>201310280657528_DBv10.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Migrations\201310282325491_DBv11.cs" />
+    <Compile Include="Migrations\201310282325491_DBv11.Designer.cs">
+      <DependentUpon>201310282325491_DBv11.cs</DependentUpon>
+    </Compile>
     <Compile Include="Migrations\Configuration.cs" />
     <Compile Include="Migrations\DiscoDataMigrator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -119,7 +136,6 @@
     </Compile>
     <Compile Include="Repository\DiscoDatabaseConnectionFactory.cs" />
     <Compile Include="Repository\DiscoDataContext.cs" />
-    <Compile Include="Repository\DiscoDataContextInitializer.cs" />
     <Compile Include="Repository\DiscoDataSeeder.cs" />
     <Compile Include="Repository\Monitor\RepositoryMonitor.cs" />
     <Compile Include="Repository\Monitor\RepositoryMonitorEvent.cs" />
@@ -146,6 +162,18 @@
     <EmbeddedResource Include="Migrations\201302210057463_DBv7.resx">
       <DependentUpon>201302210057463_DBv7.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="Migrations\201309050648129_DBv8.resx">
+      <DependentUpon>201309050648129_DBv8.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Migrations\201310010352238_DBv9.resx">
+      <DependentUpon>201310010352238_DBv9.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Migrations\201310280657528_DBv10.resx">
+      <DependentUpon>201310280657528_DBv10.cs</DependentUpon>
+    </EmbeddedResource>
+    <EmbeddedResource Include="Migrations\201310282325491_DBv11.resx">
+      <DependentUpon>201310282325491_DBv11.cs</DependentUpon>
+    </EmbeddedResource>
     <EmbeddedResource Include="Properties\Resources.resx">
       <Generator>ResXFileCodeGenerator</Generator>
       <LastGenOutput>Resources.Designer.cs</LastGenOutput>

Disco.Data/Migrations/201309050648129_DBv8.Designer.cs

@@ -0,0 +1,27 @@
+// <auto-generated />
+namespace Disco.Data.Migrations
+{
+    using System.Data.Entity.Migrations;
+    using System.Data.Entity.Migrations.Infrastructure;
+    using System.Resources;
+    
+    public sealed partial class DBv8 : IMigrationMetadata
+    {
+        private readonly ResourceManager Resources = new ResourceManager(typeof(DBv8));
+        
+        string IMigrationMetadata.Id
+        {
+            get { return "201309050648129_DBv8"; }
+        }
+        
+        string IMigrationMetadata.Source
+        {
+            get { return null; }
+        }
+        
+        string IMigrationMetadata.Target
+        {
+            get { return Resources.GetString("Target"); }
+        }
+    }
+}

Disco.Data/Migrations/201309050648129_DBv8.cs

@@ -0,0 +1,21 @@
+namespace Disco.Data.Migrations
+{
+    using System;
+    using System.Data.Entity.Migrations;
+    
+    public partial class DBv8 : DbMigration
+    {
+        public override void Up()
+        {
+            AddColumn("dbo.Devices", "DecommissionReason", c => c.Int());
+
+            // Set DecommissionedReason to default ('End Of Life') for any previously decommissioned devices.
+            Sql("UPDATE dbo.Devices SET DecommissionReason=0 WHERE NOT DecommissionedDate IS NULL");
+        }
+        
+        public override void Down()
+        {
+            DropColumn("dbo.Devices", "DecommissionReason");
+        }
+    }
+}

Disco.Data/Migrations/201310010352238_DBv9.Designer.cs

@@ -0,0 +1,27 @@
+// <auto-generated />
+namespace Disco.Data.Migrations
+{
+    using System.Data.Entity.Migrations;
+    using System.Data.Entity.Migrations.Infrastructure;
+    using System.Resources;
+    
+    public sealed partial class DBv9 : IMigrationMetadata
+    {
+        private readonly ResourceManager Resources = new ResourceManager(typeof(DBv9));
+        
+        string IMigrationMetadata.Id
+        {
+            get { return "201310010352238_DBv9"; }
+        }
+        
+        string IMigrationMetadata.Source
+        {
+            get { return null; }
+        }
+        
+        string IMigrationMetadata.Target
+        {
+            get { return Resources.GetString("Target"); }
+        }
+    }
+}

Disco.Data/Migrations/201310010352238_DBv9.cs

@@ -0,0 +1,30 @@
+namespace Disco.Data.Migrations
+{
+    using System;
+    using System.Data.Entity.Migrations;
+    
+    public partial class DBv9 : DbMigration
+    {
+        public override void Up()
+        {
+            CreateTable(
+                "dbo.AuthorizationRoles",
+                c => new
+                    {
+                        Id = c.Int(nullable: false, identity: true),
+                        Name = c.String(nullable: false, maxLength: 100),
+                        SubjectIds = c.String(),
+                        ClaimsJson = c.String(),
+                    })
+                .PrimaryKey(t => t.Id);
+            
+            DropColumn("dbo.Users", "Type");
+        }
+        
+        public override void Down()
+        {
+            AddColumn("dbo.Users", "Type", c => c.String(maxLength: 8));
+            DropTable("dbo.AuthorizationRoles");
+        }
+    }
+}

Disco.Data/Migrations/201310280657528_DBv10.Designer.cs

@@ -0,0 +1,27 @@
+// <auto-generated />
+namespace Disco.Data.Migrations
+{
+    using System.Data.Entity.Migrations;
+    using System.Data.Entity.Migrations.Infrastructure;
+    using System.Resources;
+    
+    public sealed partial class DBv10 : IMigrationMetadata
+    {
+        private readonly ResourceManager Resources = new ResourceManager(typeof(DBv10));
+        
+        string IMigrationMetadata.Id
+        {
+            get { return "201310280657528_DBv10"; }
+        }
+        
+        string IMigrationMetadata.Source
+        {
+            get { return null; }
+        }
+        
+        string IMigrationMetadata.Target
+        {
+            get { return Resources.GetString("Target"); }
+        }
+    }
+}

Disco.Data/Migrations/201310280657528_DBv10.cs

@@ -0,0 +1,18 @@
+namespace Disco.Data.Migrations
+{
+    using System;
+    using System.Data.Entity.Migrations;
+    
+    public partial class DBv10 : DbMigration
+    {
+        public override void Up()
+        {
+            AddColumn("dbo.DeviceProfiles", "AssignedUserLocalAdmin", c => c.Boolean(nullable: false, defaultValue: true));
+        }
+        
+        public override void Down()
+        {
+            DropColumn("dbo.DeviceProfiles", "AssignedUserLocalAdmin");
+        }
+    }
+}

Disco.Data/Migrations/201310282325491_DBv11.Designer.cs

@@ -0,0 +1,27 @@
+// <auto-generated />
+namespace Disco.Data.Migrations
+{
+    using System.Data.Entity.Migrations;
+    using System.Data.Entity.Migrations.Infrastructure;
+    using System.Resources;
+    
+    public sealed partial class DBv11 : IMigrationMetadata
+    {
+        private readonly ResourceManager Resources = new ResourceManager(typeof(DBv11));
+        
+        string IMigrationMetadata.Id
+        {
+            get { return "201310282325491_DBv11"; }
+        }
+        
+        string IMigrationMetadata.Source
+        {
+            get { return null; }
+        }
+        
+        string IMigrationMetadata.Target
+        {
+            get { return Resources.GetString("Target"); }
+        }
+    }
+}

Disco.Data/Migrations/201310282325491_DBv11.cs

@@ -0,0 +1,18 @@
+namespace Disco.Data.Migrations
+{
+    using System;
+    using System.Data.Entity.Migrations;
+    
+    public partial class DBv11 : DbMigration
+    {
+        public override void Up()
+        {
+            AddColumn("dbo.DeviceProfiles", "AllowUntrustedReimageJobEnrolment", c => c.Boolean(nullable: false, defaultValue: false));
+        }
+        
+        public override void Down()
+        {
+            DropColumn("dbo.DeviceProfiles", "AllowUntrustedReimageJobEnrolment");
+        }
+    }
+}

Disco.Data/Migrations/Configuration.cs

@@ -13,9 +13,9 @@ namespace Disco.Data.Migrations
             AutomaticMigrationsEnabled = false;
         }
 
-        protected override void Seed(DiscoDataContext context)
+        protected override void Seed(DiscoDataContext Database)
         {
-            context.SeedDatabase();
+            Database.SeedDatabase();
         }
     }
 }

Disco.Data/Migrations/DiscoDataMigrator.cs

@@ -49,12 +49,12 @@ namespace Disco.Data.Migrations
         public static void SeedDatabase()
         {
             // Seed/Update Database
-            using (DiscoDataContext dbContext = new DiscoDataContext())
+            using (DiscoDataContext database = new DiscoDataContext())
             {
-                dbContext.SeedDatabase();
+                database.SeedDatabase();
                 try
                 {
-                    dbContext.SaveChanges();
+                    database.SaveChanges();
                 }
                 catch (Exception ex)
                 {

Disco.Data/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.2.0725.2249")]
-[assembly: AssemblyFileVersion("1.2.0725.2249")]
+[assembly: AssemblyVersion("1.2.1128.1503")]
+[assembly: AssemblyFileVersion("1.2.1128.1503")]

Disco.Data/Repository/DiscoDataContext.cs

@@ -23,6 +23,7 @@ namespace Disco.Data.Repository
 
         public virtual DbSet<User> Users { get; set; }
         public virtual DbSet<UserAttachment> UserAttachments { get; set; }
+        public virtual DbSet<AuthorizationRole> AuthorizationRoles { get; set; }
 
         public virtual DbSet<DeviceUserAssignment> DeviceUserAssignments { get; set; }
 
@@ -65,7 +66,6 @@ namespace Disco.Data.Repository
             modelBuilder.Entity<Job>().HasMany(m => m.JobSubTypes).WithMany(m => m.Jobs).Map(m => m.ToTable("Jobs_JobSubTypes"));
             modelBuilder.Entity<User>().HasMany(m => m.Jobs).WithOptional(m => m.User);
             modelBuilder.Entity<Device>().HasMany(m => m.Jobs).WithOptional(m => m.Device);
-            modelBuilder.Entity<DeviceProfile>().Property(DeviceProfile.PropertyAccessExpressions.DistributionTypeDb);
         }
 
         // Hook for Repository Monitor

Disco.Data/Repository/DiscoDataContextInitializer.cs

@@ -1,19 +0,0 @@
-// Shouldn't Need this => Moved to Entity Migrations...
-
-//using System;
-//using System.Collections.Generic;
-//using System.Linq;
-//using System.Text;
-//using System.Data.Entity;
-
-//namespace Disco.Data.Repository
-//{
-//    class DiscoDataContextInitializer : CreateDatabaseIfNotExists<DiscoDataContext>
-//    {
-//        protected override void Seed(DiscoDataContext context)
-//        {
-//            context.SeedDatabase();
-//            context.SaveChanges();
-//        }
-//    }
-//}

Disco.Data/Repository/DiscoDataSeeder.cs

@@ -8,215 +8,232 @@ namespace Disco.Data.Repository
 {
     public static class DiscoDataSeeder
     {
-        public static void SeedDatabase(this DiscoDataContext context)
+        public static void SeedDatabase(this DiscoDataContext Database)
         {
-            context.SeedDeploymentId();
-            context.SeedDeviceModels();
-            context.SeedDeviceProfiles();
-            context.SeedJobTypes();
-            context.SeedJobSubTypes();
+            Database.SeedDeploymentId();
+            Database.SeedDeviceModels();
+            Database.SeedDeviceProfiles();
+            Database.SeedJobTypes();
+            Database.SeedJobSubTypes();
         }
 
-        public static void SeedDeploymentId(this DiscoDataContext context)
+        public static void SeedDeploymentId(this DiscoDataContext Database)
         {
-            if (context.ConfigurationItems.Count(ci => ci.Scope == "System" && ci.Key == "DeploymentId") == 0)
+            if (Database.ConfigurationItems.Count(ci => ci.Scope == "System" && ci.Key == "DeploymentId") == 0)
             {
                 var deploymentId = Guid.NewGuid().ToString("D");
-                context.ConfigurationItems.Add(new ConfigurationItem { Scope = "System", Key = "DeploymentId", Value = deploymentId });
+                Database.ConfigurationItems.Add(new ConfigurationItem { Scope = "System", Key = "DeploymentId", Value = deploymentId });
             }
         }
-        public static void SeedJobTypes(this DiscoDataContext context)
+        public static void SeedJobTypes(this DiscoDataContext Database)
         {
-            if (context.JobTypes.Count() == 0)
+            if (Database.JobTypes.Count() == 0)
             {
-                context.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.HWar, Description = "Hardware - Warranty" });
-                context.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.HNWar, Description = "Hardware - Non-Warranty" });
-                context.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.HMisc, Description = "Hardware - Misc" });
-                context.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.SImg, Description = "Software - Reimage" });
-                context.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.SApp, Description = "Software - Application" });
-                context.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.SOS, Description = "Software - Operating System" });
+                Database.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.HWar, Description = "Hardware - Warranty" });
+                Database.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.HNWar, Description = "Hardware - Non-Warranty" });
+                Database.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.HMisc, Description = "Hardware - Misc" });
+                Database.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.SImg, Description = "Software - Reimage" });
+                Database.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.SApp, Description = "Software - Application" });
+                Database.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.SOS, Description = "Software - Operating System" });
             }
             // 2012-05-22
             #region "User Management" Added
-            if (context.JobTypes.Count(jt => jt.Id == JobType.JobTypeIds.UMgmt) == 0)
-                context.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.UMgmt, Description = "User - Management" });
+            if (Database.JobTypes.Count(jt => jt.Id == JobType.JobTypeIds.UMgmt) == 0)
+                Database.JobTypes.Add(new JobType { Id = JobType.JobTypeIds.UMgmt, Description = "User - Management" });
             #endregion
             // End
         }
-        public static void SeedDeviceModels(this DiscoDataContext context)
+        public static void SeedDeviceModels(this DiscoDataContext Database)
         {
-            if (context.DeviceModels.Count() == 0)
+            if (Database.DeviceModels.Count() == 0)
             {
-                context.DeviceModels.Add(new DeviceModel { Manufacturer = "Unknown", Model = "Unknown", Description = "Unknown Device Model" });
+                Database.DeviceModels.Add(new DeviceModel { Manufacturer = "Unknown", Model = "Unknown", Description = "Unknown Device Model" });
             }
-            UpdateDeviceModelConfiguration(context);
+            UpdateDeviceModelConfiguration(Database);
             // Removed: 2013-01-14 G#
             //UpdateDeviceModelImageStorage(context);
 
             // Added: 2013-02-07 G#
-            UpdateDeviceModelDuplicates(context);
+            UpdateDeviceModelDuplicates(Database);
         }
-        public static void SeedDeviceProfiles(this DiscoDataContext context)
+        public static void SeedDeviceProfiles(this DiscoDataContext Database)
         {
-            if (context.DeviceProfiles.Count() == 0)
+            if (Database.DeviceProfiles.Count() == 0)
             {
-                context.DeviceProfiles.Add(new DeviceProfile { ShortName = "WS", Name = "Default", Description = "Initial Default Workstation Profile", ComputerNameTemplate = "DeviceProfile.ShortName + ''-'' + SerialNumber" });
+                Database.DeviceProfiles.Add(
+                    new DeviceProfile
+                    {
+                        ShortName = "WS",
+                        Name = "Default",
+                        Description = "Initial Default Workstation Profile",
+                        ComputerNameTemplate = "DeviceProfile.ShortName + ''-'' + SerialNumber",
+                        DistributionType = DeviceProfile.DistributionTypes.OneToMany
+                    });
             }
         }
-        public static void SeedJobSubTypes(this DiscoDataContext context)
+        public static void SeedJobSubTypes(this DiscoDataContext Database)
         {
-            if (context.JobSubTypes.Count() == 0)
+            if (Database.JobSubTypes.Count() == 0)
             {
-                context.JobSubTypes.Add(new JobSubType { Id = "Bag", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bag" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Battery", JobTypeId = JobType.JobTypeIds.HWar, Description = "Battery" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelCaseBottom", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Case Bottom" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelCaseTop", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Case Top" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelScreenInner", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Screen Inner" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelScreenTop", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Screen Top" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BluetoothAdapter", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bluetooth Adapter" });
-                context.JobSubTypes.Add(new JobSubType { Id = "CPU", JobTypeId = JobType.JobTypeIds.HWar, Description = "CPU" });
-                context.JobSubTypes.Add(new JobSubType { Id = "HardDrive", JobTypeId = JobType.JobTypeIds.HWar, Description = "Hard Drive" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Keyboard", JobTypeId = JobType.JobTypeIds.HWar, Description = "Keyboard" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Motherboard", JobTypeId = JobType.JobTypeIds.HWar, Description = "Motherboard" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Mouse", JobTypeId = JobType.JobTypeIds.HWar, Description = "Mouse/Track Pad" });
-                context.JobSubTypes.Add(new JobSubType { Id = "PowerAdapter", JobTypeId = JobType.JobTypeIds.HWar, Description = "Power Adapter" });
-                context.JobSubTypes.Add(new JobSubType { Id = "PowerCord", JobTypeId = JobType.JobTypeIds.HWar, Description = "Power Cord/Socket" });
-                context.JobSubTypes.Add(new JobSubType { Id = "RAM", JobTypeId = JobType.JobTypeIds.HWar, Description = "RAM" });
-                context.JobSubTypes.Add(new JobSubType { Id = "ReplacementDevice", JobTypeId = JobType.JobTypeIds.HWar, Description = "Replacement Device" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Screen", JobTypeId = JobType.JobTypeIds.HWar, Description = "Screen" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Speakers", JobTypeId = JobType.JobTypeIds.HWar, Description = "Speakers" });
-                context.JobSubTypes.Add(new JobSubType { Id = "WebCamera", JobTypeId = JobType.JobTypeIds.HWar, Description = "Web Camera" });
-                context.JobSubTypes.Add(new JobSubType { Id = "WirelessAdapter", JobTypeId = JobType.JobTypeIds.HWar, Description = "Wireless Adapter" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.HWar, Description = "Other" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Bag", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bag" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Battery", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Battery" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelCaseBottom", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Case Bottom" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelCaseTop", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Case Top" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelScreenInner", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Screen Inner" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelScreenTop", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Screen Top" });
-                context.JobSubTypes.Add(new JobSubType { Id = "BluetoothAdapter", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bluetooth Adapter" });
-                context.JobSubTypes.Add(new JobSubType { Id = "CPU", JobTypeId = JobType.JobTypeIds.HNWar, Description = "CPU" });
-                context.JobSubTypes.Add(new JobSubType { Id = "HardDrive", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Hard Drive" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Keyboard", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Keyboard" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Motherboard", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Motherboard" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Mouse", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Mouse/Track Pad" });
-                context.JobSubTypes.Add(new JobSubType { Id = "PowerAdapter", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Power Adapter" });
-                context.JobSubTypes.Add(new JobSubType { Id = "PowerCord", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Power Cord/Socket" });
-                context.JobSubTypes.Add(new JobSubType { Id = "RAM", JobTypeId = JobType.JobTypeIds.HNWar, Description = "RAM" });
-                context.JobSubTypes.Add(new JobSubType { Id = "ReplacementDevice", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Replacement Device" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Screen", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Screen" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Speakers", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Speakers" });
-                context.JobSubTypes.Add(new JobSubType { Id = "WebCamera", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Web Camera" });
-                context.JobSubTypes.Add(new JobSubType { Id = "WirelessAdapter", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Wireless Adapter" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Other" });
-                context.JobSubTypes.Add(new JobSubType { Id = "ExternalHardDrive", JobTypeId = JobType.JobTypeIds.HMisc, Description = "External Hard Drive" });
-                context.JobSubTypes.Add(new JobSubType { Id = "IWB", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Interactive Whiteboard" });
-                context.JobSubTypes.Add(new JobSubType { Id = "InternetDongle", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Internet Dongle" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Keyboard", JobTypeId = JobType.JobTypeIds.HMisc, Description = "External Keyboard" });
-                context.JobSubTypes.Add(new JobSubType { Id = "MobilePhone", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Mobile Phone" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Mouse", JobTypeId = JobType.JobTypeIds.HMisc, Description = "External Mouse" });
-                context.JobSubTypes.Add(new JobSubType { Id = "MP3Player", JobTypeId = JobType.JobTypeIds.HMisc, Description = "MP3 Player" });
-                context.JobSubTypes.Add(new JobSubType { Id = "PrinterScanner", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Printer/Scanner" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Projector", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Projector" });
-                context.JobSubTypes.Add(new JobSubType { Id = "USBFlashDrive", JobTypeId = JobType.JobTypeIds.HMisc, Description = "USB Flash Drive" });
-                context.JobSubTypes.Add(new JobSubType { Id = "WebCamera", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Web Camera" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Other" });
-                context.JobSubTypes.Add(new JobSubType { Id = "ContentIllegal", JobTypeId = JobType.JobTypeIds.SImg, Description = "Content - Illegal" });
-                context.JobSubTypes.Add(new JobSubType { Id = "ContentInappropriate", JobTypeId = JobType.JobTypeIds.SImg, Description = "Content - Inappropriate" });
-                context.JobSubTypes.Add(new JobSubType { Id = "CorruptOS", JobTypeId = JobType.JobTypeIds.SImg, Description = "Corrupt Operating System" });
-                context.JobSubTypes.Add(new JobSubType { Id = "HardwareChanges", JobTypeId = JobType.JobTypeIds.SImg, Description = "Hardware Changes" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Malware", JobTypeId = JobType.JobTypeIds.SImg, Description = "Malware" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Performance", JobTypeId = JobType.JobTypeIds.SImg, Description = "Performance" });
-                context.JobSubTypes.Add(new JobSubType { Id = "UserRequest", JobTypeId = JobType.JobTypeIds.SImg, Description = "User Request" });
-                context.JobSubTypes.Add(new JobSubType { Id = "UpdatedImage", JobTypeId = JobType.JobTypeIds.SImg, Description = "Updated Image" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.SImg, Description = "Other" });
-                context.JobSubTypes.Add(new JobSubType { Id = "CurriculumTool", JobTypeId = JobType.JobTypeIds.SApp, Description = "Curriculum Tool" });
-                context.JobSubTypes.Add(new JobSubType { Id = "GamingEntertainment", JobTypeId = JobType.JobTypeIds.SApp, Description = "Gaming/Entertainment" });
-                context.JobSubTypes.Add(new JobSubType { Id = "ImageManipulation", JobTypeId = JobType.JobTypeIds.SApp, Description = "Image Manipulation" });
-                context.JobSubTypes.Add(new JobSubType { Id = "MultimediaPlayback", JobTypeId = JobType.JobTypeIds.SApp, Description = "Multimedia Playback" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Presentation", JobTypeId = JobType.JobTypeIds.SApp, Description = "Presentation" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Spreadsheet", JobTypeId = JobType.JobTypeIds.SApp, Description = "Spreadsheet" });
-                context.JobSubTypes.Add(new JobSubType { Id = "StaffTool", JobTypeId = JobType.JobTypeIds.SApp, Description = "Staff Tool" });
-                context.JobSubTypes.Add(new JobSubType { Id = "StudentReporting", JobTypeId = JobType.JobTypeIds.SApp, Description = "Student Reporting" });
-                context.JobSubTypes.Add(new JobSubType { Id = "VideoEditing", JobTypeId = JobType.JobTypeIds.SApp, Description = "Video Editing" });
-                context.JobSubTypes.Add(new JobSubType { Id = "WebBrowser", JobTypeId = JobType.JobTypeIds.SApp, Description = "Web Browser" });
-                context.JobSubTypes.Add(new JobSubType { Id = "WebBrowserPlugin", JobTypeId = JobType.JobTypeIds.SApp, Description = "Web Browser Plugin" });
-                context.JobSubTypes.Add(new JobSubType { Id = "WordProcessing", JobTypeId = JobType.JobTypeIds.SApp, Description = "Word Processing" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.SApp, Description = "Other" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Appearance", JobTypeId = JobType.JobTypeIds.SOS, Description = "Appearance & Personalisation" });
-                context.JobSubTypes.Add(new JobSubType { Id = "DisplaySettings", JobTypeId = JobType.JobTypeIds.SOS, Description = "Display Settings" });
-                context.JobSubTypes.Add(new JobSubType { Id = "DriversIWB", JobTypeId = JobType.JobTypeIds.SOS, Description = "Drivers - Interactive Whiteboard" });
-                context.JobSubTypes.Add(new JobSubType { Id = "DriversPrintScan", JobTypeId = JobType.JobTypeIds.SOS, Description = "Drivers - Printers/Scanners" });
-                context.JobSubTypes.Add(new JobSubType { Id = "DriversSystem", JobTypeId = JobType.JobTypeIds.SOS, Description = "Drivers - System" });
-                context.JobSubTypes.Add(new JobSubType { Id = "DriversOther", JobTypeId = JobType.JobTypeIds.SOS, Description = "Drivers - Other" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Group Policy", JobTypeId = JobType.JobTypeIds.SOS, Description = "Group Policy" });
-                context.JobSubTypes.Add(new JobSubType { Id = "KeyboardMouseConfig", JobTypeId = JobType.JobTypeIds.SOS, Description = "Keyboard/Mouse Configuration" });
-                context.JobSubTypes.Add(new JobSubType { Id = "MalwareProtection", JobTypeId = JobType.JobTypeIds.SOS, Description = "Malware Protection" });
-                context.JobSubTypes.Add(new JobSubType { Id = "NetworkDrives", JobTypeId = JobType.JobTypeIds.SOS, Description = "Network Drives" });
-                context.JobSubTypes.Add(new JobSubType { Id = "NetworkWired", JobTypeId = JobType.JobTypeIds.SOS, Description = "Network - Wired" });
-                context.JobSubTypes.Add(new JobSubType { Id = "NetworkWireless", JobTypeId = JobType.JobTypeIds.SOS, Description = "Network - Wireless" });
-                context.JobSubTypes.Add(new JobSubType { Id = "NetworkOther", JobTypeId = JobType.JobTypeIds.SOS, Description = "Network - Other" });
-                context.JobSubTypes.Add(new JobSubType { Id = "PatchUpdate", JobTypeId = JobType.JobTypeIds.SOS, Description = "Patches/Updates" });
-                context.JobSubTypes.Add(new JobSubType { Id = "PowerManagement", JobTypeId = JobType.JobTypeIds.SOS, Description = "Power Management" });
-                context.JobSubTypes.Add(new JobSubType { Id = "PrintersScanners", JobTypeId = JobType.JobTypeIds.SOS, Description = "Printers/Scanners" });
-                context.JobSubTypes.Add(new JobSubType { Id = "SoundConfig", JobTypeId = JobType.JobTypeIds.SOS, Description = "Sound Configuration" });
-                context.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.SOS, Description = "Other" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Bag", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bag" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Battery", JobTypeId = JobType.JobTypeIds.HWar, Description = "Battery" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelCaseBottom", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Case Bottom" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelCaseTop", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Case Top" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelScreenInner", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Screen Inner" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelScreenTop", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Screen Top" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BluetoothAdapter", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bluetooth Adapter" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "CPU", JobTypeId = JobType.JobTypeIds.HWar, Description = "CPU" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "HardDrive", JobTypeId = JobType.JobTypeIds.HWar, Description = "Hard Drive" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Keyboard", JobTypeId = JobType.JobTypeIds.HWar, Description = "Keyboard" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Motherboard", JobTypeId = JobType.JobTypeIds.HWar, Description = "Motherboard" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Mouse", JobTypeId = JobType.JobTypeIds.HWar, Description = "Mouse/Track Pad" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "PowerAdapter", JobTypeId = JobType.JobTypeIds.HWar, Description = "Power Adapter" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "PowerCord", JobTypeId = JobType.JobTypeIds.HWar, Description = "Power Cord/Socket" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "RAM", JobTypeId = JobType.JobTypeIds.HWar, Description = "RAM" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "ReplacementDevice", JobTypeId = JobType.JobTypeIds.HWar, Description = "Replacement Device" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Screen", JobTypeId = JobType.JobTypeIds.HWar, Description = "Screen" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Speakers", JobTypeId = JobType.JobTypeIds.HWar, Description = "Speakers" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "WebCamera", JobTypeId = JobType.JobTypeIds.HWar, Description = "Web Camera" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "WirelessAdapter", JobTypeId = JobType.JobTypeIds.HWar, Description = "Wireless Adapter" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.HWar, Description = "Other" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Bag", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bag" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Battery", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Battery" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelCaseBottom", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Case Bottom" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelCaseTop", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Case Top" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelScreenInner", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Screen Inner" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelScreenTop", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Screen Top" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "BluetoothAdapter", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bluetooth Adapter" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "CPU", JobTypeId = JobType.JobTypeIds.HNWar, Description = "CPU" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "HardDrive", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Hard Drive" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Keyboard", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Keyboard" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Motherboard", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Motherboard" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Mouse", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Mouse/Track Pad" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "PowerAdapter", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Power Adapter" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "PowerCord", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Power Cord/Socket" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "RAM", JobTypeId = JobType.JobTypeIds.HNWar, Description = "RAM" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "ReplacementDevice", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Replacement Device" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Screen", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Screen" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Speakers", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Speakers" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "WebCamera", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Web Camera" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "WirelessAdapter", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Wireless Adapter" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Other" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "ExternalHardDrive", JobTypeId = JobType.JobTypeIds.HMisc, Description = "External Hard Drive" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "IWB", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Interactive Whiteboard" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "InternetDongle", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Internet Dongle" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Keyboard", JobTypeId = JobType.JobTypeIds.HMisc, Description = "External Keyboard" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "MobilePhone", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Mobile Phone" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Mouse", JobTypeId = JobType.JobTypeIds.HMisc, Description = "External Mouse" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "MP3Player", JobTypeId = JobType.JobTypeIds.HMisc, Description = "MP3 Player" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "PrinterScanner", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Printer/Scanner" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Projector", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Projector" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "USBFlashDrive", JobTypeId = JobType.JobTypeIds.HMisc, Description = "USB Flash Drive" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "WebCamera", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Web Camera" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Other" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "ContentIllegal", JobTypeId = JobType.JobTypeIds.SImg, Description = "Content - Illegal" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "ContentInappropriate", JobTypeId = JobType.JobTypeIds.SImg, Description = "Content - Inappropriate" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "CorruptOS", JobTypeId = JobType.JobTypeIds.SImg, Description = "Corrupt Operating System" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "HardwareChanges", JobTypeId = JobType.JobTypeIds.SImg, Description = "Hardware Changes" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Malware", JobTypeId = JobType.JobTypeIds.SImg, Description = "Malware" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Performance", JobTypeId = JobType.JobTypeIds.SImg, Description = "Performance" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "UserRequest", JobTypeId = JobType.JobTypeIds.SImg, Description = "User Request" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "UpdatedImage", JobTypeId = JobType.JobTypeIds.SImg, Description = "Updated Image" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.SImg, Description = "Other" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "CurriculumTool", JobTypeId = JobType.JobTypeIds.SApp, Description = "Curriculum Tool" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "GamingEntertainment", JobTypeId = JobType.JobTypeIds.SApp, Description = "Gaming/Entertainment" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "ImageManipulation", JobTypeId = JobType.JobTypeIds.SApp, Description = "Image Manipulation" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "MultimediaPlayback", JobTypeId = JobType.JobTypeIds.SApp, Description = "Multimedia Playback" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Presentation", JobTypeId = JobType.JobTypeIds.SApp, Description = "Presentation" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Spreadsheet", JobTypeId = JobType.JobTypeIds.SApp, Description = "Spreadsheet" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "StaffTool", JobTypeId = JobType.JobTypeIds.SApp, Description = "Staff Tool" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "StudentReporting", JobTypeId = JobType.JobTypeIds.SApp, Description = "Student Reporting" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "VideoEditing", JobTypeId = JobType.JobTypeIds.SApp, Description = "Video Editing" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "WebBrowser", JobTypeId = JobType.JobTypeIds.SApp, Description = "Web Browser" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "WebBrowserPlugin", JobTypeId = JobType.JobTypeIds.SApp, Description = "Web Browser Plugin" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "WordProcessing", JobTypeId = JobType.JobTypeIds.SApp, Description = "Word Processing" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.SApp, Description = "Other" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Appearance", JobTypeId = JobType.JobTypeIds.SOS, Description = "Appearance & Personalisation" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "DisplaySettings", JobTypeId = JobType.JobTypeIds.SOS, Description = "Display Settings" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "DriversIWB", JobTypeId = JobType.JobTypeIds.SOS, Description = "Drivers - Interactive Whiteboard" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "DriversPrintScan", JobTypeId = JobType.JobTypeIds.SOS, Description = "Drivers - Printers/Scanners" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "DriversSystem", JobTypeId = JobType.JobTypeIds.SOS, Description = "Drivers - System" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "DriversOther", JobTypeId = JobType.JobTypeIds.SOS, Description = "Drivers - Other" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Group Policy", JobTypeId = JobType.JobTypeIds.SOS, Description = "Group Policy" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "KeyboardMouseConfig", JobTypeId = JobType.JobTypeIds.SOS, Description = "Keyboard/Mouse Configuration" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "MalwareProtection", JobTypeId = JobType.JobTypeIds.SOS, Description = "Malware Protection" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "NetworkDrives", JobTypeId = JobType.JobTypeIds.SOS, Description = "Network Drives" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "NetworkWired", JobTypeId = JobType.JobTypeIds.SOS, Description = "Network - Wired" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "NetworkWireless", JobTypeId = JobType.JobTypeIds.SOS, Description = "Network - Wireless" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "NetworkOther", JobTypeId = JobType.JobTypeIds.SOS, Description = "Network - Other" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "PatchUpdate", JobTypeId = JobType.JobTypeIds.SOS, Description = "Patches/Updates" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "PowerManagement", JobTypeId = JobType.JobTypeIds.SOS, Description = "Power Management" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "PrintersScanners", JobTypeId = JobType.JobTypeIds.SOS, Description = "Printers/Scanners" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "SoundConfig", JobTypeId = JobType.JobTypeIds.SOS, Description = "Sound Configuration" });
+                Database.JobSubTypes.Add(new JobSubType { Id = "Other", JobTypeId = JobType.JobTypeIds.SOS, Description = "Other" });
             }
 
             // Feature Request 2012-04-27 by Elijah: https://disco.uservoice.com/forums/159707-feedback/suggestions/2803945-customisable-job-sub-types
             #region "Optical Drive" Added
-            if (context.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HNWar && jst.Id == "OpticalDrive") == 0)
-                context.JobSubTypes.Add(new JobSubType { Id = "OpticalDrive", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Optical Drive" });
-            if (context.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HWar && jst.Id == "OpticalDrive") == 0)
-                context.JobSubTypes.Add(new JobSubType { Id = "OpticalDrive", JobTypeId = JobType.JobTypeIds.HWar, Description = "Optical Drive" });
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HNWar && jst.Id == "OpticalDrive") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "OpticalDrive", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Optical Drive" });
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HWar && jst.Id == "OpticalDrive") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "OpticalDrive", JobTypeId = JobType.JobTypeIds.HWar, Description = "Optical Drive" });
             #endregion
             // End Feature Request
 
             // 2012-05-22
             #region "User Management" Added
-            if (context.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.UMgmt) == 0)
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.UMgmt) == 0)
             {
-                context.JobSubTypes.Add(new JobSubType { Id = JobSubType.UserManagementJobSubTypes.Infringement, JobTypeId = JobType.JobTypeIds.UMgmt, Description = JobSubType.UserManagementJobSubTypes.Infringement });
-                context.JobSubTypes.Add(new JobSubType { Id = JobSubType.UserManagementJobSubTypes.Contact, JobTypeId = JobType.JobTypeIds.UMgmt, Description = JobSubType.UserManagementJobSubTypes.Contact });
+                Database.JobSubTypes.Add(new JobSubType { Id = JobSubType.UserManagementJobSubTypes.Infringement, JobTypeId = JobType.JobTypeIds.UMgmt, Description = JobSubType.UserManagementJobSubTypes.Infringement });
+                Database.JobSubTypes.Add(new JobSubType { Id = JobSubType.UserManagementJobSubTypes.Contact, JobTypeId = JobType.JobTypeIds.UMgmt, Description = JobSubType.UserManagementJobSubTypes.Contact });
             }
             #endregion
             // End
 
             // 2012-05-29 - Audits
             #region "Audit" Added
-            if (context.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HMisc && jst.Id == "Audit") == 0)
-                context.JobSubTypes.Add(new JobSubType { Id = "Audit", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Audit" });
-            if (context.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.SApp && jst.Id == "Audit") == 0)
-                context.JobSubTypes.Add(new JobSubType { Id = "Audit", JobTypeId = JobType.JobTypeIds.SApp, Description = "Audit" });
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HMisc && jst.Id == "Audit") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "Audit", JobTypeId = JobType.JobTypeIds.HMisc, Description = "Audit" });
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.SApp && jst.Id == "Audit") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "Audit", JobTypeId = JobType.JobTypeIds.SApp, Description = "Audit" });
             #endregion
             // End
 
             // Feature Request 2012-06-16 by James: https://disco.uservoice.com/forums/159707-feedback/suggestions/3002911-add-in-microphone-in-hardware-warranty-and-non-war
             #region "Microphone" Added
-            if (context.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HNWar && jst.Id == "Microphone") == 0)
-                context.JobSubTypes.Add(new JobSubType { Id = "Microphone", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Microphone" });
-            if (context.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HWar && jst.Id == "Microphone") == 0)
-                context.JobSubTypes.Add(new JobSubType { Id = "Microphone", JobTypeId = JobType.JobTypeIds.HWar, Description = "Microphone" });
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HNWar && jst.Id == "Microphone") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "Microphone", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Microphone" });
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HWar && jst.Id == "Microphone") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "Microphone", JobTypeId = JobType.JobTypeIds.HWar, Description = "Microphone" });
             #endregion
             // End Feature Request
 
             // Feature Request 2013-05-16 by Michael
             #region "Bezel - Case Bottom Load Cover" Added
-            if (context.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HNWar && jst.Id == "BezelCaseBottomCover") == 0)
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelCaseBottomCover", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Case Bottom Load Cover" });
-            if (context.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HWar && jst.Id == "BezelCaseBottomCover") == 0)
-                context.JobSubTypes.Add(new JobSubType { Id = "BezelCaseBottomCover", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Case Bottom Load Cover" });
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HNWar && jst.Id == "BezelCaseBottomCover") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelCaseBottomCover", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Bezel - Case Bottom Load Cover" });
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HWar && jst.Id == "BezelCaseBottomCover") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "BezelCaseBottomCover", JobTypeId = JobType.JobTypeIds.HWar, Description = "Bezel - Case Bottom Load Cover" });
+            #endregion
+            // End Feature Request
+
+            // Feature Request https://github.com/garysharp/Disco/issues/1
+            #region "Device Stolen/Lost"
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HNWar && jst.Id == "DeviceStolen") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "DeviceStolen", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Device Stolen" });
+            if (Database.JobSubTypes.Count(jst => jst.JobTypeId == JobType.JobTypeIds.HNWar && jst.Id == "DeviceLost") == 0)
+                Database.JobSubTypes.Add(new JobSubType { Id = "DeviceLost", JobTypeId = JobType.JobTypeIds.HNWar, Description = "Device Lost" });
             #endregion
             // End Feature Request
         }
 
-        private static void UpdateDeviceModelConfiguration(this DiscoDataContext context)
+        private static void UpdateDeviceModelConfiguration(this DiscoDataContext Database)
         {
-            if (context.ConfigurationItems.Where(c => c.Scope.StartsWith("DeviceProfile:")).Count() > 0)
+            if (Database.ConfigurationItems.Where(c => c.Scope.StartsWith("DeviceProfile:")).Count() > 0)
             {
-                var configurationItems = context.ConfigurationItems.Where(c => c.Scope.StartsWith("DeviceProfile:")).ToList();
+                var configurationItems = Database.ConfigurationItems.Where(c => c.Scope.StartsWith("DeviceProfile:")).ToList();
 
-                var deviceProfiles = context.DeviceProfiles.ToDictionary(dp => dp.Id);
+                var deviceProfiles = Database.DeviceProfiles.ToDictionary(dp => dp.Id);
                 foreach (var configurationItem in configurationItems)
                 {
                     int profileId = int.Parse(configurationItem.Scope.Substring(configurationItem.Scope.IndexOf(":") + 1));
@@ -245,47 +262,19 @@ namespace Disco.Data.Repository
                         }
                     }
                     // Remove from DB
-                    context.ConfigurationItems.Remove(configurationItem);
+                    Database.ConfigurationItems.Remove(configurationItem);
                 }
             }
 
         }
 
-        // Removed: 2013-01-14 G#
-        //        private static void UpdateDeviceModelImageStorage(this DiscoDataContext dbContext)
-        //        {
-        //#pragma warning disable 0618
-        //            var updateModels = dbContext.DeviceModels.Where(dm => dm.Image != null);
-        //            if (updateModels.Count() > 0)
-        //            {
-        //                var dataStoreLocation = dbContext.ConfigurationItems.Where(ci => ci.Scope == "System" && ci.Key == "DataStoreLocation").Select(ci => ci.Value).FirstOrDefault();
-        //                if (!string.IsNullOrEmpty(dataStoreLocation) && System.IO.Directory.Exists(dataStoreLocation))
-        //                {
-        //                    var deviceModelImagesLocation = System.IO.Path.Combine(dataStoreLocation, "DeviceModelImages");
-        //                    if (!System.IO.Directory.Exists(deviceModelImagesLocation))
-        //                        System.IO.Directory.CreateDirectory(deviceModelImagesLocation);
-        //                    foreach (var model in updateModels)
-        //                    {
-        //                        var modelpath = System.IO.Path.Combine(deviceModelImagesLocation, string.Format("{0}.png", model.Id));
-
-        //                        if (model.Image != null && model.Image.Length > 0)
-        //                        {
-        //                            System.IO.File.WriteAllBytes(modelpath, model.Image);
-        //                        }
-        //                        model.Image = null;
-        //                    }
-        //                }
-        //            }
-        //#pragma warning restore 0618
-        //        }
-
         // Added: 2013-02-07 G#
         // Fix previous problem with duplicate device models being created if new devices enrol at the same time
         // http://www.discoict.com.au/forum/support/2013/2/duplicate-device-models.aspx
         // Thanks to Michael Vorster for reporting this problem.
-        private static void UpdateDeviceModelDuplicates(this DiscoDataContext dbContext)
+        private static void UpdateDeviceModelDuplicates(this DiscoDataContext Database)
         {
-            var deviceModels = dbContext.DeviceModels.ToList();
+            var deviceModels = Database.DeviceModels.ToList();
             var duplicateModels = deviceModels.GroupBy(g => string.Format("{0}|{1}", g.Manufacturer, g.Model)).Where(g => g.Count() > 1);
             foreach (var duplicateModel in duplicateModels)
             {
@@ -293,7 +282,7 @@ namespace Disco.Data.Repository
 
                 foreach (var redundantModel in duplicateModel.Where(m => m != primaryModel))
                 {
-                    foreach (var affectedDevice in dbContext.Devices.Where(d => d.DeviceModelId == redundantModel.Id))
+                    foreach (var affectedDevice in Database.Devices.Where(d => d.DeviceModelId == redundantModel.Id))
                     {
                         affectedDevice.DeviceModelId = primaryModel.Id;
                     }