/// <summary>
/// Command Provision Device
/// The Certificate Model must be retrieve from /Certificates/DeviceProvisioning/ endpoint
/// </summary>
/// <param name="deviceCertificateModel">DeviceCertificateModel certificate</param>
/// <returns>True if autoprovisioning succeeded</returns>
public async Task <ResultCommand> ProvisionDevice(RequestCommandProvisionDevice requestProvisionDevice)
{
var resultProvisionDevice = await _streamClient.SendCommand <RequestCommandProvisionDevice, ResultCommand>
(CommandsEnum.ProvisionDevice, requestProvisionDevice, Common.Helpers.SharedConstants.DEFAULT_ENCRYPTION_KEY);
return(resultProvisionDevice);
}
public Task <ResultCommand> ProvisionDevice(RequestCommandProvisionDevice provisionDeviceCommand)
{
return(Task.FromResult(new ResultCommand()
{
IsSuccess = true
}));
}
public async Task <ResultCommand> ProvisionDevice(RequestCommandProvisionDevice requestProvisionDevice, string password)
{
try
{
DeviceCertificateModel certificateInfo = requestProvisionDevice.DeviceCertificateInformation;
//Load certificate chain
var(deviceCertificate, collectionCertificates) =
LoadCertificateFromPfx(Convert.FromBase64String(certificateInfo.Certificate), password);
//Save certificate in store
if (!await SaveCertificateInStore(deviceCertificate))
{
return(ResultCommand.CreateFailedCommand($"Error while saving User Certificate in Store."));
}
using (var securityProvider = new SecurityProviderX509Certificate(deviceCertificate, collectionCertificates))
{
using (var transport = new ProvisioningTransportHandlerHttp())
{
ProvisioningDeviceClient provClient =
ProvisioningDeviceClient.Create(certificateInfo.DpsInstance, certificateInfo.DpsIdScope, securityProvider, transport);
DeviceRegistrationResult result = await provClient.RegisterAsync();
if (result.Status != ProvisioningRegistrationStatusType.Assigned)
{
DebugHelper.LogError($"ProvisioningClient AssignedHub: {result.AssignedHub}; DeviceID: {result.DeviceId}");
return(ResultCommand.CreateFailedCommand($"Error during registration: {result.Status}, {result.ErrorMessage}"));
}
//Test the connection
if (!await TestDeviceConnection(result.DeviceId, result.AssignedHub, deviceCertificate))
{
return(ResultCommand.CreateFailedCommand($"Error while testing the device connection."));
}
//Persist provision in TPM/HSM
SimulatedDevice.ProvisionDevice(result.AssignedHub, result.DeviceId);
//Provisioned!
SimulatedDevice.IsProvisioned = true;
}
}
if (deviceCertificate != null)
{
deviceCertificate.Dispose();
}
return(ResultCommand.CreateSuccessCommand());
}
catch (Exception e)
{
DebugHelper.LogError($"Error ProvisionDevice: {e.Message}.");
return(ResultCommand.CreateFailedCommand($"Error ProvisionDevice: {e.Message}."));
}
}
public async Task <ResultCommand> ProvisionDevice(RequestCommandProvisionDevice requestProvisionDevice)
{
RestRequest request = await PrepareQuery("ProvisionDevice", Method.POST);
request.AddParameter("application/json", JsonConvert.SerializeObject(requestProvisionDevice), ParameterType.RequestBody);
var queryResult = await _client.ExecuteTaskAsync <Command>(request);
if (queryResult.IsSuccessful)
{
return(GetResultCommand <ResultCommand>(queryResult.Data));
}
else
{
Debug.WriteLine($"ProvisionDevice: {queryResult.StatusCode}");
}
return(ResultCommand.CreateFailedCommand <ResultCommand>($"ProvisionDevice: {queryResult.StatusCode}"));
}
public async Task <ResultCommand> ProvisionDevice(RequestCommandProvisionDevice provisionDeviceCommand)
{
try
{
var request = PrepareRequest("/ProvisionDevice", Method.POST, provisionDeviceCommand);
var queryResult = await client.ExecutePostTaskAsync <ResultCommand>(request);
if (queryResult.IsSuccessful)
{
return(queryResult.Data);
}
return(null);
}
catch (Exception e)
{
logger.Log(e);
return(null);
}
}
