protected override void ExecuteTask() { using (var database = new DiscoDataContext()) { UpdateDataHistory(database, true); } }
public override bool Apply(DiscoDataContext Database, Device Device) { if (this.FieldAction == EntityState.Added || this.FieldAction == EntityState.Modified) { DeviceDetail detail = Database.DeviceDetails.FirstOrDefault(dd => dd.DeviceSerialNumber == Device.SerialNumber && dd.Scope == DeviceDetail.ScopeHardware && dd.Key == DeviceDetail.HardwareKeyLanMacAddress); if (detail == null) { detail = new DeviceDetail() { Device = Device, DeviceSerialNumber = Device.SerialNumber, Scope = DeviceDetail.ScopeHardware, Key = DeviceDetail.HardwareKeyLanMacAddress }; Database.DeviceDetails.Add(detail); } detail.Value = parsedValue; return true; } else { return false; } }
public static WhoAmIResponse BuildResponse(this WhoAmI 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; if (username == null) throw new InvalidOperationException("Unauthenticated Http Context"); using (DiscoDataContext database = new DiscoDataContext()) { AuthorizationToken token = UserService.GetAuthorization(username, database, true); WhoAmIResponse response = new WhoAmIResponse() { Username = token.User.UserId, DisplayName = token.User.DisplayName, Type = token.Has(Claims.ComputerAccount) ? "Computer Account" : "User Account" }; return response; } }
public override bool Parse(DiscoDataContext Database, IDeviceImportCache Cache, DeviceImportContext Context, int RecordIndex, string DeviceSerialNumber, Device ExistingDevice, Dictionary<DeviceImportFieldTypes, string> Values, string Value) { friendlyValue = Value; // Validate if (string.IsNullOrWhiteSpace(Value)) this.parsedValue = 1; // Default Model else if (!int.TryParse(Value, out parsedValue)) return Error("The Model Identifier must be a number"); var m = Cache.DeviceModels.FirstOrDefault(dm => dm.Id == parsedValue); if (m == null) return Error(string.Format("The identifier ({0}) does not match any Device Model", Value)); friendlyValue = string.Format("{0} [{1}]", m.Description, m.Id); if (ExistingDevice == null) return Success(EntityState.Added); else if (ExistingDevice != null && ExistingDevice.DeviceModelId != parsedValue) { friendlyPreviousValue = null; if (ExistingDevice.DeviceModelId.HasValue) { var previousModel = Cache.DeviceModels.FirstOrDefault(dm => dm.Id == ExistingDevice.DeviceModelId.Value); friendlyPreviousValue = string.Format("{0} [{1}]", previousModel.Description, previousModel.Id); } return Success(EntityState.Modified); } else return Success(EntityState.Unchanged); }
public void Execute(IJobExecutionContext context) { using (DiscoDataContext database = new DiscoDataContext()) { LogContext.ReInitalize(database); } }
public static DeviceImportContext BeginImport(DiscoDataContext Database, string Filename, bool HasHeader, Stream FileContent) { if (FileContent == null) throw new ArgumentNullException("FileContent"); if (string.IsNullOrWhiteSpace(Filename)) Filename = "<None Specified>"; DeviceImportContext context; List<Tuple<string, DeviceImportFieldTypes>> header; List<string[]> rawData; using (TextReader csvTextReader = new StreamReader(FileContent)) { using (CsvReader csvReader = new CsvReader(csvTextReader, HasHeader)) { csvReader.DefaultParseErrorAction = ParseErrorAction.ThrowException; csvReader.MissingFieldAction = MissingFieldAction.ReplaceByNull; rawData = csvReader.ToList(); header = csvReader.GetFieldHeaders().Select(h => Tuple.Create(h, DeviceImportFieldTypes.IgnoreColumn)).ToList(); } } context = new DeviceImportContext(Filename, header, rawData); context.GuessHeaderTypes(Database); return context; }
public override bool Parse(DiscoDataContext Database, IDeviceImportCache Cache, DeviceImportContext Context, int RecordIndex, string DeviceSerialNumber, Device ExistingDevice, Dictionary<DeviceImportFieldTypes, string> Values, string Value) { friendlyValue = Value; // Validate if (string.IsNullOrWhiteSpace(Value)) this.parsedValue = Database.DiscoConfiguration.DeviceProfiles.DefaultAddDeviceOfflineDeviceProfileId; else if (!int.TryParse(Value, out parsedValue)) return Error("The Profile Identifier must be a number"); var p = Cache.DeviceProfiles.FirstOrDefault(dp => dp.Id == parsedValue); if (p == null) return Error(string.Format("The identifier ({0}) does not match any Device Profile", Value)); friendlyValue = string.Format("{0} [{1}]", p.Description, p.Id); if (ExistingDevice == null) return Success(EntityState.Added); else if (ExistingDevice != null && ExistingDevice.DeviceProfileId != parsedValue) { var previousProfile = Cache.DeviceProfiles.FirstOrDefault(dp => dp.Id == ExistingDevice.DeviceProfileId); friendlyPreviousValue = string.Format("{0} [{1}]", previousProfile.Description, previousProfile.Id); return Success(EntityState.Modified); } else return Success(EntityState.Unchanged); }
private void Initialize(DiscoDataContext Database) { // Search Entire Forest (default: true) this._SearchAllForestServers = Database.DiscoConfiguration.ActiveDirectory.SearchAllForestServers ?? true; // Set Search LDAP Filters InitializeWildcardSearchSufixOnly(Database.DiscoConfiguration.ActiveDirectory.SearchWildcardSuffixOnly); // Determine Site var computerSite = ActiveDirectorySite.GetComputerSite(); this.Site = new ADSite(this, computerSite); // Determine Domains var computerDomain = Domain.GetComputerDomain(); this.Domains = computerDomain.Forest.Domains .Cast<Domain>() .Select(d => new ADDomain(this, d)) .ToList(); this.PrimaryDomain = this.Domains.Where(d => d.Name == computerDomain.Name).First(); // Determine Search Scope Containers ReinitializeSearchContainers(Database.DiscoConfiguration.ActiveDirectory.SearchContainers); // Determine Domain Controllers var siteDomainControllers = computerSite.Servers .OfType<DomainController>() .Where(dc => dc.IsReachable()) .Select(dc => new ADDomainController(this, dc, GetDomainByName(dc.Domain.Name), IsSiteServer: true, IsWritable: false)); Site.UpdateDomainControllers(siteDomainControllers); this.Domains.ForEach(domain => domain.UpdateDomainControllers(siteDomainControllers.Where(dc => dc.Domain == domain))); }
public static List<DocumentTemplatePackage> AvailablePackages(this Job job, DiscoDataContext Database, User TechnicianUser) { var packages = new List<DocumentTemplatePackage>(); foreach (var package in AvailablePackages(Database, AttachmentTypes.Job)) { bool subTypeMatch = true; // default match if (package.JobSubTypes != null && package.JobSubTypes.Count > 0) { subTypeMatch = false; // enforce match foreach (var subType in job.JobSubTypes) { if (package.JobSubTypes.Contains($"{subType.JobTypeId}_{subType.Id}", StringComparer.OrdinalIgnoreCase)) { subTypeMatch = true; break; } } } if (subTypeMatch) { if (package.FilterExpressionMatches(job, Database, TechnicianUser, DateTime.Now, DocumentState.DefaultState())) { packages.Add(package); } } } return packages; }
public static IndexModel Build(DiscoDataContext Database) { var m = new IndexModel(); m.DeviceProfiles = Database.DeviceProfiles.OrderBy(dp => dp.Name).Select(dp => new _IndexModelItem() { Id = dp.Id, Name = dp.Name, ShortName = dp.ShortName, Address = dp.DefaultOrganisationAddress, Description = dp.Description, DistributionType = dp.DistributionType.Value, DeviceCount = dp.Devices.Count, DeviceDecommissionedCount = dp.Devices.Count(d => d.DecommissionedDate.HasValue), IsLinked = dp.AssignedUsersLinkedGroup != null || dp.DevicesLinkedGroup != null }).ToArray().Cast<ConfigDeviceProfileIndexModelItem>().ToList(); if (DiscoApplication.MultiSiteMode) { foreach (var dp in m.DeviceProfiles) { if (dp.Address.HasValue) { dp.AddressName = Database.DiscoConfiguration.OrganisationAddresses.GetAddress(dp.Address.Value)?.Name; } } } return m; }
private static string RequiredFilePath(DiscoDataContext Database) { if (Database.DiscoConfiguration.DataStoreLocation != null) return Path.Combine(Database.DiscoConfiguration.DataStoreLocation, "_ThumbnailUpdateRequired.txt"); else return null; }
public UserHeldDeviceModel ToUserHeldDeviceModel(DiscoDataContext Database) { var uhdm = new UserHeldDeviceModel() { UserId = this.UserId, UserDisplayName = this.UserDisplayName, ReadyForReturn = this.ReadyForReturn, WaitingForUserAction = this.WaitingForUserAction, DeviceProfileId = this.DeviceProfileId, DeviceAddress = (this.DeviceAddressId.HasValue ? Database.DiscoConfiguration.OrganisationAddresses.GetAddress(this.DeviceAddressId.Value)?.ShortName : string.Empty) }; var n = DateTime.Now; if (!this.ReadyForReturn && this.EstimatedReturnTime.HasValue && this.EstimatedReturnTime.Value > n) { uhdm.EstimatedReturnTime = this.EstimatedReturnTime.FromNow(); } if (this.ReadyForReturn) { uhdm.ReadyForReturnSince = this.ReadyForReturnSince.FromNow(); uhdm.IsAlert = (this.ReadyForReturnSince.Value < DateTime.Now.AddDays(-3)); } if (this.WaitingForUserAction) { uhdm.WaitingForUserActionSince = this.WaitingForUserActionSince.FromNow(); uhdm.IsAlert = (this.WaitingForUserActionSince.Value < n.AddDays(-6)); } return uhdm; }
public List<Models.LogLiveEvent> Query(DiscoDataContext Database) { List<Models.LogLiveEvent> results = new List<LogLiveEvent>(); // Validate Options this.Validate(); var relevantLogFiles = RelevantLogFiles(Database); relevantLogFiles.Reverse(); foreach (var logFile in relevantLogFiles) { SqlCeConnectionStringBuilder sqlCeCSB = new SqlCeConnectionStringBuilder(); sqlCeCSB.DataSource = logFile.Item1; var logModules = LogContext.LogModules; using (var context = new LogPersistContext(sqlCeCSB.ToString())) { var query = this.BuildQuery(context, logFile.Item2, results.Count); IEnumerable<LogEvent> queryResults = query; // Run the Query results.AddRange(queryResults.Select(le => Models.LogLiveEvent.Create(logModules[le.ModuleId], logModules[le.ModuleId].EventTypes[le.EventTypeId], le.Timestamp, le.Arguments))); } if (this.Take.HasValue && this.Take.Value < results.Count) break; } return results; }
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 static string ComputerNameRender(this Device device, DiscoDataContext Database, ADDomain Domain) { if (Domain == null) throw new ArgumentNullException("Domain"); var deviceProfile = device.DeviceProfile; Expression computerNameTemplateExpression = null; computerNameTemplateExpression = ExpressionCache.GetValue(DeviceProfileExtensions.ComputerNameExpressionCacheModule, deviceProfile.Id.ToString(), () => { // Removed 2012-06-14 G# - Properties moved to DeviceProfile model & DB Migrated in DBv3. //return Expressions.Expression.TokenizeSingleDynamic(null, deviceProfile.Configuration(context).ComputerNameTemplate, 0); return Expression.TokenizeSingleDynamic(null, deviceProfile.ComputerNameTemplate, 0); }); var evaluatorVariables = Expression.StandardVariables(null, Database, UserService.CurrentUser, DateTime.Now, null); string rendered; try { rendered = computerNameTemplateExpression.EvaluateFirst<string>(device, evaluatorVariables); } catch (Exception ex) { ex.ToExceptionless().AddObject(deviceProfile.ComputerNameTemplate, "ComputerNameTemplate").Submit(); throw new InvalidOperationException(string.Format("An error occurred rendering the computer name: [{0}] {1}", ex.GetType().Name, ex.Message), ex.InnerException); } if (rendered == null || rendered.Length > 24) { throw new InvalidOperationException("The rendered computer name would be invalid or longer than 24 characters"); } return string.Format(@"{0}\{1}", Domain.NetBiosName, rendered); }
public static DeviceBatch DefaultNewDeviceBatch(DiscoDataContext Database) { return new DeviceBatch() { PurchaseDate = DateTime.Today }; }
public static List<DocumentTemplate> AvailableDocumentTemplates(this Device d, DiscoDataContext Database, User User, DateTime TimeStamp) { List<DocumentTemplate> ats = Database.DocumentTemplates .Where(at => !at.IsHidden && at.Scope == DocumentTemplate.DocumentTemplateScopes.Device).ToList(); return ats.Where(at => at.FilterExpressionMatches(d, Database, User, TimeStamp, DocumentState.DefaultState())).ToList(); }
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 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 void UpdateModel(DiscoDataContext Database) { if (this.JobTypes == null) JobTypes = Database.JobTypes.ToList(); if (this.JobSubTypes == null) JobSubTypes = Database.JobSubTypes.ToList(); }
public static bool FilterExpressionMatches(this DocumentTemplate dt, object Data, DiscoDataContext Database, User User, System.DateTime TimeStamp, DocumentState State) { if (!string.IsNullOrEmpty(dt.FilterExpression)) { var compiledExpression = dt.FilterExpressionFromCache(); var evaluatorVariables = Expression.StandardVariables(dt, Database, User, TimeStamp, State); try { var er = compiledExpression.EvaluateFirst<object>(Data, evaluatorVariables); if (er is bool) { return (bool)er; } bool erBool; if (bool.TryParse(er.ToString(), out erBool)) { return erBool; } } catch { return false; } } return true; }
public override void InitalizeScheduledTask(DiscoDataContext Database) { // Trigger Daily @ 12:30am TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithSchedule(CronScheduleBuilder.DailyAtHourAndMinute(0, 30)); this.ScheduleTask(triggerBuilder); }
public override int? GuessHeader(DiscoDataContext Database, DeviceImportContext Context) { // 'model' in column name var possibleColumns = Context.Header .Select((h, i) => Tuple.Create(h, i)) .Where(h => h.Item1.Item2 == DeviceImportFieldTypes.IgnoreColumn && h.Item1.Item1.IndexOf("model", System.StringComparison.OrdinalIgnoreCase) >= 0); // All Integers Numbers possibleColumns = possibleColumns.Where(h => { int lastValue; return Context.RawData.Select(v => v[h.Item2]).Take(100).Where(v => !string.IsNullOrWhiteSpace(v)).All(v => int.TryParse(v, out lastValue)); }).ToList(); // Multiple Columns, tighten column definition if (possibleColumns.Count() > 1) { possibleColumns = possibleColumns .Where(h => h.Item1.Item1.IndexOf("modelid", StringComparison.OrdinalIgnoreCase) >= 0 || h.Item1.Item1.IndexOf("model id", StringComparison.OrdinalIgnoreCase) >= 0); } return possibleColumns.Select(h => (int?)h.Item2).FirstOrDefault(); }
protected override void ExecuteTask() { string dataStoreLocation; using (DiscoDataContext database = new DiscoDataContext()) { dataStoreLocation = DataStore.CreateLocation(database, @"Cache\DocumentDropBox_SessionPages"); } int deleteCount = 0; int errorCount = 0; var dataStoreInfo = new DirectoryInfo(dataStoreLocation); foreach (var file in dataStoreInfo.GetFiles()) { try { if (file.CreationTime < DateTime.Today) { file.Delete(); deleteCount++; } } catch { errorCount++; } } Status.LogInformation($"Cleared DocumentDropBox_SessionPages Cache, Deleted {deleteCount} File/s, with {errorCount} Error/s"); }
public override bool Parse(DiscoDataContext Database, IDeviceImportCache Cache, DeviceImportContext Context, int RecordIndex, string DeviceSerialNumber, Device ExistingDevice, Dictionary<DeviceImportFieldTypes, string> Values, string Value) { if (string.IsNullOrWhiteSpace(Value)) parsedValue = null; else { parsedValue = Value.Trim(); } if (ExistingDevice == null && parsedValue != null) return Success(EntityState.Added); else if (ExistingDevice != null) { var detail = ExistingDevice.DeviceDetails.FirstOrDefault(dd => dd.Scope == DeviceDetail.ScopeHardware && dd.Key == DeviceDetail.HardwareKeyLanMacAddress); if (detail == null && parsedValue == null) return Success(EntityState.Unchanged); else if (detail == null && parsedValue != null) { return Success(EntityState.Modified); } else if (detail.Value != parsedValue) { previousValue = detail.Value; return Success(EntityState.Modified); } else return Success(EntityState.Unchanged); } else return Success(EntityState.Unchanged); }
public static Stream GenerateBulkFromPackage(DocumentTemplatePackage package, DiscoDataContext Database, User CreatorUser, DateTime Timestamp, bool InsertBlankPages, List<IAttachmentTarget> DataObjects) { if (DataObjects.Count > 0) { List<Stream> generatedPdfs = new List<Stream>(DataObjects.Count); using (var state = DocumentState.DefaultState()) { foreach (var d in DataObjects) { generatedPdfs.Add(package.GeneratePdfPackage(Database, d, CreatorUser, Timestamp, state)); state.SequenceNumber++; state.FlushScopeCache(); } } if (generatedPdfs.Count == 1) { return generatedPdfs[0]; } else { Stream bulkPdf = Utilities.JoinPdfs(package.InsertBlankPages || InsertBlankPages, generatedPdfs); foreach (Stream singlePdf in generatedPdfs) singlePdf.Dispose(); return bulkPdf; } } return null; }
public static void OnRemove(this UserFlagAssignment fa, DiscoDataContext Database, User RemovingUser) { if (!fa.CanRemove()) throw new InvalidOperationException("Removing user flags is denied"); fa.OnRemoveUnsafe(Database, RemovingUser); }
public static Stream GenerateBulkFromPackage(DocumentTemplatePackage package, DiscoDataContext Database, User CreatorUser, DateTime Timestamp, bool InsertBlankPages, List<string> DataObjectsIds) { List<IAttachmentTarget> DataObjects; switch (package.Scope) { case AttachmentTypes.Device: DataObjects = Database.Devices.Where(d => DataObjectsIds.Contains(d.SerialNumber)).ToList<IAttachmentTarget>(); break; case AttachmentTypes.Job: int[] intDataObjectsIds = DataObjectsIds.Select(i => int.Parse(i)).ToArray(); DataObjects = Database.Jobs.Where(j => intDataObjectsIds.Contains(j.Id)).ToList<IAttachmentTarget>(); break; case AttachmentTypes.User: DataObjects = new List<IAttachmentTarget>(DataObjectsIds.Count); for (int idIndex = 0; idIndex < DataObjectsIds.Count; idIndex++) { string dataObjectId = DataObjectsIds[idIndex]; var user = UserService.GetUser(ActiveDirectory.ParseDomainAccountId(dataObjectId), Database, true); if (user == null) throw new Exception($"Unknown Username specified: {dataObjectId}"); DataObjects.Add(user); } break; default: throw new InvalidOperationException("Invalid DocumentType Scope"); } return GenerateBulkFromPackage(package, Database, CreatorUser, Timestamp, InsertBlankPages, DataObjects); }
public ImportPage(DiscoDataContext Database, string SessionId, PdfDocument PdfiumDocument, int PageIndex) { this.Database = Database; this.SessionId = SessionId; this.PdfiumDocument = PdfiumDocument; this.PageIndex = PageIndex; }
public override void InitalizeScheduledTask(DiscoDataContext Database) { // Run in Background 5 Second after Scheduled (on App Startup) TriggerBuilder triggerBuilder = TriggerBuilder.Create().StartAt(new DateTimeOffset(DateTime.Now).AddSeconds(5)); this.ScheduleTask(triggerBuilder); }