public static UserFlag CreateUserFlag(DiscoDataContext Database, UserFlag UserFlag)
{
// Verify
if (string.IsNullOrWhiteSpace(UserFlag.Name))
throw new ArgumentException("The User Flag Name is required");
// Name Unique
if (_cache.GetUserFlags().Any(f => f.Name == UserFlag.Name))
throw new ArgumentException("Another User Flag already exists with that name", "UserFlag");
// Clone to break reference
var flag = new UserFlag()
{
Name = UserFlag.Name,
Description = UserFlag.Description,
Icon = UserFlag.Icon,
IconColour = UserFlag.IconColour,
UsersLinkedGroup = UserFlag.UsersLinkedGroup,
UserDevicesLinkedGroup = UserFlag.UserDevicesLinkedGroup
};
Database.UserFlags.Add(flag);
Database.SaveChanges();
_cache.AddOrUpdate(flag);
return flag;
}
protected override void ExecuteTask()
{
var forestServers = DiscoverForestServers();
ADDiscoverForestServers.ForestServers = forestServers;
// Restrict Searching Entire Forest if to many servers
using (DiscoDataContext Database = new DiscoDataContext())
{
var searchEntireForest = Database.DiscoConfiguration.ActiveDirectory.SearchAllForestServers;
// Check explicitly configured: No
if (!searchEntireForest.HasValue || searchEntireForest.Value)
{
// Not Configured, or explicitly configured: Yes
if (forestServers.Count > ActiveDirectory.MaxForestServerSearch)
{
// Update Database
Database.DiscoConfiguration.ActiveDirectory.SearchAllForestServers = false;
}
else
{
// Default
Database.DiscoConfiguration.ActiveDirectory.SearchAllForestServers = true;
}
Database.SaveChanges();
}
}
}
public bool Apply(DiscoDataContext Database)
{
if (RecordAction == EntityState.Detached || !HasError)
{
Device device;
if (RecordAction == EntityState.Unchanged)
{
// Unchanged - No Action Required
return false;
}
else if (RecordAction == EntityState.Modified)
{
device = Database.Devices.Find(this.DeviceSerialNumber);
}
else if (RecordAction == EntityState.Added)
{
// Use 'Add Device Offline' default if available
var deviceProfileId = Database.DiscoConfiguration.DeviceProfiles.DefaultAddDeviceOfflineDeviceProfileId;
if (deviceProfileId == 0)
{
deviceProfileId = Database.DiscoConfiguration.DeviceProfiles.DefaultDeviceProfileId;
}
// Create Device
device = new Device()
{
SerialNumber = DeviceSerialNumber.ToUpper(),
CreatedDate = DateTime.Now,
AllowUnauthenticatedEnrol = true,
DeviceProfileId = deviceProfileId,
DeviceModelId = 1 // Default 'Unknown Device Model'
};
Database.Devices.Add(device);
}
else
{
// Invalid State
return false;
}
bool changesMade = (RecordAction == EntityState.Added);
foreach (var field in Fields.Cast<DeviceImportFieldBase>())
{
changesMade = field.Apply(Database, device) || changesMade;
}
// Commit Changes
if (changesMade)
Database.SaveChanges();
return changesMade;
}
// Record has Errors
return false;
}
public static MacEnrolResponse BuildResponse(this MacEnrol request)
{
if (HttpContext.Current == null)
throw new PlatformNotSupportedException("This function can only be accessed from within ASP.NET");
using (DiscoDataContext database = new DiscoDataContext())
{
MacEnrolResponse response = DeviceEnrolment.MacEnrol(database, request, false);
database.SaveChanges();
return response;
}
}
internal static void MigrateDatabase(DiscoDataContext Database)
{
// Migrate all organisation addresses to JSON
if (Database.ConfigurationItems.Count(i => i.Scope == scope && !i.Value.StartsWith("{")) > 0)
{
var items = Database.ConfigurationItems.Where(i => i.Scope == scope && !i.Value.StartsWith("{")).ToList();
items.ForEach(i =>
{
i.Value = JsonConvert.SerializeObject(OrganisationAddress.FromConfigurationEntry(int.Parse(i.Key), i.Value));
});
Database.SaveChanges();
}
}
public static void OnRemoveUnsafe(this UserFlagAssignment fa, DiscoDataContext Database, User RemovingUser)
{
fa.RemovedDate = DateTime.Now;
fa.RemovedUserId = RemovingUser.UserId;
if (!string.IsNullOrWhiteSpace(fa.UserFlag.OnUnassignmentExpression))
{
try
{
Database.SaveChanges();
var expressionResult = fa.EvaluateOnUnassignmentExpression(Database, RemovingUser, fa.AddedDate);
if (!string.IsNullOrWhiteSpace(expressionResult))
{
fa.OnUnassignmentExpressionResult = expressionResult;
Database.SaveChanges();
}
}
catch (Exception ex)
{
SystemLog.LogException("User Flag Expression - OnUnassignmentExpression", ex);
}
}
}
protected override void ExecuteTask()
{
int changeCount;
this.Status.UpdateStatus(1, "Starting", "Connecting to the Database and initializing the environment");
using (DiscoDataContext database = new DiscoDataContext())
{
UpdateLastNetworkLogonDates(database, this.Status);
Status.UpdateStatus(95, "Updating Database", "Writing last network logon dates to the Database");
changeCount = database.SaveChanges();
Status.Finished(string.Format("{0} Device last network logon dates updated", changeCount), "/Config/SystemConfig");
}
Status.LogInformation($"Updated LastNetworkLogon Device Property for Device/s, {changeCount:N0} changes");
}
public static EnrolResponse BuildResponse(this Enrol request)
{
if (HttpContext.Current == null)
throw new PlatformNotSupportedException("This function can only be accessed from within ASP.NET");
string username = null;
if (HttpContext.Current.Request.IsAuthenticated)
username = HttpContext.Current.User.Identity.Name;
using (DiscoDataContext database = new DiscoDataContext())
{
EnrolResponse response = DeviceEnrolment.Enrol(database, username, request);
database.SaveChanges();
return response;
}
}
public static void SeedDatabase()
{
// Seed/Update Database
using (DiscoDataContext database = new DiscoDataContext())
{
database.SeedDatabase();
try
{
database.SaveChanges();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
throw;
}
}
}
public static JobQueueToken CreateJobQueue(DiscoDataContext Database, JobQueue JobQueue)
{
// Verify
if (string.IsNullOrWhiteSpace(JobQueue.Name))
throw new ArgumentException("The Job Queue Name is required");
// Name Unique
if (_cache.GetQueues().Any(q => q.JobQueue.Name == JobQueue.Name))
throw new ArgumentException("Another Job Queue already exists with that name", "JobQueue");
// Sanitize Subject Ids
if (string.IsNullOrWhiteSpace(JobQueue.SubjectIds))
{
JobQueue.SubjectIds = null;
}
else
{
var subjectIds = JobQueue.SubjectIds.Split(',');
foreach (var subjectId in subjectIds)
{
UserService.GetUser(subjectId, Database);
}
JobQueue.SubjectIds = string.Join(",", Database.Users.Where(u => subjectIds.Contains(u.UserId)).Select(u => u.UserId));
}
// Clone to break reference
var queue = new JobQueue()
{
Name = JobQueue.Name,
Description = JobQueue.Description,
Icon = JobQueue.Icon,
IconColour = JobQueue.IconColour,
DefaultSLAExpiry = JobQueue.DefaultSLAExpiry,
Priority = JobQueue.Priority,
SubjectIds = JobQueue.SubjectIds
};
Database.JobQueues.Add(queue);
Database.SaveChanges();
return _cache.UpdateQueue(queue);
}
public static UserFlagAssignment OnAddUserFlagUnsafe(this User u, DiscoDataContext Database, UserFlag flag, User AddingUser, string Comments)
{
var fa = new UserFlagAssignment()
{
UserFlag = flag,
User = u,
AddedDate = DateTime.Now,
AddedUser = AddingUser,
Comments = string.IsNullOrWhiteSpace(Comments) ? null : Comments.Trim()
};
Database.UserFlagAssignments.Add(fa);
if (!string.IsNullOrWhiteSpace(flag.OnAssignmentExpression))
{
try
{
Database.SaveChanges();
var expressionResult = fa.EvaluateOnAssignmentExpression(Database, AddingUser, fa.AddedDate);
if (!string.IsNullOrWhiteSpace(expressionResult))
{
fa.OnAssignmentExpressionResult = expressionResult;
Database.SaveChanges();
}
}
catch (Exception ex)
{
SystemLog.LogException("User Flag Expression - OnAssignmentExpression", ex);
}
}
return fa;
}
public static void DeleteAuthorizationRole(DiscoDataContext Database, AuthorizationRole Role)
{
if (Role == null)
throw new ArgumentNullException("Role");
Database.AuthorizationRoles.Remove(Role);
Database.SaveChanges();
AuthorizationLog.LogRoleDeleted(Role, CurrentUserId);
// Remove from Role Cache
RoleCache.RemoveRole(Role);
// Flush User Cache
Cache.FlushCache();
}
public static int CreateAuthorizationRole(DiscoDataContext Database, AuthorizationRole Role)
{
if (Role == null)
throw new ArgumentNullException("Role");
if (string.IsNullOrWhiteSpace(Role.ClaimsJson))
Role.ClaimsJson = JsonConvert.SerializeObject(new RoleClaims());
Database.AuthorizationRoles.Add(Role);
Database.SaveChanges();
AuthorizationLog.LogRoleCreated(Role, CurrentUserId);
// Add to Cache
RoleCache.AddRole(Role);
// Flush User Cache
Cache.FlushCache();
return Role.Id;
}
public virtual ActionResult Database(DatabaseModel model)
{
if (ModelState.IsValid)
{
// Continue with Configuration
var connectionString = model.ToConnectionString();
// Try Creating/Migrating
connectionString.ConnectTimeout = 5;
Disco.Data.Repository.DiscoDatabaseConnectionFactory.SetDiscoDataContextConnectionString(connectionString.ToString(), false);
try
{
Disco.Data.Migrations.DiscoDataMigrator.MigrateLatest(true);
}
catch (Exception ex)
{
// Find inner exception
SqlException sqlException = null;
Exception innermostException = ex;
do
{
if (sqlException == null)
sqlException = innermostException as SqlException;
if (innermostException.InnerException != null)
innermostException = innermostException.InnerException;
else
break;
} while (true);
if (sqlException != null)
{
ModelState.AddModelError(string.Empty, string.Format("Unable to create or migrate the database to the latest version: [{0}] {1}", sqlException.GetType().Name, sqlException.Message));
}
else
{
ModelState.AddModelError(string.Empty, string.Format("Unable to create or migrate the database to the latest version: [{0}] {1}", innermostException.GetType().Name, innermostException.Message));
}
}
if (ModelState.IsValid)
{
// Save Connection String
//Disco.Data.Repository.DiscoDatabaseConnectionFactory.SetDiscoDataContextConnectionString(model.ToConnectionString().ToString(), true);
// Write Organisation Name into DB
using (DiscoDataContext database = new DiscoDataContext())
{
database.DiscoConfiguration.OrganisationName = DiscoApplication.OrganisationName;
database.SaveChanges();
}
return RedirectToAction(MVC.InitialConfig.FileStore());
}
}
return View(model);
}
public virtual ActionResult FileStore(FileStoreModel m)
{
if (ModelState.IsValid)
{
using (DiscoDataContext database = new DiscoDataContext())
{
database.DiscoConfiguration.DataStoreLocation = m.FileStoreLocation;
database.SaveChanges();
// Extract DataStore Template into FileStore
var templatePath = Server.MapPath("~/ClientBin/DataStoreTemplate.zip");
if (System.IO.File.Exists(templatePath))
{
try
{
using (ZipArchive templateArchive = ZipFile.Open(templatePath, ZipArchiveMode.Read))
{
foreach (var entry in templateArchive.Entries)
{
var entryDestinationPath = Path.Combine(m.FileStoreLocation, entry.FullName);
if (System.IO.File.Exists(entryDestinationPath))
System.IO.File.Delete(entryDestinationPath);
}
templateArchive.ExtractToDirectory(m.FileStoreLocation);
}
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, string.Format("Unable to extract File Store template: [{0}] {1}", ex.GetType().Name, ex.Message));
}
}
// Initialize Core Environment
AppConfig.InitalizeCoreEnvironment(database);
}
return RedirectToAction(MVC.InitialConfig.Administrators());
}
m.ExpandDirectoryModel();
return View(m);
}
/// <summary>
/// Migrates authorization role claims to conform with changes to Disco since the last release.
/// Claims are only added when the meaning of an existing claim has changed (or expanded/contracted) to improve the migration experience.
/// </summary>
private static void MigrateAuthorizationRoles(DiscoDataContext Database)
{
// Determine roles which need migration from DBv11 -> DBv14
var affectedRoles_DBv14 = Database.AuthorizationRoles.Where(r => !r.ClaimsJson.Contains("MyJobs")).ToList();
// Determine roles which need migration from DBv14 -> DBv15
var affectedRoles_DBv15 = Database.AuthorizationRoles.Where(r => !r.ClaimsJson.Contains("RepairProviderDetails")).ToList();
if (affectedRoles_DBv14.Count > 0)
{
foreach (var role in affectedRoles_DBv14)
{
var claims = JsonConvert.DeserializeObject<RoleClaims>(role.ClaimsJson);
// MyJobs replaces 'AwaitingTechnicianAction' jobs on the Job page.
if (claims.Job.Lists.AwaitingTechnicianAction)
{
claims.Job.Lists.MyJobs = true;
claims.Job.Lists.MyJobsOrphaned = true;
}
// Stale Jobs expands on Long Running Jobs (and replaces it on the Job page)
if (claims.Job.Lists.LongRunningJobs)
{
claims.Job.Lists.StaleJobs = true;
}
// Greater control to create jobs was added, this adds claims to keep the behaviour the same for existing roles
if (claims.Job.Actions.Create)
{
claims.Job.Types.CreateHMisc = true;
claims.Job.Types.CreateHNWar = true;
claims.Job.Types.CreateHWar = true;
claims.Job.Types.CreateSApp = true;
claims.Job.Types.CreateSOS = true;
claims.Job.Types.CreateSImg = true;
claims.Job.Types.CreateUMgmt = true;
}
// A claim was added to control whether Current User Assignments could be shown (independently of User Assignment History)
if (claims.User.ShowAssignmentHistory)
{
claims.User.ShowAssignments = true;
}
// A claim was added to control whether User personal details could be shown
if (claims.User.Show)
{
claims.User.ShowDetails = true;
}
role.ClaimsJson = Newtonsoft.Json.JsonConvert.SerializeObject(claims);
}
Database.SaveChanges();
}
if (affectedRoles_DBv15.Count > 0)
{
foreach (var role in affectedRoles_DBv15)
{
var claims = JsonConvert.DeserializeObject<RoleClaims>(role.ClaimsJson);
// If the user previously had the ability to view warranty provider details, they probably should be able to view repair provider details (new feature).
if (claims.Job.Properties.WarrantyProperties.ProviderDetails)
{
claims.Job.Properties.NonWarrantyProperties.RepairProviderDetails = true;
}
role.ClaimsJson = Newtonsoft.Json.JsonConvert.SerializeObject(claims);
}
Database.SaveChanges();
}
}
public static void UpdateAdministratorSubjectIds(DiscoDataContext Database, IEnumerable<string> SubjectIds)
{
// Clean
SubjectIds = SubjectIds
.Where(s => !string.IsNullOrWhiteSpace(s))
.Concat(RequiredAdministratorSubjectIds)
.Distinct(StringComparer.OrdinalIgnoreCase)
.OrderBy(s => s);
var subjectIdsString = string.Join(",", SubjectIds);
// Update Database
Database.DiscoConfiguration.Administrators = subjectIdsString;
Database.SaveChanges();
// Update State
_AdministratorToken.SubjectIds = SubjectIds.ToList();
_AdministratorToken.SubjectIdHashes = new HashSet<string>(SubjectIds, StringComparer.OrdinalIgnoreCase);
}
public static UpdateResponseV2 Check(DiscoDataContext Database, bool UseProxy, IScheduledTaskStatus Status)
{
Status.UpdateStatus(10, "Gathering statistics and building update request");
var updateRequest = BuildRequest(Database);
Status.UpdateStatus(40, "Sending statistics and update request");
var discoVersion = CurrentDiscoVersionFormatted();
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(UpdateUrl());
// Fix for Proxy Servers which don't support KeepAlive
request.KeepAlive = false;
if (!UseProxy)
request.Proxy = new WebProxy();
request.ContentType = "application/json; charset=utf-8; encoding=gzip";
request.Method = WebRequestMethods.Http.Post;
request.UserAgent = string.Format("Disco/{0} (Update)", discoVersion);
using (var requestStream = request.GetRequestStream())
{
using (var compressedStream = new GZipStream(requestStream, CompressionLevel.Optimal))
{
using (var requestStreamWriter = new StreamWriter(compressedStream, Encoding.UTF8))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(requestStreamWriter, updateRequest);
requestStreamWriter.Flush();
}
}
}
Status.UpdateStatus(50, "Waiting for update response");
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
if (response.StatusCode == HttpStatusCode.OK)
{
Status.UpdateStatus(90, "Reading update response");
string updateResultJson;
UpdateResponseV2 updateResult;
using (var responseStream = response.GetResponseStream())
{
using (var responseReader = new StreamReader(responseStream))
{
updateResultJson = responseReader.ReadToEnd();
}
}
updateResult = JsonConvert.DeserializeObject<UpdateResponseV2>(updateResultJson);
Database.DiscoConfiguration.UpdateLastCheckResponse = updateResult;
Database.SaveChanges();
Status.SetFinishedMessage(string.Format("The update server reported Version {0} is the latest.", updateResult.LatestVersion));
return updateResult;
}
else
{
Status.SetTaskException(new WebException(string.Format("Server responded with: [{0}] {1}", response.StatusCode, response.StatusDescription)));
return null;
}
}
}
internal static Tuple<User, AuthorizationToken> ImportUser(DiscoDataContext Database, string UserId)
{
if (string.IsNullOrEmpty(UserId))
throw new ArgumentNullException("UserId is required", "UserId");
if (UserId.EndsWith("$"))
{
// Machine Account
var adAccount = ActiveDirectory.RetrieveADMachineAccount(UserId);
if (adAccount == null)
return null;
var user = adAccount.ToRepositoryUser();
var token = AuthorizationToken.BuildComputerAccountToken(user);
return new Tuple<User, AuthorizationToken>(user, token);
}
else
{
// User Account
ADUserAccount adAccount;
try
{
adAccount = ActiveDirectory.RetrieveADUserAccount(UserId);
if (adAccount == null)
throw new ArgumentException(string.Format("Invalid Username: '******'; User not found in Active Directory", UserId), "Username");
}
catch (COMException ex)
{
// If "Server is not operational" then Try Cache
if (ex.ErrorCode == -2147016646)
SystemLog.LogException("Server is not operational; Primary Domain Controller Down?", ex);
throw ex;
}
catch (ActiveDirectoryOperationException ex)
{
// Try From Cache...
SystemLog.LogException("Primary Domain Controller Down?", ex);
throw ex;
}
var user = adAccount.ToRepositoryUser();
// Update Repository
User existingUser = Database.Users.Find(user.UserId);
if (existingUser == null)
Database.Users.Add(user);
else
{
existingUser.UpdateSelf(user);
user = existingUser;
}
Database.SaveChanges();
var token = AuthorizationToken.BuildToken(user, adAccount.Groups.Select(g => g.Id));
return new Tuple<User, AuthorizationToken>(user, token);
}
}
public static void DeleteUserFlag(DiscoDataContext Database, int UserFlagId, IScheduledTaskStatus Status)
{
UserFlag flag = Database.UserFlags.Find(UserFlagId);
// Dispose of AD Managed Groups
Interop.ActiveDirectory.ActiveDirectory.Context.ManagedGroups.Remove(UserFlagUserDevicesManagedGroup.GetKey(flag));
Interop.ActiveDirectory.ActiveDirectory.Context.ManagedGroups.Remove(UserFlagUsersManagedGroup.GetKey(flag));
// Delete Assignments
Status.UpdateStatus(0, string.Format("Removing '{0}' [{1}] User Flag", flag.Name, flag.Id), "Starting");
List<UserFlagAssignment> flagAssignments = Database.UserFlagAssignments.Where(fa => fa.UserFlagId == flag.Id).ToList();
if (flagAssignments.Count > 0)
{
Status.UpdateStatus(20, "Removing flag from users");
flagAssignments.ForEach(flagAssignment => Database.UserFlagAssignments.Remove(flagAssignment));
Database.SaveChanges();
}
// Delete Flag
Status.UpdateStatus(90, "Deleting User Flag");
Database.UserFlags.Remove(flag);
Database.SaveChanges();
// Remove from Cache
_cache.Remove(UserFlagId);
Status.Finished(string.Format("Successfully Deleted User Flag: '{0}' [{1}]", flag.Name, flag.Id));
}
public static void DeleteJobQueue(DiscoDataContext Database, int JobQueueId, IScheduledTaskStatus Status)
{
JobQueue queue = Database.JobQueues.Find(JobQueueId);
// Validate: Current Jobs?
var currentJobs = Database.JobQueueJobs.Any(jqj => jqj.JobQueueId == queue.Id && !jqj.RemovedDate.HasValue);
if (currentJobs)
throw new InvalidOperationException("The Job Queue cannot be deleted because it contains jobs");
// Delete History
Status.UpdateStatus(0, string.Format("Removing '{0}' [{1}] Job Queue", queue.Name, queue.Id), "Starting");
var jobQueueJobs = Database.JobQueueJobs.Include("Job").Where(jsj => jsj.JobQueueId == queue.Id).ToList();
if (jobQueueJobs.Count > 0)
{
double progressInterval = 90 / jobQueueJobs.Count;
for (int jqjIndex = 0; jqjIndex < jobQueueJobs.Count; jqjIndex++)
{
var jqj = jobQueueJobs[jqjIndex];
Status.UpdateStatus(jqjIndex * progressInterval, string.Format("Merging history into job #{0} logs", jqj.JobId));
// Write Logs
Database.JobLogs.Add(new JobLog()
{
JobId = jqj.JobId,
TechUserId = jqj.AddedUserId,
Timestamp = jqj.AddedDate,
Comments = string.Format("# Added to Queue\r\n**{0}**\r\nPriority: **{1}**\r\n{2}", Environment.NewLine, queue.Name, jqj.Priority.ToString(), string.IsNullOrWhiteSpace(jqj.AddedComment) ? "<no comment>" : jqj.AddedComment)
});
Database.JobLogs.Add(new JobLog()
{
JobId = jqj.JobId,
TechUserId = jqj.RemovedUserId,
Timestamp = jqj.RemovedDate.Value,
Comments = string.Format("# Removed from Queue\r\n**{0}**\r\n{1}", queue.Name, string.IsNullOrWhiteSpace(jqj.RemovedComment) ? "<no comment>" : jqj.RemovedComment)
});
// Delete JQJ
Database.JobQueueJobs.Remove(jqj);
// Save Changes
Database.SaveChanges();
}
}
// Delete Queue
Status.UpdateStatus(90, "Deleting Queue");
Database.JobQueues.Remove(queue);
Database.SaveChanges();
// Remove from Cache
_cache.RemoveQueue(JobQueueId);
Status.Finished(string.Format("Successfully Deleted Job Queue: '{0}' [{1}]", queue.Name, queue.Id));
}
public static void UpdateAuthorizationRole(DiscoDataContext Database, AuthorizationRole Role)
{
if (Role == null)
throw new ArgumentNullException("Role");
if (Database == null)
throw new ArgumentNullException("Database");
Database.SaveChanges();
// Update Role Cache
RoleCache.UpdateRole(Role);
// Flush User Cache
Cache.FlushCache();
}
protected void Application_Start()
{
if (AppConfig.InitializeDatabase())
{
// Database Initialized
using (DiscoDataContext database = new DiscoDataContext())
{
// Check for Post-Update
var previousVersion = database.DiscoConfiguration.InstalledDatabaseVersion;
bool isVersionUpdate = previousVersion != UpdateQuery.CurrentDiscoVersion();
bool ignoreVersionUpdate = false;
if (isVersionUpdate)
{
// Update Database with New Version
database.DiscoConfiguration.InstalledDatabaseVersion = UpdateQuery.CurrentDiscoVersion();
database.SaveChanges();
// Check if configured to Ignore Plugin Updates (Mainly for Dev environment)
bool.TryParse(ConfigurationManager.AppSettings["DiscoIgnoreVersionUpdate"], out ignoreVersionUpdate);
// Only Update if Plugins are installed
if (!ignoreVersionUpdate)
ignoreVersionUpdate = (Disco.Services.Plugins.UpdatePluginTask.OfflineInstalledPlugins(database).Count == 0);
}
if (!isVersionUpdate || ignoreVersionUpdate)
{
// Normal Startup
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles();
AppConfig.InitalizeNormalEnvironment(database);
}
else
{
// Post-Update Startup
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterUpdateRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles();
AppConfig.InitializeUpdateEnvironment(database, previousVersion);
}
}
}
else
{
// Database Not Initialized
// Install
InitialConfig = true;
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterInstallRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles();
}
}
private static void PersistCache()
{
var packages = cache.Values.ToList();
if (packages.Count == 0)
packages = null;
using (var database = new DiscoDataContext())
{
database.DiscoConfiguration.Documents.Packages = packages;
database.SaveChanges();
}
}
public static DeviceAttachment CreateAttachment(this Device Device, DiscoDataContext Database, User CreatorUser, string Filename, string MimeType, string Comments, Stream Content, DocumentTemplate DocumentTemplate = null, Image PdfThumbnail = null)
{
if (string.IsNullOrEmpty(MimeType) || MimeType.Equals("unknown/unknown", StringComparison.OrdinalIgnoreCase))
MimeType = Interop.MimeTypes.ResolveMimeType(Filename);
DeviceAttachment da = new DeviceAttachment()
{
DeviceSerialNumber = Device.SerialNumber,
TechUserId = CreatorUser.UserId,
Filename = Filename,
MimeType = MimeType,
Timestamp = DateTime.Now,
Comments = Comments
};
if (DocumentTemplate != null)
da.DocumentTemplateId = DocumentTemplate.Id;
Database.DeviceAttachments.Add(da);
Database.SaveChanges();
da.SaveAttachment(Database, Content);
Content.Position = 0;
if (PdfThumbnail == null)
da.GenerateThumbnail(Database, Content);
else
da.SaveThumbnailAttachment(Database, PdfThumbnail);
return da;
}
internal static List<User> SearchUsers(DiscoDataContext Database, string Term, bool PersistResults, int? LimitCount = ActiveDirectory.DefaultSearchResultLimit)
{
var adImportedUsers = ActiveDirectory.SearchADUserAccounts(Term, Quick: true, ResultLimit: LimitCount).Select(adU => adU.ToRepositoryUser()).ToList();
if (PersistResults)
{
foreach (var adU in adImportedUsers)
{
var existingUser = Database.Users.Find(adU.UserId);
if (existingUser != null)
existingUser.UpdateSelf(adU);
else
Database.Users.Add(adU);
Database.SaveChanges();
UserService.InvalidateCachedUser(adU.UserId);
}
}
return adImportedUsers;
}
public static JobQueueToken UpdateJobQueue(DiscoDataContext Database, JobQueue JobQueue)
{
// Verify
if (string.IsNullOrWhiteSpace(JobQueue.Name))
throw new ArgumentException("The Job Queue Name is required");
// Name Unique
if (_cache.GetQueues().Any(q => q.JobQueue.Id != JobQueue.Id && q.JobQueue.Name == JobQueue.Name))
throw new ArgumentException("Another Job Queue already exists with that name", "JobQueue");
// Sanitize Subject Ids
if (string.IsNullOrWhiteSpace(JobQueue.SubjectIds))
{
JobQueue.SubjectIds = null;
}
else
{
var subjectIds = JobQueue.SubjectIds.Split(',');
foreach (var subjectId in subjectIds)
{
UserService.GetUser(subjectId, Database);
}
JobQueue.SubjectIds = string.Join(",", Database.Users.Where(u => subjectIds.Contains(u.UserId)).Select(u => u.UserId));
}
Database.SaveChanges();
return _cache.UpdateQueue(JobQueue);
}
public static Tuple<DeviceModel, bool> GetOrCreateDeviceModel(this DbSet<DeviceModel> DeviceModelsSet, string Manufacturer, string Model, string ModelType)
{
if (string.IsNullOrWhiteSpace(Manufacturer))
Manufacturer = "Unknown";
else
Manufacturer = Manufacturer.Trim();
if (string.IsNullOrWhiteSpace(Model))
Model = "Unknown";
else
Model = Model.Trim();
if (string.IsNullOrWhiteSpace(ModelType))
ModelType = null;
else
ModelType = ModelType.Trim();
// Already Exists?
var deviceModel = DeviceModelsSet.FirstOrDefault(dm => dm.Manufacturer == Manufacturer && dm.Model == Model);
if (deviceModel == null)
{
// Ensure only one thread/request at a time
lock (_CreateDeviceModelLock)
{
// Check again now that lock is enforced
deviceModel = DeviceModelsSet.FirstOrDefault(dm => dm.Manufacturer == Manufacturer && dm.Model == Model);
if (deviceModel == null)
{
// Create the Device Model in a different DataContext so we don't have to commit unrelated changes
using (DiscoDataContext database = new DiscoDataContext())
{
var description = $"{Manufacturer} {Model}";
if (Model.Equals("Unknown", StringComparison.OrdinalIgnoreCase))
{
description = $"Unknown {Manufacturer} Model";
}
var addDeviceModel = new DeviceModel
{
Manufacturer = Manufacturer,
Model = Model,
ModelType = ModelType,
Description = description
};
database.DeviceModels.Add(addDeviceModel);
database.SaveChanges();
}
// Obtain the Device Model with the in-scope DataContext
// - Overhead acknowledged, but reasonable given the infrequency of occurrence
deviceModel = DeviceModelsSet.FirstOrDefault(dm => dm.Manufacturer == Manufacturer && dm.Model == Model);
return new Tuple<DeviceModel, bool>(deviceModel, true);
}
}
}
else
{
if (deviceModel.ModelType != ModelType)
deviceModel.ModelType = ModelType;
}
return new Tuple<DeviceModel, bool>(deviceModel, false);
}
public virtual ActionResult Unauthenticated(string feature)
{
if (string.IsNullOrEmpty(feature))
{
return Json(null);
}
switch (feature.ToLower())
{
case "enrol":
{
// Ensure supported version
if (Request.UserAgent.StartsWith(@"Disco-Client/", StringComparison.OrdinalIgnoreCase))
{
Version clientVersion;
if (Version.TryParse(Request.UserAgent.Substring(13), out clientVersion))
{
if (clientVersion < new Version(2, 2))
{
return new HttpStatusCodeResult(400, "Disco Client not compatible");
}
}
}
var serializer = new JsonSerializer();
Enrol enrolRequest;
Request.InputStream.Position = 0;
using (var streamReader = new StreamReader(Request.InputStream))
{
using (var jsonReader = new JsonTextReader(streamReader))
{
enrolRequest = serializer.Deserialize<Enrol>(jsonReader);
}
}
EnrolResponse enrolResponse = enrolRequest.BuildResponse();
return Json(enrolResponse);
}
case "macenrol":
{
var Binder = ModelBinders.Binders.GetBinder(typeof(MacEnrol));
var BinderContext = new ModelBindingContext()
{
ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(MacEnrol)),
ValueProvider = ValueProvider
};
MacEnrol enrolRequest = (MacEnrol)Binder.BindModel(ControllerContext, BinderContext);
MacEnrolResponse enrolResponse = enrolRequest.BuildResponse();
return Json(enrolResponse, JsonRequestBehavior.AllowGet);
}
case "macsecureenrol":
{
using (var database = new DiscoDataContext())
{
var host = HttpContext.Request.UserHostAddress;
MacSecureEnrolResponse enrolResponse = DeviceEnrolment.MacSecureEnrol(database, host);
database.SaveChanges();
return Json(enrolResponse, JsonRequestBehavior.AllowGet);
}
}
}
throw new MissingMethodException(string.Format("Unknown Feature: {0}", feature));
}
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 = EnrolmentLog.Current.ModuleId,
EventTypes = new List<int>() { (int)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);
}
}
