public override void ExecuteCmdlet()
{
if (ShouldProcess(this.DpsName, DPSResources.RemoveEnrollment))
{
ProvisioningServiceDescription provisioningServiceDescription;
if (ParameterSetName.Equals(InputObjectParameterSet))
{
this.ResourceGroupName = this.DpsObject.ResourceGroupName;
this.DpsName = this.DpsObject.Name;
provisioningServiceDescription = IotDpsUtils.ConvertObject <PSProvisioningServiceDescription, ProvisioningServiceDescription>(this.DpsObject);
}
else
{
if (ParameterSetName.Equals(ResourceIdParameterSet))
{
this.ResourceGroupName = IotDpsUtils.GetResourceGroupName(this.ResourceId);
this.DpsName = IotDpsUtils.GetIotDpsName(this.ResourceId);
}
provisioningServiceDescription = GetIotDpsResource(this.ResourceGroupName, this.DpsName);
}
IEnumerable <SharedAccessSignatureAuthorizationRuleAccessRightsDescription> authPolicies = this.IotDpsClient.IotDpsResource.ListKeys(this.DpsName, this.ResourceGroupName);
SharedAccessSignatureAuthorizationRuleAccessRightsDescription policy = IotDpsUtils.GetPolicy(authPolicies, PSAccessRightsDescription.EnrollmentWrite);
PSIotDpsConnectionString psIotDpsConnectionString = IotDpsUtils.ToPSIotDpsConnectionString(policy, provisioningServiceDescription.Properties.ServiceOperationsHostName);
ProvisioningServiceClient client = ProvisioningServiceClient.CreateFromConnectionString(psIotDpsConnectionString.PrimaryConnectionString);
try
{
if (this.RegistrationId != null)
{
client.DeleteIndividualEnrollmentAsync(this.RegistrationId).GetAwaiter().GetResult();
}
else
{
QueryResult enrollments = client.CreateIndividualEnrollmentQuery(new QuerySpecification("select * from enrollments")).NextAsync().GetAwaiter().GetResult();
foreach (PSIndividualEnrollments enrollment in IotDpsUtils.ToPSIndividualEnrollments(enrollments.Items))
{
client.DeleteIndividualEnrollmentAsync(enrollment.RegistrationId).GetAwaiter().GetResult();
}
}
if (PassThru.IsPresent)
{
this.WriteObject(true);
}
}
catch
{
if (PassThru.IsPresent)
{
this.WriteObject(false);
}
}
}
}
public static async Task ProvisioningServiceClient_IndividualEnrollments_Create_Ok(string proxyServerAddress, AttestationMechanismType attestationType, ReprovisionPolicy reprovisionPolicy, AllocationPolicy allocationPolicy, CustomAllocationDefinition customAllocationDefinition, ICollection<string> iotHubsToProvisionTo)
{
using (ProvisioningServiceClient provisioningServiceClient = CreateProvisioningService(proxyServerAddress))
{
IndividualEnrollment individualEnrollment = await CreateIndividualEnrollment(provisioningServiceClient, attestationType, reprovisionPolicy, allocationPolicy, customAllocationDefinition, iotHubsToProvisionTo, null).ConfigureAwait(false);
IndividualEnrollment individualEnrollmentResult = await provisioningServiceClient.GetIndividualEnrollmentAsync(individualEnrollment.RegistrationId).ConfigureAwait(false);
Assert.AreEqual(individualEnrollmentResult.ProvisioningStatus, ProvisioningStatus.Enabled);
if (reprovisionPolicy != null)
{
Assert.AreEqual(reprovisionPolicy.UpdateHubAssignment, individualEnrollmentResult.ReprovisionPolicy.UpdateHubAssignment);
Assert.AreEqual(reprovisionPolicy.MigrateDeviceData, individualEnrollmentResult.ReprovisionPolicy.MigrateDeviceData);
}
if (customAllocationDefinition != null)
{
Assert.AreEqual(customAllocationDefinition.WebhookUrl, individualEnrollmentResult.CustomAllocationDefinition.WebhookUrl);
Assert.AreEqual(customAllocationDefinition.ApiVersion, individualEnrollmentResult.CustomAllocationDefinition.ApiVersion);
}
//allocation policy is never null
Assert.AreEqual(allocationPolicy, individualEnrollmentResult.AllocationPolicy);
await provisioningServiceClient.DeleteIndividualEnrollmentAsync(individualEnrollment.RegistrationId).ConfigureAwait(false);
}
}
public static async Task RunSample()
{
Console.WriteLine("Starting sample...");
using (ProvisioningServiceClient provisioningServiceClient =
ProvisioningServiceClient.CreateFromConnectionString(_provisioningConnectionString))
{
#region Create a new individualEnrollment config
Console.WriteLine("\nCreating a new individualEnrollment...");
Attestation attestation = new TpmAttestation(_tpmEndorsementKey);
IndividualEnrollment individualEnrollment =
new IndividualEnrollment(
SampleRegistrationId,
attestation);
// The following parameters are optional. Remove it if you don't need.
individualEnrollment.DeviceId = OptionalDeviceId;
individualEnrollment.ProvisioningStatus = OptionalProvisioningStatus;
#endregion
#region Create the individualEnrollment
Console.WriteLine("\nAdding new individualEnrollment...");
IndividualEnrollment individualEnrollmentResult =
await provisioningServiceClient.CreateOrUpdateIndividualEnrollmentAsync(individualEnrollment).ConfigureAwait(false);
Console.WriteLine("\nIndividualEnrollment created with success.");
Console.WriteLine(individualEnrollmentResult);
#endregion
#region Get info of individualEnrollment
Console.WriteLine("\nGetting the individualEnrollment information...");
IndividualEnrollment getResult =
await provisioningServiceClient.GetIndividualEnrollmentAsync(SampleRegistrationId).ConfigureAwait(false);
Console.WriteLine(getResult);
#endregion
#region Query info of individualEnrollment
Console.WriteLine("\nCreating a query for enrollments...");
QuerySpecification querySpecification = new QuerySpecification("SELECT * FROM enrollments");
using (Query query = provisioningServiceClient.CreateIndividualEnrollmentQuery(querySpecification))
{
while (query.HasNext())
{
Console.WriteLine("\nQuerying the next enrollments...");
QueryResult queryResult = await query.NextAsync().ConfigureAwait(false);
Console.WriteLine(queryResult);
}
}
#endregion
#region Delete info of individualEnrollment
Console.WriteLine("\nDeleting the individualEnrollment...");
await provisioningServiceClient.DeleteIndividualEnrollmentAsync(getResult).ConfigureAwait(false);
#endregion
}
}
private async Task ProvisioningServiceClient_IndividualEnrollments_Create_Ok(string proxyServerAddress)
{
ProvisioningServiceClient provisioningServiceClient = CreateProvisioningServiceWithProxy(proxyServerAddress);
IndividualEnrollment individualEnrollment = await CreateIndividualEnrollment(provisioningServiceClient).ConfigureAwait(false);
IndividualEnrollment individualEnrollmentResult = await provisioningServiceClient.GetIndividualEnrollmentAsync(RegistrationId).ConfigureAwait(false);
Assert.AreEqual(individualEnrollmentResult.ProvisioningStatus, ProvisioningStatus.Enabled);
await provisioningServiceClient.DeleteIndividualEnrollmentAsync(RegistrationId).ConfigureAwait(false);
}
/**********************************************************************************
* Deletes enrollment from DPS
*********************************************************************************/
public async Task <bool> DeleteDpsEnrollment(string registrationId)
{
bool bDeleted = false;
try
{
_logger.LogDebug($"Removing enrollment {registrationId}");
await _provisioningServiceClient.DeleteIndividualEnrollmentAsync(registrationId).ConfigureAwait(false);
bDeleted = true;
}
catch (Exception e)
{
_logger.LogError($"Exception in DeleteDpsEnrollment() : {e.Message}");
}
return(bDeleted);
}
public static async Task DeleteCreatedEnrollmentAsync(
EnrollmentType?enrollmentType,
string registrationId,
string groupId,
MsTestLogger logger)
{
using ProvisioningServiceClient dpsClient = CreateProvisioningService();
try
{
if (enrollmentType == EnrollmentType.Individual)
{
await RetryOperationHelper
.RetryOperationsAsync(
async() =>
{
await dpsClient.DeleteIndividualEnrollmentAsync(registrationId).ConfigureAwait(false);
},
s_provisioningServiceRetryPolicy,
s_retryableExceptions,
logger)
.ConfigureAwait(false);
}
else if (enrollmentType == EnrollmentType.Group)
{
await RetryOperationHelper
.RetryOperationsAsync(
async() =>
{
await dpsClient.DeleteEnrollmentGroupAsync(groupId).ConfigureAwait(false);
},
s_provisioningServiceRetryPolicy,
s_retryableExceptions,
logger)
.ConfigureAwait(false);
}
}
catch (Exception ex)
{
Console.WriteLine($"Cleanup of enrollment failed due to {ex}.");
}
}
public async Task DeleteIndividualEnrollmentAsync()
{
Console.WriteLine("\nDeleting the individualEnrollment...");
await _provisioningServiceClient.DeleteIndividualEnrollmentAsync(RegistrationId).ConfigureAwait(false);
}
public static async Task RunSample()
{
Console.WriteLine("Starting sample...");
TwinCollection desiredProperties =
new TwinCollection()
{
["Brand"] = "Contoso",
["Model"] = "SSC4",
["Color"] = "White",
};
using (ProvisioningServiceClient provisioningServiceClient =
ProvisioningServiceClient.CreateFromConnectionString(_provisioningConnectionString))
{
#region Create a new individualEnrollment
Console.WriteLine("\nCreating a new individualEnrollment...");
Attestation attestation = new TpmAttestation(_tpmEndorsementKey);
IndividualEnrollment individualEnrollment =
new IndividualEnrollment(
SampleRegistrationId,
attestation);
individualEnrollment.InitialTwinState = new TwinState(
null,
desiredProperties);
IndividualEnrollment individualEnrollmentResult =
await provisioningServiceClient.CreateOrUpdateIndividualEnrollmentAsync(individualEnrollment).ConfigureAwait(false);
Console.WriteLine("\nIndividualEnrollment created with success...");
Console.WriteLine(
"Note that there is a difference between the content of the individualEnrollment that you sent and\n" +
" the individualEnrollmentResult that you received. The individualEnrollmentResult contains the eTag.");
Console.WriteLine(
"\nindividualEnrollment:\n" + individualEnrollment);
Console.WriteLine(
"\nindividualEnrollmentResult:\n" + individualEnrollmentResult);
#endregion
#region Update the info of individualEnrollment
/*
* At this point, if you try to update your information in the provisioning service using the individualEnrollment
* that you created, it will fail because of the "precondition". It will happen because the individualEnrollment
* do not contains the eTag, and the provisioning service will not be able to check if the enrollment that you
* are updating is the correct one.
*
* So, to update the information you must use the individualEnrollmentResult that the provisioning service returned
* when you created the enrollment, another solution is get the latest enrollment from the provisioning service
* using the provisioningServiceClient.getIndividualEnrollment(), the result of this operation is an IndividualEnrollment
* object that contains the eTag.
*/
Console.WriteLine("\nUpdating the enrollment...");
desiredProperties["Color"] = "Glace white";
individualEnrollmentResult.InitialTwinState = new TwinState(null, desiredProperties);
individualEnrollmentResult =
await provisioningServiceClient.CreateOrUpdateIndividualEnrollmentAsync(individualEnrollmentResult).ConfigureAwait(false);
Console.WriteLine("\nIndividualEnrollment updated with success...");
Console.WriteLine(individualEnrollmentResult);
#endregion
#region Delete info of individualEnrollment
Console.WriteLine("\nDeleting the individualEnrollment...");
await provisioningServiceClient.DeleteIndividualEnrollmentAsync(_registrationId).ConfigureAwait(false);
#endregion
}
}
