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();
}
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 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);
}
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 override int? GuessHeader(DiscoDataContext Database, DeviceImportContext Context)
{
// 'serial' 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("serial", System.StringComparison.OrdinalIgnoreCase) >= 0);
// All Values
possibleColumns = possibleColumns.Where(h =>
{
return Context.RawData.Select(v => v[h.Item2]).All(v => !string.IsNullOrWhiteSpace(v));
}).ToList();
if (possibleColumns.Count() > 1)
{
// Hunt Database
var possibleColumnIndex = possibleColumns.Where(h =>
{
try
{
var top50SerialNumbers = Context.RawData.Select(v => v[h.Item2]).Take(50).ToArray();
return Database.Devices.Count(d => top50SerialNumbers.Contains(d.SerialNumber)) > 0;
}
catch (Exception) { return false; }
}).Select(h => (int?)h.Item2).FirstOrDefault();
if (possibleColumnIndex.HasValue)
return possibleColumnIndex;
}
return possibleColumns.Select(h => (int?)h.Item2).FirstOrDefault();
}
public override bool Parse(DiscoDataContext Database, IDeviceImportCache Cache, DeviceImportContext Context, int RecordIndex, string DeviceSerialNumber, Device ExistingDevice, Dictionary<DeviceImportFieldTypes, string> Values, string Value)
{
// Validate
if (string.IsNullOrWhiteSpace(Value))
return Error("The Device Serial Number is required");
else
{
parsedValue = Value.Trim();
if (parsedValue.Length > maxLength)
return Error($"Cannot be more than {maxLength} characters");
if (parsedValue.Contains(@"/"))
return Error(@"The '/' character is not allowed.");
if (parsedValue.Contains(@"\"))
return Error(@"The '\' character is not allowed.");
}
// Duplicate
var duplicate = Context.RawData
.Take(RecordIndex)
.Select((r, i) => Tuple.Create(i, ParseRawDeviceSerialNumber(r[Context.HeaderDeviceSerialNumberIndex])))
.Where(r => IsDeviceSerialNumberValid(r.Item2))
.FirstOrDefault(r => r.Item2.Equals(parsedValue, StringComparison.OrdinalIgnoreCase));
if (duplicate != null)
return Error($"This Device Serial Number was already present on Row {duplicate.Item1 + 1}");
// No action required
return Success(EntityState.Unchanged);
}
public override int? GuessHeader(DiscoDataContext Database, DeviceImportContext Context)
{
// column name
var possibleColumns = Context.Header
.Select((h, i) => Tuple.Create(h, i))
.Where(h => h.Item1.Item2 == DeviceImportFieldTypes.IgnoreColumn && h.Item1.Item1.IndexOf("location", System.StringComparison.OrdinalIgnoreCase) >= 0);
return possibleColumns.Select(h => (int?)h.Item2).FirstOrDefault();
}
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 = null; // Default = null
else
{
int valueInt;
if (int.TryParse(Value, out valueInt))
this.parsedValue = valueInt;
else
return Error("The Batch Identifier must be a number");
}
if (this.parsedValue.HasValue)
{
var b = Cache.DeviceBatches.FirstOrDefault(db => db.Id == parsedValue);
if (b == null)
return Error(string.Format("The identifier ({0}) does not match any Device Batch", Value));
friendlyValue = string.Format("{0} [{1}]", b.Name, b.Id);
}
else
friendlyValue = null;
if (ExistingDevice == null)
return Success(EntityState.Added);
else if (ExistingDevice != null && ExistingDevice.DeviceBatchId != parsedValue)
{
DeviceBatch previousBatch = null;
if (ExistingDevice.DeviceBatchId.HasValue)
previousBatch = Cache.DeviceBatches.FirstOrDefault(db => db.Id == ExistingDevice.DeviceBatchId.Value);
if (previousBatch != null)
friendlyPreviousValue = string.Format("{0} [{1}]", previousBatch.Name, previousBatch.Id);
return Success(EntityState.Modified);
}
else
return Success(EntityState.Unchanged);
}
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))
{
rawValue = null;
parsedValue = null;
}
else
{
DecommissionReasons valueReason;
if (!decommissionReasonsMap.Value.TryGetValue(Value.Trim(), out valueReason))
{
rawValue = Value.Trim();
return Error("Cannot parse the value as a Decommission Reason");
}
else
{
parsedValue = valueReason;
}
}
if (parsedValue.HasValue && !Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedDate))
{
string errorMessage;
if (!DeviceDecommissionedDateImportField.CanDecommissionDevice(ExistingDevice, Values, out errorMessage))
return Error(errorMessage);
setDate = true;
}
else if (parsedValue.HasValue && string.IsNullOrWhiteSpace(Values[DeviceImportFieldTypes.DeviceDecommissionedDate]))
{
setDate = true;
}
if (ExistingDevice != null && ExistingDevice.DecommissionReason != parsedValue)
{
previousValue = ExistingDevice.DecommissionReason;
return Success(EntityState.Modified);
}
else
return Success(EntityState.Unchanged);
}
public override int? GuessHeader(DiscoDataContext Database, DeviceImportContext Context)
{
// column name
var possibleColumns = Context.Header
.Select((h, i) => Tuple.Create(h, i))
.Where(h => h.Item1.Item2 == DeviceImportFieldTypes.IgnoreColumn &&
h.Item1.Item1.IndexOf("trust enrol", System.StringComparison.OrdinalIgnoreCase) >= 0 ||
h.Item1.Item1.IndexOf("enrolment trusted", System.StringComparison.OrdinalIgnoreCase) >= 0 ||
h.Item1.Item1.IndexOf("trust", System.StringComparison.OrdinalIgnoreCase) >= 0
);
// All Boolean
possibleColumns = possibleColumns.Where(h =>
{
bool lastValue;
return Context.RawData.Select(v => v[h.Item2]).Take(100).Where(v => !string.IsNullOrWhiteSpace(v)).All(v => ParseBoolean(v, out lastValue));
}).ToList();
return possibleColumns.Select(h => (int?)h.Item2).FirstOrDefault();
}
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 (parsedValue.Length > 250)
return Error("Cannot be more than 250 characters");
}
if (ExistingDevice == null && parsedValue != null)
return Success(EntityState.Added);
else if (ExistingDevice != null && ExistingDevice.Location != parsedValue)
{
previousValue = ExistingDevice.Location;
return Success(EntityState.Modified);
}
else
return Success(EntityState.Unchanged);
}
public override bool Parse(DiscoDataContext Database, IDeviceImportCache Cache, DeviceImportContext Context, int RecordIndex, string DeviceSerialNumber, Device ExistingDevice, Dictionary<DeviceImportFieldTypes, string> Values, string Value)
{
friendlyValue = Value;
if (!ParseBoolean(Value, out parsedValue))
return Error("Expected a Boolean expression (True, 1, Yes, On, False, 0, No, Off)");
friendlyValue = parsedValue.ToString();
if (parsedValue == true)
{
// Check Decommissioned
bool? importDecommissioning = null;
if (Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedDate) || Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedReason))
importDecommissioning = Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedDate) && !string.IsNullOrWhiteSpace(Values[DeviceImportFieldTypes.DeviceDecommissionedDate]) ||
Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedReason) && !string.IsNullOrWhiteSpace(Values[DeviceImportFieldTypes.DeviceDecommissionedReason]);
if (importDecommissioning.HasValue && importDecommissioning.Value)
return Error("Cannot enrol a device being decommissioned");
if (ExistingDevice != null && ExistingDevice.DecommissionedDate.HasValue && !importDecommissioning.HasValue)
{
return Error("Cannot enrol a decommissioned device");
}
}
if (ExistingDevice == null && parsedValue != false) // Default: True
{
return Success(EntityState.Added);
}
else if (ExistingDevice != null && ExistingDevice.AllowUnauthenticatedEnrol != parsedValue)
{
friendlyPreviousValue = ExistingDevice.AllowUnauthenticatedEnrol.ToString();
return Success(EntityState.Modified);
}
else
return Success(EntityState.Unchanged);
}
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))
{
rawValue = null;
parsedValue = null;
}
else
{
DateTime valueDateTime;
if (!DateTime.TryParse(Value.Trim(), CultureInfo.CurrentCulture, System.Globalization.DateTimeStyles.AssumeLocal, out valueDateTime))
{
rawValue = Value.Trim();
return Error(string.Format("Cannot parse the value as a Date/Time using {0} culture (system default).", CultureInfo.CurrentCulture.Name));
}
else
{
// Accuracy to the second (remove any milliseconds)
parsedValue = new DateTime((valueDateTime.Ticks / 10000000L) * 10000000L);
}
}
string errorMessage;
if (parsedValue.HasValue && !CanDecommissionDevice(ExistingDevice, Values, out errorMessage))
return Error(errorMessage);
setReason = !Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedReason) ||
(parsedValue.HasValue && string.IsNullOrWhiteSpace(Values[DeviceImportFieldTypes.DeviceDecommissionedReason]));
if (ExistingDevice != null && ExistingDevice.DecommissionedDate != parsedValue)
{
previousValue = ExistingDevice.DecommissionedDate;
return Success(EntityState.Modified);
}
else
return Success(EntityState.Unchanged);
}
public override bool Parse(DiscoDataContext Database, IDeviceImportCache Cache, DeviceImportContext Context, int RecordIndex, string DeviceSerialNumber, Device ExistingDevice, Dictionary<DeviceImportFieldTypes, string> Values, string Value)
{
friendlyValue = Value;
if (string.IsNullOrWhiteSpace(Value))
{
friendlyValue = null;
parsedValue = null;
}
else
{
parsedValue = Value.Trim();
parsedValue = ActiveDirectory.ParseDomainAccountId(parsedValue);
friendlyValue = parsedValue;
if (parsedValue.Length > 50)
return Error("Cannot be more than 50 characters");
}
if (parsedValue != null)
{
// Check User Exists
// Try Database
User user = Database.Users.FirstOrDefault(u => u.UserId == parsedValue);
try
{
// Try Updating from AD
user = UserService.GetUser(parsedValue, Database);
}
catch (Exception ex)
{
if (user == null)
return Error(ex.Message);
}
parsedValue = user.UserId;
friendlyValue = string.Format("{0} [{1}]", user.DisplayName, user.UserId);
// Check Decommissioned
bool? importDecommissioning = null;
if (Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedDate) || Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedReason))
importDecommissioning = Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedDate) && !string.IsNullOrWhiteSpace(Values[DeviceImportFieldTypes.DeviceDecommissionedDate]) ||
Values.ContainsKey(DeviceImportFieldTypes.DeviceDecommissionedReason) && !string.IsNullOrWhiteSpace(Values[DeviceImportFieldTypes.DeviceDecommissionedReason]);
if (importDecommissioning.HasValue && importDecommissioning.Value)
return Error("Cannot assign a user to a device being decommissioned");
if (ExistingDevice != null && ExistingDevice.DecommissionedDate.HasValue && !importDecommissioning.HasValue)
{
return Error("Cannot assign a user to a decommissioned device");
}
}
if (ExistingDevice == null && parsedValue != null)
{
return Success(EntityState.Added);
}
else if (ExistingDevice != null && ExistingDevice.AssignedUserId != parsedValue)
{
if (ExistingDevice.AssignedUserId != null)
friendlyPreviousValue = string.Format("{0} [{1}]", ExistingDevice.AssignedUser.DisplayName, ExistingDevice.AssignedUser.UserId);
else
friendlyPreviousValue = null;
return Success(EntityState.Modified);
}
else
return Success(EntityState.Unchanged);
}
