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