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