public async Task <IHttpActionResult> CreateDevice(
int customerId,
CreateDeviceRequestDto request
)
{
var operationResult = await devicesControllerHelper.CreateDevice(customerId, request);
if (operationResult.Status != CreateDeviceStatus.Success)
{
return(Content(
HttpStatusCode.BadRequest,
new ErrorResponseDto()
{
Error = ErrorCode.InvalidRequest,
Message = ErrorCode.InvalidRequest.Description(),
Details = operationResult.Status.Description()
}
));
}
return(Created(
new Uri(Request.RequestUri, operationResult.Content.Id.ToString()),
new PostResponseDto <Guid> {
Id = operationResult.Content.Id
}
));
}
public async Task <ActionResult> AddDevice([FromBody] CreateDeviceRequestDto deviceData)
{
HttpClient client = new HttpClient();
HttpResponseMessage response = await client.PostAsJsonAsync(
$"{baseURL}/devices/", deviceData);
response.EnsureSuccessStatusCode();
// return URI of the created resource.
return(Json(null));
}
public async Task CreateDevice_DeviceWasCreated_ReturnsCorrectResult()
{
// Arrange
const int testCustomerId = 3000;
var deviceDto = new CreateDeviceRequestDto
{
BirthDate = "1990-01-01",
PatientId = Guid.NewGuid(),
DeviceModel = "TestModel",
DeviceType = DeviceType.IVR,
Settings = new DeviceSettingsDto
{
iHealthAccount = "TestiHealthAccount",
BloodGlucosePeripheral = BloodGlucosePeripheral.glooko_metersync,
PinCode = "1234",
IsWeightAutomated = true,
IsPinCodeRequired = true,
IsBloodGlucoseAutomated = true,
IsBloodGlucoseManual = true,
IsBloodPressureAutomated = true,
IsBloodPressureManual = true,
IsPeakFlowAutomated = true,
IsPeakFlowManual = true,
IsPedometerAutomated = true,
IsPedometerManual = true,
IsPulseOxAutomated = true,
IsPulseOxManual = true,
IsTemperatureAutomated = true,
IsTemperatureManual = true,
IsWeightManual = true
}
};
Device createdDevice = null;
this.devicesServiceMock
.Setup(s => s.CreateDevice(It.IsAny <Device>()))
.Callback <Device>((deviceToSave) =>
{
createdDevice = deviceToSave;
createdDevice.Id = Guid.NewGuid();
createdDevice.ActivationCode = "actCode";
})
.Returns(() => Task.FromResult(
new OperationResultDto <Device, CreateDeviceStatus>(
CreateDeviceStatus.Success,
createdDevice)));
// Act
var result = await this.sut.CreateDevice(testCustomerId, deviceDto);
var actual = result.Content;
// Assert
Assert.IsNotNull(actual);
Assert.AreEqual(createdDevice.Id, actual.Id);
Assert.AreEqual(createdDevice.ActivationCode, actual.ActivationCode);
Assert.AreEqual(testCustomerId, actual.CustomerId);
Assert.AreEqual(deviceDto.DeviceModel, actual.DeviceModel);
Assert.AreEqual(deviceDto.DeviceType.ToString(), actual.DeviceType);
Assert.AreEqual(deviceDto.BirthDate, actual.BirthDate);
Assert.AreEqual(deviceDto.Settings.iHealthAccount, actual.Settings.iHealthAccount);
Assert.AreEqual(deviceDto.Settings.BloodGlucosePeripheral, actual.Settings.BloodGlucosePeripheral);
Assert.AreEqual(deviceDto.Settings.PinCode, actual.Settings.PinCode);
Assert.AreEqual(deviceDto.Settings.IsWeightAutomated, actual.Settings.IsWeightAutomated);
Assert.AreEqual(deviceDto.Settings.IsPinCodeRequired, actual.Settings.IsPinCodeRequired);
Assert.AreEqual(deviceDto.Settings.IsBloodGlucoseAutomated, actual.Settings.IsBloodGlucoseAutomated);
Assert.AreEqual(deviceDto.Settings.IsBloodGlucoseManual, actual.Settings.IsBloodGlucoseManual);
Assert.AreEqual(deviceDto.Settings.IsBloodPressureAutomated, actual.Settings.IsBloodPressureAutomated);
Assert.AreEqual(deviceDto.Settings.IsBloodPressureManual, actual.Settings.IsBloodPressureManual);
Assert.AreEqual(deviceDto.Settings.IsPeakFlowAutomated, actual.Settings.IsPeakFlowAutomated);
Assert.AreEqual(deviceDto.Settings.IsPeakFlowManual, actual.Settings.IsPeakFlowManual);
Assert.AreEqual(deviceDto.Settings.IsPedometerAutomated, actual.Settings.IsPedometerAutomated);
Assert.AreEqual(deviceDto.Settings.IsPedometerManual, actual.Settings.IsPedometerManual);
Assert.AreEqual(deviceDto.Settings.IsPulseOxAutomated, actual.Settings.IsPulseOxAutomated);
Assert.AreEqual(deviceDto.Settings.IsPulseOxManual, actual.Settings.IsPulseOxManual);
Assert.AreEqual(deviceDto.Settings.IsTemperatureAutomated, actual.Settings.IsTemperatureAutomated);
Assert.AreEqual(deviceDto.Settings.IsTemperatureManual, actual.Settings.IsTemperatureManual);
Assert.AreEqual(deviceDto.Settings.IsWeightManual, actual.Settings.IsWeightManual);
Assert.AreEqual(testMessagingHubUrl, actual.Settings.MessagingHubUrl);
}
/// <summary>
/// Creates the device.
/// </summary>
/// <param name="customerId">The customer identifier.</param>
/// <param name="deviceDto">The device dto.</param>
/// <returns></returns>
public async Task <OperationResultDto <CreateDeviceResponseDto, CreateDeviceStatus> > CreateDevice(int customerId,
CreateDeviceRequestDto deviceDto)
{
var device = Mapper.Map <CreateDeviceRequestDto, Device>(deviceDto);
device.CustomerId = customerId;
var createDeviceResult = await deviceService.CreateDevice(device);
if (createDeviceResult.Status != CreateDeviceStatus.Success)
{
return(createDeviceResult.Clone <CreateDeviceResponseDto>());
}
var createDeviceResponse = Mapper.Map <Device, CreateDeviceResponseDto>(createDeviceResult.Content);
return(new OperationResultDto <CreateDeviceResponseDto, CreateDeviceStatus>()
{
Content = createDeviceResponse,
Status = CreateDeviceStatus.Success
});
}
public async Task <ActionResult> Device_Create([DataSourceRequest] DataSourceRequest request, CreateDeviceRequestDto deviceData)
{
HttpClient client = new HttpClient();
if (deviceData != null && ModelState.IsValid)
{
HttpResponseMessage response = await client.PostAsJsonAsync(
$"{baseURL}/devices/", deviceData);
response.EnsureSuccessStatusCode();
// return URI of the created resource.
}
return(Json(new[] { deviceData }.ToDataSourceResult(request, ModelState)));
}
/// <summary>
/// Creates the specified create device dto.
/// </summary>
/// <param name="customerId">The customer identifier.</param>
/// <param name="request">The request.</param>
/// <param name="token">The token.</param>
/// <returns></returns>
public async Task <PostResponseDto <Guid> > CreateDevice(int customerId, CreateDeviceRequestDto request, string token)
{
return(await devicesDataProvider.CreateDevice(customerId, request, token));
}
/// <summary>
/// Creates the specified create device dto.
/// </summary>
/// <param name="customerId">The customer identifier.</param>
/// <param name="request">The request.</param>
/// <param name="bearerToken">The bearer token.</param>
/// <returns></returns>
public async Task <PostResponseDto <Guid> > CreateDevice(int customerId, CreateDeviceRequestDto request, string bearerToken)
{
return(await apiClient.SendRequestAsync <PostResponseDto <Guid> >(string.Format("/api/{0}/devices", customerId), request, Method.POST, null, bearerToken));
}
