public async Task SetDeviceConfiguration(string deviceName, string configuration)
{
var loggerInfo = await db.LoggingDevices
.Where(dbLoggingDevice => dbLoggingDevice.DeviceName == deviceName)
.Select(dbLoggingDevice => new
{
LoggingDeviceId = dbLoggingDevice.Id
})
.SingleOrDefaultAsync();
if (loggerInfo == null)
{
// Could not find the supplied device name.
throw new DeviceNotFoundException(deviceName);
}
LoggingDevice device = new LoggingDevice
{
Id = loggerInfo.LoggingDeviceId,
PendingConfigurationString = configuration
};
db.LoggingDevices.Attach(device);
db.Entry(device).Property(dbLoggingDevice => dbLoggingDevice.PendingConfigurationString).IsModified = true;
await db.SaveChangesNoValidationAsync();
db.Entry(device).State = EntityState.Detached;
}
public async Task <bool> AssignFirmwareUpgradeToLoggers(int?firmwareUpgradeId, IEnumerable <int> loggerIds)
{
// Set all the loggers to the selected upgrade ID.
foreach (int loggerId in loggerIds)
{
LoggingDevice device = new LoggingDevice
{
Id = loggerId,
FirmwareUpgradeId = firmwareUpgradeId,
FirmwareUpgradeAttempts = firmwareUpgradeId.HasValue ? 0 : (int?)null
};
db.LoggingDevices.Attach(device);
db.Entry(device).Property(dbLoggingDevice => dbLoggingDevice.FirmwareUpgradeId).IsModified = true;
db.Entry(device).Property(dbLoggingDevice => dbLoggingDevice.FirmwareUpgradeAttempts).IsModified = true;
}
// Save the changes.
try
{
await db.SaveChangesNoValidationAsync();
}
catch (Exception e)
{
Trace.TraceError("Failed to assign upgrade to loggers: {0}", e);
return(false);
}
return(true);
}
public async Task <ActionResult> Delete(LoggingDeviceViewModel vm)
{
LoggingDevice device = new LoggingDevice
{
Id = vm.Id
};
await devicesService.DeleteLoggingDevice(device);
return(RedirectToAction("Index"));
}
public async Task UpdateLastContactTime(string deviceName)
{
LoggingDevice loggingDevice = await db.LoggingDevices
.SingleOrDefaultAsync(dbLoggingDevice => dbLoggingDevice.DeviceName == deviceName);
if (loggingDevice == null)
{
// Can't find the device.
throw new DeviceNotFoundException(deviceName);
}
loggingDevice.LastContactTime = DateTime.UtcNow;
await db.SaveChangesAsync();
}
public async Task MarkConfigurationSent(string deviceName)
{
LoggingDevice loggingDevice = await db.LoggingDevices
.SingleOrDefaultAsync(dbLoggingDevice => dbLoggingDevice.DeviceName == deviceName);
if (loggingDevice == null)
{
// Can't find the device.
throw new DeviceNotFoundException(deviceName);
}
loggingDevice.PendingConfigurationString = null;
loggingDevice.LastConfigRetrieved = DateTime.UtcNow;
await db.SaveChangesAsync();
}
public async Task <FirmwareUpgrade> GetNewFirmware(string deviceName, string deviceFirmwareHash)
{
// Save the device's reported firmware hash.
var loggerInfo = await db.LoggingDevices
.Where(dbLoggingDevice => dbLoggingDevice.DeviceName == deviceName)
.Select(dbLoggingDevice => new
{
LoggingDevice = dbLoggingDevice,
AssignedUpgradeHash = dbLoggingDevice.FirmwareUpgrade.FileHash
})
.SingleOrDefaultAsync();
if (loggerInfo == null)
{
// Could not find the supplied device name.
throw new DeviceNotFoundException(deviceName);
}
// Update firmware hash on device.
LoggingDevice device = loggerInfo.LoggingDevice;
device.FirmwareId = deviceFirmwareHash;
// Get the device's upgrade data if it is different.
if (!String.Equals(loggerInfo.AssignedUpgradeHash, deviceFirmwareHash) &&
device.FirmwareUpgradeAttempts < MaxFirmwareUpgradeAttempts)
{
// Save changes to the number of upgrade attempts and the hash on the device.
device.FirmwareUpgradeAttempts = (device.FirmwareUpgradeAttempts ?? 0) + 1;
await db.SaveChangesAsync();
return(await db.LoggingDevices
.Where(dbLoggingDevice => dbLoggingDevice.Id == device.Id)
.Select(dbLoggingDevice => dbLoggingDevice.FirmwareUpgrade)
.SingleOrDefaultAsync());
}
else
{
// Save change to the hash on the device.
await db.SaveChangesAsync();
// No new firmware upgrade to return.
return(null);
}
}
public async Task <ActionResult> Register(LoggingDeviceViewModel newDevice)
{
if (ModelState.IsValid)
{
LoggingDevice device = await devicesService.RegisterLoggingDevice(newDevice.DeviceName, newDevice.FriendlyName);
if (device != null)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("RegisterDeviceFailure", "Failed to register device. Has the device already been registered?");
}
}
return(View(newDevice));
}
public async Task <LoggingDevice> RegisterLoggingDevice(string deviceId, string deviceName)
{
LoggingDevice newDevice = new LoggingDevice
{
DeviceName = deviceId,
FriendlyName = deviceName
};
try
{
db.Entry(newDevice).State = EntityState.Added;
await db.SaveChangesAsync();
}
catch (Exception e)
{
Trace.TraceError("Error saving logging device: {0}", e);
return(null);
}
return(newDevice);
}
public async Task DeleteLoggingDevice(LoggingDevice device)
{
db.Entry(device).State = EntityState.Deleted;
await db.SaveChangesAsync();
}
