< Summary

Class:Azure.Iot.Hub.Service.ModulesRestClient
Assembly:Azure.Iot.Hub.Service
File(s):C:\Git\azure-sdk-for-net\sdk\iot\Azure.Iot.Hub.Service\src\Generated\ModulesRestClient.cs
Covered lines:181
Uncovered lines:154
Coverable lines:335
Total lines:759
Line coverage:54% (181 of 335)
Covered branches:46
Total branches:124
Branch coverage:37% (46 of 124)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.ctor(...)-88.89%50%
CreateGetTwinRequest(...)-100%100%
GetTwinAsync()-75%50%
GetTwin(...)-75%50%
CreateReplaceTwinRequest(...)-0%0%
ReplaceTwinAsync()-0%0%
ReplaceTwin(...)-0%0%
CreateUpdateTwinRequest(...)-100%100%
UpdateTwinAsync()-78.57%62.5%
UpdateTwin(...)-78.57%62.5%
CreateGetModulesOnDeviceRequest(...)-100%100%
GetModulesOnDeviceAsync()-84.62%66.67%
GetModulesOnDevice(...)-84.62%66.67%
CreateGetIdentityRequest(...)-100%100%
GetIdentityAsync()-75%50%
GetIdentity(...)-75%50%
CreateCreateOrUpdateIdentityRequest(...)-100%100%
CreateOrUpdateIdentityAsync()-78.57%62.5%
CreateOrUpdateIdentity(...)-78.57%62.5%
CreateDeleteIdentityRequest(...)-0%0%
DeleteIdentityAsync()-0%0%
DeleteIdentity(...)-0%0%
CreateInvokeMethodRequest(...)-0%100%
InvokeMethodAsync()-0%0%
InvokeMethod(...)-0%0%

File(s)

C:\Git\azure-sdk-for-net\sdk\iot\Azure.Iot.Hub.Service\src\Generated\ModulesRestClient.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4// <auto-generated/>
 5
 6#nullable disable
 7
 8using System;
 9using System.Collections.Generic;
 10using System.Text.Json;
 11using System.Threading;
 12using System.Threading.Tasks;
 13using Azure;
 14using Azure.Core;
 15using Azure.Core.Pipeline;
 16using Azure.Iot.Hub.Service.Models;
 17
 18namespace Azure.Iot.Hub.Service
 19{
 20    internal partial class ModulesRestClient
 21    {
 22        private Uri endpoint;
 23        private string apiVersion;
 24        private ClientDiagnostics _clientDiagnostics;
 25        private HttpPipeline _pipeline;
 26
 27        /// <summary> Initializes a new instance of ModulesRestClient. </summary>
 28        /// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
 29        /// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
 30        /// <param name="endpoint"> server parameter. </param>
 31        /// <param name="apiVersion"> Api Version. </param>
 32        /// <exception cref="ArgumentNullException"> <paramref name="apiVersion"/> is null. </exception>
 7633        public ModulesRestClient(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, Uri endpoint = null, string
 34        {
 7635            endpoint ??= new Uri("https://fully-qualified-iothubname.azure-devices.net");
 7636            if (apiVersion == null)
 37            {
 038                throw new ArgumentNullException(nameof(apiVersion));
 39            }
 40
 7641            this.endpoint = endpoint;
 7642            this.apiVersion = apiVersion;
 7643            _clientDiagnostics = clientDiagnostics;
 7644            _pipeline = pipeline;
 7645        }
 46
 47        internal HttpMessage CreateGetTwinRequest(string id, string mid)
 48        {
 1249            var message = _pipeline.CreateMessage();
 1250            var request = message.Request;
 1251            request.Method = RequestMethod.Get;
 1252            var uri = new RawRequestUriBuilder();
 1253            uri.Reset(endpoint);
 1254            uri.AppendPath("/twins/", false);
 1255            uri.AppendPath(id, true);
 1256            uri.AppendPath("/modules/", false);
 1257            uri.AppendPath(mid, true);
 1258            uri.AppendQuery("api-version", apiVersion, true);
 1259            request.Uri = uri;
 1260            return message;
 61        }
 62
 63        /// <summary> Gets the module twin. See https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-device-twins f
 64        /// <param name="id"> The unique identifier of the device. </param>
 65        /// <param name="mid"> The unique identifier of the module. </param>
 66        /// <param name="cancellationToken"> The cancellation token to use. </param>
 67        /// <exception cref="ArgumentNullException"> <paramref name="id"/> or <paramref name="mid"/> is null. </exceptio
 68        public async Task<Response<TwinData>> GetTwinAsync(string id, string mid, CancellationToken cancellationToken = 
 69        {
 670            if (id == null)
 71            {
 072                throw new ArgumentNullException(nameof(id));
 73            }
 674            if (mid == null)
 75            {
 076                throw new ArgumentNullException(nameof(mid));
 77            }
 78
 679            using var message = CreateGetTwinRequest(id, mid);
 680            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 681            switch (message.Response.Status)
 82            {
 83                case 200:
 84                    {
 85                        TwinData value = default;
 686                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 687                        value = TwinData.DeserializeTwinData(document.RootElement);
 688                        return Response.FromValue(value, message.Response);
 89                    }
 90                default:
 091                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 92            }
 693        }
 94
 95        /// <summary> Gets the module twin. See https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-device-twins f
 96        /// <param name="id"> The unique identifier of the device. </param>
 97        /// <param name="mid"> The unique identifier of the module. </param>
 98        /// <param name="cancellationToken"> The cancellation token to use. </param>
 99        /// <exception cref="ArgumentNullException"> <paramref name="id"/> or <paramref name="mid"/> is null. </exceptio
 100        public Response<TwinData> GetTwin(string id, string mid, CancellationToken cancellationToken = default)
 101        {
 6102            if (id == null)
 103            {
 0104                throw new ArgumentNullException(nameof(id));
 105            }
 6106            if (mid == null)
 107            {
 0108                throw new ArgumentNullException(nameof(mid));
 109            }
 110
 6111            using var message = CreateGetTwinRequest(id, mid);
 6112            _pipeline.Send(message, cancellationToken);
 6113            switch (message.Response.Status)
 114            {
 115                case 200:
 116                    {
 117                        TwinData value = default;
 6118                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 6119                        value = TwinData.DeserializeTwinData(document.RootElement);
 6120                        return Response.FromValue(value, message.Response);
 121                    }
 122                default:
 0123                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 124            }
 6125        }
 126
 127        internal HttpMessage CreateReplaceTwinRequest(string id, string mid, TwinData deviceTwinInfo, string ifMatch)
 128        {
 0129            var message = _pipeline.CreateMessage();
 0130            var request = message.Request;
 0131            request.Method = RequestMethod.Put;
 0132            var uri = new RawRequestUriBuilder();
 0133            uri.Reset(endpoint);
 0134            uri.AppendPath("/twins/", false);
 0135            uri.AppendPath(id, true);
 0136            uri.AppendPath("/modules/", false);
 0137            uri.AppendPath(mid, true);
 0138            uri.AppendQuery("api-version", apiVersion, true);
 0139            request.Uri = uri;
 0140            if (ifMatch != null)
 141            {
 0142                request.Headers.Add("If-Match", ifMatch);
 143            }
 0144            request.Headers.Add("Content-Type", "application/json");
 0145            var content = new Utf8JsonRequestContent();
 0146            content.JsonWriter.WriteObjectValue(deviceTwinInfo);
 0147            request.Content = content;
 0148            return message;
 149        }
 150
 151        /// <summary> Replaces the tags and desired properties of a module twin. See https://docs.microsoft.com/azure/io
 152        /// <param name="id"> The unique identifier of the device. </param>
 153        /// <param name="mid"> The unique identifier of the module. </param>
 154        /// <param name="deviceTwinInfo"> The module twin info that will replace the existing info. </param>
 155        /// <param name="ifMatch"> The string representing a weak ETag for the device twin, as per RFC7232. It determine
 156        /// <param name="cancellationToken"> The cancellation token to use. </param>
 157        /// <exception cref="ArgumentNullException"> <paramref name="id"/>, <paramref name="mid"/>, or <paramref name="d
 158        public async Task<Response<TwinData>> ReplaceTwinAsync(string id, string mid, TwinData deviceTwinInfo, string if
 159        {
 0160            if (id == null)
 161            {
 0162                throw new ArgumentNullException(nameof(id));
 163            }
 0164            if (mid == null)
 165            {
 0166                throw new ArgumentNullException(nameof(mid));
 167            }
 0168            if (deviceTwinInfo == null)
 169            {
 0170                throw new ArgumentNullException(nameof(deviceTwinInfo));
 171            }
 172
 0173            using var message = CreateReplaceTwinRequest(id, mid, deviceTwinInfo, ifMatch);
 0174            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0175            switch (message.Response.Status)
 176            {
 177                case 200:
 178                    {
 179                        TwinData value = default;
 0180                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0181                        value = TwinData.DeserializeTwinData(document.RootElement);
 0182                        return Response.FromValue(value, message.Response);
 183                    }
 184                default:
 0185                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 186            }
 0187        }
 188
 189        /// <summary> Replaces the tags and desired properties of a module twin. See https://docs.microsoft.com/azure/io
 190        /// <param name="id"> The unique identifier of the device. </param>
 191        /// <param name="mid"> The unique identifier of the module. </param>
 192        /// <param name="deviceTwinInfo"> The module twin info that will replace the existing info. </param>
 193        /// <param name="ifMatch"> The string representing a weak ETag for the device twin, as per RFC7232. It determine
 194        /// <param name="cancellationToken"> The cancellation token to use. </param>
 195        /// <exception cref="ArgumentNullException"> <paramref name="id"/>, <paramref name="mid"/>, or <paramref name="d
 196        public Response<TwinData> ReplaceTwin(string id, string mid, TwinData deviceTwinInfo, string ifMatch = null, Can
 197        {
 0198            if (id == null)
 199            {
 0200                throw new ArgumentNullException(nameof(id));
 201            }
 0202            if (mid == null)
 203            {
 0204                throw new ArgumentNullException(nameof(mid));
 205            }
 0206            if (deviceTwinInfo == null)
 207            {
 0208                throw new ArgumentNullException(nameof(deviceTwinInfo));
 209            }
 210
 0211            using var message = CreateReplaceTwinRequest(id, mid, deviceTwinInfo, ifMatch);
 0212            _pipeline.Send(message, cancellationToken);
 0213            switch (message.Response.Status)
 214            {
 215                case 200:
 216                    {
 217                        TwinData value = default;
 0218                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0219                        value = TwinData.DeserializeTwinData(document.RootElement);
 0220                        return Response.FromValue(value, message.Response);
 221                    }
 222                default:
 0223                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 224            }
 0225        }
 226
 227        internal HttpMessage CreateUpdateTwinRequest(string id, string mid, TwinData deviceTwinInfo, string ifMatch)
 228        {
 12229            var message = _pipeline.CreateMessage();
 12230            var request = message.Request;
 12231            request.Method = RequestMethod.Patch;
 12232            var uri = new RawRequestUriBuilder();
 12233            uri.Reset(endpoint);
 12234            uri.AppendPath("/twins/", false);
 12235            uri.AppendPath(id, true);
 12236            uri.AppendPath("/modules/", false);
 12237            uri.AppendPath(mid, true);
 12238            uri.AppendQuery("api-version", apiVersion, true);
 12239            request.Uri = uri;
 12240            if (ifMatch != null)
 241            {
 12242                request.Headers.Add("If-Match", ifMatch);
 243            }
 12244            request.Headers.Add("Content-Type", "application/json");
 12245            var content = new Utf8JsonRequestContent();
 12246            content.JsonWriter.WriteObjectValue(deviceTwinInfo);
 12247            request.Content = content;
 12248            return message;
 249        }
 250
 251        /// <summary> Updates the tags and desired properties of a module twin. See https://docs.microsoft.com/azure/iot
 252        /// <param name="id"> The unique identifier of the device. </param>
 253        /// <param name="mid"> The unique identifier of the module. </param>
 254        /// <param name="deviceTwinInfo"> The module twin info containing the tags and desired properties to be updated.
 255        /// <param name="ifMatch"> The string representing a weak ETag for the device twin, as per RFC7232. It determine
 256        /// <param name="cancellationToken"> The cancellation token to use. </param>
 257        /// <exception cref="ArgumentNullException"> <paramref name="id"/>, <paramref name="mid"/>, or <paramref name="d
 258        public async Task<Response<TwinData>> UpdateTwinAsync(string id, string mid, TwinData deviceTwinInfo, string ifM
 259        {
 6260            if (id == null)
 261            {
 0262                throw new ArgumentNullException(nameof(id));
 263            }
 6264            if (mid == null)
 265            {
 0266                throw new ArgumentNullException(nameof(mid));
 267            }
 6268            if (deviceTwinInfo == null)
 269            {
 0270                throw new ArgumentNullException(nameof(deviceTwinInfo));
 271            }
 272
 6273            using var message = CreateUpdateTwinRequest(id, mid, deviceTwinInfo, ifMatch);
 6274            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 6275            switch (message.Response.Status)
 276            {
 277                case 200:
 278                    {
 279                        TwinData value = default;
 4280                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 4281                        value = TwinData.DeserializeTwinData(document.RootElement);
 4282                        return Response.FromValue(value, message.Response);
 283                    }
 284                default:
 2285                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 286            }
 4287        }
 288
 289        /// <summary> Updates the tags and desired properties of a module twin. See https://docs.microsoft.com/azure/iot
 290        /// <param name="id"> The unique identifier of the device. </param>
 291        /// <param name="mid"> The unique identifier of the module. </param>
 292        /// <param name="deviceTwinInfo"> The module twin info containing the tags and desired properties to be updated.
 293        /// <param name="ifMatch"> The string representing a weak ETag for the device twin, as per RFC7232. It determine
 294        /// <param name="cancellationToken"> The cancellation token to use. </param>
 295        /// <exception cref="ArgumentNullException"> <paramref name="id"/>, <paramref name="mid"/>, or <paramref name="d
 296        public Response<TwinData> UpdateTwin(string id, string mid, TwinData deviceTwinInfo, string ifMatch = null, Canc
 297        {
 6298            if (id == null)
 299            {
 0300                throw new ArgumentNullException(nameof(id));
 301            }
 6302            if (mid == null)
 303            {
 0304                throw new ArgumentNullException(nameof(mid));
 305            }
 6306            if (deviceTwinInfo == null)
 307            {
 0308                throw new ArgumentNullException(nameof(deviceTwinInfo));
 309            }
 310
 6311            using var message = CreateUpdateTwinRequest(id, mid, deviceTwinInfo, ifMatch);
 6312            _pipeline.Send(message, cancellationToken);
 6313            switch (message.Response.Status)
 314            {
 315                case 200:
 316                    {
 317                        TwinData value = default;
 4318                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 4319                        value = TwinData.DeserializeTwinData(document.RootElement);
 4320                        return Response.FromValue(value, message.Response);
 321                    }
 322                default:
 2323                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 324            }
 4325        }
 326
 327        internal HttpMessage CreateGetModulesOnDeviceRequest(string id)
 328        {
 4329            var message = _pipeline.CreateMessage();
 4330            var request = message.Request;
 4331            request.Method = RequestMethod.Get;
 4332            var uri = new RawRequestUriBuilder();
 4333            uri.Reset(endpoint);
 4334            uri.AppendPath("/devices/", false);
 4335            uri.AppendPath(id, true);
 4336            uri.AppendPath("/modules", false);
 4337            uri.AppendQuery("api-version", apiVersion, true);
 4338            request.Uri = uri;
 4339            return message;
 340        }
 341
 342        /// <summary> Gets all the module identities on the device. </summary>
 343        /// <param name="id"> The unique identifier of the device. </param>
 344        /// <param name="cancellationToken"> The cancellation token to use. </param>
 345        /// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
 346        public async Task<Response<IReadOnlyList<ModuleIdentity>>> GetModulesOnDeviceAsync(string id, CancellationToken 
 347        {
 2348            if (id == null)
 349            {
 0350                throw new ArgumentNullException(nameof(id));
 351            }
 352
 2353            using var message = CreateGetModulesOnDeviceRequest(id);
 2354            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 2355            switch (message.Response.Status)
 356            {
 357                case 200:
 358                    {
 359                        IReadOnlyList<ModuleIdentity> value = default;
 2360                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 2361                        List<ModuleIdentity> array = new List<ModuleIdentity>();
 24362                        foreach (var item in document.RootElement.EnumerateArray())
 363                        {
 10364                            array.Add(ModuleIdentity.DeserializeModuleIdentity(item));
 365                        }
 2366                        value = array;
 2367                        return Response.FromValue(value, message.Response);
 368                    }
 369                default:
 0370                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 371            }
 2372        }
 373
 374        /// <summary> Gets all the module identities on the device. </summary>
 375        /// <param name="id"> The unique identifier of the device. </param>
 376        /// <param name="cancellationToken"> The cancellation token to use. </param>
 377        /// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
 378        public Response<IReadOnlyList<ModuleIdentity>> GetModulesOnDevice(string id, CancellationToken cancellationToken
 379        {
 2380            if (id == null)
 381            {
 0382                throw new ArgumentNullException(nameof(id));
 383            }
 384
 2385            using var message = CreateGetModulesOnDeviceRequest(id);
 2386            _pipeline.Send(message, cancellationToken);
 2387            switch (message.Response.Status)
 388            {
 389                case 200:
 390                    {
 391                        IReadOnlyList<ModuleIdentity> value = default;
 2392                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 2393                        List<ModuleIdentity> array = new List<ModuleIdentity>();
 24394                        foreach (var item in document.RootElement.EnumerateArray())
 395                        {
 10396                            array.Add(ModuleIdentity.DeserializeModuleIdentity(item));
 397                        }
 2398                        value = array;
 2399                        return Response.FromValue(value, message.Response);
 400                    }
 401                default:
 0402                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 403            }
 2404        }
 405
 406        internal HttpMessage CreateGetIdentityRequest(string id, string mid)
 407        {
 44408            var message = _pipeline.CreateMessage();
 44409            var request = message.Request;
 44410            request.Method = RequestMethod.Get;
 44411            var uri = new RawRequestUriBuilder();
 44412            uri.Reset(endpoint);
 44413            uri.AppendPath("/devices/", false);
 44414            uri.AppendPath(id, true);
 44415            uri.AppendPath("/modules/", false);
 44416            uri.AppendPath(mid, true);
 44417            uri.AppendQuery("api-version", apiVersion, true);
 44418            request.Uri = uri;
 44419            return message;
 420        }
 421
 422        /// <summary> Gets a module identity on the device. </summary>
 423        /// <param name="id"> The unique identifier of the device. </param>
 424        /// <param name="mid"> The unique identifier of the module. </param>
 425        /// <param name="cancellationToken"> The cancellation token to use. </param>
 426        /// <exception cref="ArgumentNullException"> <paramref name="id"/> or <paramref name="mid"/> is null. </exceptio
 427        public async Task<Response<ModuleIdentity>> GetIdentityAsync(string id, string mid, CancellationToken cancellati
 428        {
 22429            if (id == null)
 430            {
 0431                throw new ArgumentNullException(nameof(id));
 432            }
 22433            if (mid == null)
 434            {
 0435                throw new ArgumentNullException(nameof(mid));
 436            }
 437
 22438            using var message = CreateGetIdentityRequest(id, mid);
 22439            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 22440            switch (message.Response.Status)
 441            {
 442                case 200:
 443                    {
 444                        ModuleIdentity value = default;
 22445                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 22446                        value = ModuleIdentity.DeserializeModuleIdentity(document.RootElement);
 22447                        return Response.FromValue(value, message.Response);
 448                    }
 449                default:
 0450                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 451            }
 22452        }
 453
 454        /// <summary> Gets a module identity on the device. </summary>
 455        /// <param name="id"> The unique identifier of the device. </param>
 456        /// <param name="mid"> The unique identifier of the module. </param>
 457        /// <param name="cancellationToken"> The cancellation token to use. </param>
 458        /// <exception cref="ArgumentNullException"> <paramref name="id"/> or <paramref name="mid"/> is null. </exceptio
 459        public Response<ModuleIdentity> GetIdentity(string id, string mid, CancellationToken cancellationToken = default
 460        {
 22461            if (id == null)
 462            {
 0463                throw new ArgumentNullException(nameof(id));
 464            }
 22465            if (mid == null)
 466            {
 0467                throw new ArgumentNullException(nameof(mid));
 468            }
 469
 22470            using var message = CreateGetIdentityRequest(id, mid);
 22471            _pipeline.Send(message, cancellationToken);
 22472            switch (message.Response.Status)
 473            {
 474                case 200:
 475                    {
 476                        ModuleIdentity value = default;
 22477                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 22478                        value = ModuleIdentity.DeserializeModuleIdentity(document.RootElement);
 22479                        return Response.FromValue(value, message.Response);
 480                    }
 481                default:
 0482                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 483            }
 22484        }
 485
 486        internal HttpMessage CreateCreateOrUpdateIdentityRequest(string id, string mid, ModuleIdentity module, string if
 487        {
 92488            var message = _pipeline.CreateMessage();
 92489            var request = message.Request;
 92490            request.Method = RequestMethod.Put;
 92491            var uri = new RawRequestUriBuilder();
 92492            uri.Reset(endpoint);
 92493            uri.AppendPath("/devices/", false);
 92494            uri.AppendPath(id, true);
 92495            uri.AppendPath("/modules/", false);
 92496            uri.AppendPath(mid, true);
 92497            uri.AppendQuery("api-version", apiVersion, true);
 92498            request.Uri = uri;
 92499            if (ifMatch != null)
 500            {
 92501                request.Headers.Add("If-Match", ifMatch);
 502            }
 92503            request.Headers.Add("Content-Type", "application/json");
 92504            var content = new Utf8JsonRequestContent();
 92505            content.JsonWriter.WriteObjectValue(module);
 92506            request.Content = content;
 92507            return message;
 508        }
 509
 510        /// <summary> Creates or updates the module identity for a device in the IoT Hub. The moduleId and generationId 
 511        /// <param name="id"> The unique identifier of the device. </param>
 512        /// <param name="mid"> The unique identifier of the module. </param>
 513        /// <param name="module"> The module identity. </param>
 514        /// <param name="ifMatch"> The string representing a weak ETag for the module, as per RFC7232. Should not be set
 515        /// <param name="cancellationToken"> The cancellation token to use. </param>
 516        /// <exception cref="ArgumentNullException"> <paramref name="id"/>, <paramref name="mid"/>, or <paramref name="m
 517        public async Task<Response<ModuleIdentity>> CreateOrUpdateIdentityAsync(string id, string mid, ModuleIdentity mo
 518        {
 46519            if (id == null)
 520            {
 0521                throw new ArgumentNullException(nameof(id));
 522            }
 46523            if (mid == null)
 524            {
 0525                throw new ArgumentNullException(nameof(mid));
 526            }
 46527            if (module == null)
 528            {
 0529                throw new ArgumentNullException(nameof(module));
 530            }
 531
 46532            using var message = CreateCreateOrUpdateIdentityRequest(id, mid, module, ifMatch);
 46533            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 46534            switch (message.Response.Status)
 535            {
 536                case 200:
 537                case 201:
 538                    {
 539                        ModuleIdentity value = default;
 44540                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 44541                        value = ModuleIdentity.DeserializeModuleIdentity(document.RootElement);
 44542                        return Response.FromValue(value, message.Response);
 543                    }
 544                default:
 2545                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 546            }
 44547        }
 548
 549        /// <summary> Creates or updates the module identity for a device in the IoT Hub. The moduleId and generationId 
 550        /// <param name="id"> The unique identifier of the device. </param>
 551        /// <param name="mid"> The unique identifier of the module. </param>
 552        /// <param name="module"> The module identity. </param>
 553        /// <param name="ifMatch"> The string representing a weak ETag for the module, as per RFC7232. Should not be set
 554        /// <param name="cancellationToken"> The cancellation token to use. </param>
 555        /// <exception cref="ArgumentNullException"> <paramref name="id"/>, <paramref name="mid"/>, or <paramref name="m
 556        public Response<ModuleIdentity> CreateOrUpdateIdentity(string id, string mid, ModuleIdentity module, string ifMa
 557        {
 46558            if (id == null)
 559            {
 0560                throw new ArgumentNullException(nameof(id));
 561            }
 46562            if (mid == null)
 563            {
 0564                throw new ArgumentNullException(nameof(mid));
 565            }
 46566            if (module == null)
 567            {
 0568                throw new ArgumentNullException(nameof(module));
 569            }
 570
 46571            using var message = CreateCreateOrUpdateIdentityRequest(id, mid, module, ifMatch);
 46572            _pipeline.Send(message, cancellationToken);
 46573            switch (message.Response.Status)
 574            {
 575                case 200:
 576                case 201:
 577                    {
 578                        ModuleIdentity value = default;
 44579                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 44580                        value = ModuleIdentity.DeserializeModuleIdentity(document.RootElement);
 44581                        return Response.FromValue(value, message.Response);
 582                    }
 583                default:
 2584                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 585            }
 44586        }
 587
 588        internal HttpMessage CreateDeleteIdentityRequest(string id, string mid, string ifMatch)
 589        {
 0590            var message = _pipeline.CreateMessage();
 0591            var request = message.Request;
 0592            request.Method = RequestMethod.Delete;
 0593            var uri = new RawRequestUriBuilder();
 0594            uri.Reset(endpoint);
 0595            uri.AppendPath("/devices/", false);
 0596            uri.AppendPath(id, true);
 0597            uri.AppendPath("/modules/", false);
 0598            uri.AppendPath(mid, true);
 0599            uri.AppendQuery("api-version", apiVersion, true);
 0600            request.Uri = uri;
 0601            if (ifMatch != null)
 602            {
 0603                request.Headers.Add("If-Match", ifMatch);
 604            }
 0605            return message;
 606        }
 607
 608        /// <summary> Deletes the module identity for a device in the IoT Hub. </summary>
 609        /// <param name="id"> The unique identifier of the deivce. </param>
 610        /// <param name="mid"> The unique identifier of the module. </param>
 611        /// <param name="ifMatch"> The string representing a weak ETag for the module, as per RFC7232. The delete operat
 612        /// <param name="cancellationToken"> The cancellation token to use. </param>
 613        /// <exception cref="ArgumentNullException"> <paramref name="id"/> or <paramref name="mid"/> is null. </exceptio
 614        public async Task<Response> DeleteIdentityAsync(string id, string mid, string ifMatch = null, CancellationToken 
 615        {
 0616            if (id == null)
 617            {
 0618                throw new ArgumentNullException(nameof(id));
 619            }
 0620            if (mid == null)
 621            {
 0622                throw new ArgumentNullException(nameof(mid));
 623            }
 624
 0625            using var message = CreateDeleteIdentityRequest(id, mid, ifMatch);
 0626            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0627            switch (message.Response.Status)
 628            {
 629                case 204:
 0630                    return message.Response;
 631                default:
 0632                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 633            }
 0634        }
 635
 636        /// <summary> Deletes the module identity for a device in the IoT Hub. </summary>
 637        /// <param name="id"> The unique identifier of the deivce. </param>
 638        /// <param name="mid"> The unique identifier of the module. </param>
 639        /// <param name="ifMatch"> The string representing a weak ETag for the module, as per RFC7232. The delete operat
 640        /// <param name="cancellationToken"> The cancellation token to use. </param>
 641        /// <exception cref="ArgumentNullException"> <paramref name="id"/> or <paramref name="mid"/> is null. </exceptio
 642        public Response DeleteIdentity(string id, string mid, string ifMatch = null, CancellationToken cancellationToken
 643        {
 0644            if (id == null)
 645            {
 0646                throw new ArgumentNullException(nameof(id));
 647            }
 0648            if (mid == null)
 649            {
 0650                throw new ArgumentNullException(nameof(mid));
 651            }
 652
 0653            using var message = CreateDeleteIdentityRequest(id, mid, ifMatch);
 0654            _pipeline.Send(message, cancellationToken);
 0655            switch (message.Response.Status)
 656            {
 657                case 204:
 0658                    return message.Response;
 659                default:
 0660                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 661            }
 0662        }
 663
 664        internal HttpMessage CreateInvokeMethodRequest(string deviceId, string moduleId, CloudToDeviceMethodRequest dire
 665        {
 0666            var message = _pipeline.CreateMessage();
 0667            var request = message.Request;
 0668            request.Method = RequestMethod.Post;
 0669            var uri = new RawRequestUriBuilder();
 0670            uri.Reset(endpoint);
 0671            uri.AppendPath("/twins/", false);
 0672            uri.AppendPath(deviceId, true);
 0673            uri.AppendPath("/modules/", false);
 0674            uri.AppendPath(moduleId, true);
 0675            uri.AppendPath("/methods", false);
 0676            uri.AppendQuery("api-version", apiVersion, true);
 0677            request.Uri = uri;
 0678            request.Headers.Add("Content-Type", "application/json");
 0679            var content = new Utf8JsonRequestContent();
 0680            content.JsonWriter.WriteObjectValue(directMethodRequest);
 0681            request.Content = content;
 0682            return message;
 683        }
 684
 685        /// <summary> Invokes a direct method on a module of a device. See https://docs.microsoft.com/azure/iot-hub/iot-
 686        /// <param name="deviceId"> The unique identifier of the device. </param>
 687        /// <param name="moduleId"> The unique identifier of the module. </param>
 688        /// <param name="directMethodRequest"> The parameters to execute a direct method on the module. </param>
 689        /// <param name="cancellationToken"> The cancellation token to use. </param>
 690        /// <exception cref="ArgumentNullException"> <paramref name="deviceId"/>, <paramref name="moduleId"/>, or <param
 691        public async Task<Response<CloudToDeviceMethodResponse>> InvokeMethodAsync(string deviceId, string moduleId, Clo
 692        {
 0693            if (deviceId == null)
 694            {
 0695                throw new ArgumentNullException(nameof(deviceId));
 696            }
 0697            if (moduleId == null)
 698            {
 0699                throw new ArgumentNullException(nameof(moduleId));
 700            }
 0701            if (directMethodRequest == null)
 702            {
 0703                throw new ArgumentNullException(nameof(directMethodRequest));
 704            }
 705
 0706            using var message = CreateInvokeMethodRequest(deviceId, moduleId, directMethodRequest);
 0707            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0708            switch (message.Response.Status)
 709            {
 710                case 200:
 711                    {
 712                        CloudToDeviceMethodResponse value = default;
 0713                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0714                        value = CloudToDeviceMethodResponse.DeserializeCloudToDeviceMethodResponse(document.RootElement)
 0715                        return Response.FromValue(value, message.Response);
 716                    }
 717                default:
 0718                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 719            }
 0720        }
 721
 722        /// <summary> Invokes a direct method on a module of a device. See https://docs.microsoft.com/azure/iot-hub/iot-
 723        /// <param name="deviceId"> The unique identifier of the device. </param>
 724        /// <param name="moduleId"> The unique identifier of the module. </param>
 725        /// <param name="directMethodRequest"> The parameters to execute a direct method on the module. </param>
 726        /// <param name="cancellationToken"> The cancellation token to use. </param>
 727        /// <exception cref="ArgumentNullException"> <paramref name="deviceId"/>, <paramref name="moduleId"/>, or <param
 728        public Response<CloudToDeviceMethodResponse> InvokeMethod(string deviceId, string moduleId, CloudToDeviceMethodR
 729        {
 0730            if (deviceId == null)
 731            {
 0732                throw new ArgumentNullException(nameof(deviceId));
 733            }
 0734            if (moduleId == null)
 735            {
 0736                throw new ArgumentNullException(nameof(moduleId));
 737            }
 0738            if (directMethodRequest == null)
 739            {
 0740                throw new ArgumentNullException(nameof(directMethodRequest));
 741            }
 742
 0743            using var message = CreateInvokeMethodRequest(deviceId, moduleId, directMethodRequest);
 0744            _pipeline.Send(message, cancellationToken);
 0745            switch (message.Response.Status)
 746            {
 747                case 200:
 748                    {
 749                        CloudToDeviceMethodResponse value = default;
 0750                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0751                        value = CloudToDeviceMethodResponse.DeserializeCloudToDeviceMethodResponse(document.RootElement)
 0752                        return Response.FromValue(value, message.Response);
 753                    }
 754                default:
 0755                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 756            }
 0757        }
 758    }
 759}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:42 PM
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
CreateGetTwinRequest(...)
GetTwinAsync()
GetTwin(...)
CreateReplaceTwinRequest(...)
ReplaceTwinAsync()
ReplaceTwin(...)
CreateUpdateTwinRequest(...)
UpdateTwinAsync()
UpdateTwin(...)
CreateGetModulesOnDeviceRequest(...)
GetModulesOnDeviceAsync()
GetModulesOnDevice(...)
CreateGetIdentityRequest(...)
GetIdentityAsync()
GetIdentity(...)
CreateCreateOrUpdateIdentityRequest(...)
CreateOrUpdateIdentityAsync()
CreateOrUpdateIdentity(...)
CreateDeleteIdentityRequest(...)
DeleteIdentityAsync()
DeleteIdentity(...)
CreateInvokeMethodRequest(...)
InvokeMethodAsync()
InvokeMethod(...)