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); } }