< Summary

Class:Azure.DigitalTwins.Core.DigitalTwinModelsRestClient
Assembly:Azure.DigitalTwins.Core
File(s):C:\Git\azure-sdk-for-net\sdk\digitaltwins\Azure.DigitalTwins.Core\src\Customized\DigitalTwinModelsRestClient.cs
C:\Git\azure-sdk-for-net\sdk\digitaltwins\Azure.DigitalTwins.Core\src\Generated\DigitalTwinModelsRestClient.cs
Covered lines:203
Uncovered lines:83
Coverable lines:286
Total lines:614
Line coverage:70.9% (203 of 286)
Covered branches:55
Total branches:96
Branch coverage:57.2% (55 of 96)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
CreateDeleteRequest(...)-100%100%
Delete(...)-100%100%
CreateListNextPageRequest(...)-100%100%
ListNextPage(...)-100%100%
DeleteAsync()-100%100%
ListNextPageAsync()-100%100%
AddAsync()-100%83.33%
.ctor(...)-100%75%
CreateListRequest(...)-88.24%70%
Add(...)-95.24%75%
ListAsync()-90%50%
UpdateAsync()-73.68%50%
List(...)-63.64%50%
Update(...)-76.19%62.5%
CreateGetByIdRequest(...)-100%66.67%
CreateAddRequest(...)-100%83.33%
GetByIdAsync()-100%83.33%
CreateUpdateRequest(...)-93.33%75%
GetById(...)-91.67%75%
AddAsync(...)-100%100%
Add(...)-100%100%
UpdateAsync(...)-0%100%
CreateUpdateRequest(...)-0%100%
Update(...)-0%100%
CreateAddRequest(...)-0%100%
.ctor(...)-88.89%50%
CreateListRequest(...)-86.67%62.5%
ListAsync()-87.5%50%
List(...)-87.5%50%
CreateGetByIdRequest(...)-100%100%
GetByIdAsync()-90%75%
GetById(...)-90%75%
CreateUpdateRequest(...)-0%0%
CreateDeleteRequest(...)-100%100%
DeleteAsync()-75%50%
Delete(...)-75%50%
CreateListNextPageRequest(...)-0%0%
ListNextPageAsync()-0%0%
ListNextPage(...)-0%0%

File(s)

C:\Git\azure-sdk-for-net\sdk\digitaltwins\Azure.DigitalTwins.Core\src\Customized\DigitalTwinModelsRestClient.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Collections.Generic;
 6using System.Text.Json;
 7using System.Threading;
 8using System.Threading.Tasks;
 9using Azure.Core;
 10using Azure.Core.Pipeline;
 11using Azure.DigitalTwins.Core.Serialization;
 12
 13namespace Azure.DigitalTwins.Core
 14{
 15    internal partial class DigitalTwinModelsRestClient
 16    {
 17        // The modelUpdates parameter needs to be changed from IEnumerable<object> to IEnumerable<string>
 18        // and not parsed like a json object.
 19        public async Task<Response<IReadOnlyList<ModelData>>> AddAsync(IEnumerable<string> models = null, CancellationTo
 20        {
 1821            using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinModelsClient.Add");
 1822            scope.Start();
 23            try
 24            {
 1825                using HttpMessage message = CreateAddRequest(models);
 1826                await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 1827                switch (message.Response.Status)
 28                {
 29                    case 200:
 30                    case 201:
 31                        {
 3032                            IReadOnlyList<ModelData> value = default;
 1633                            using JsonDocument document = await JsonDocument.ParseAsync(message.Response.ContentStream, 
 4634                            List<ModelData> array = new List<ModelData>(document.RootElement.GetArrayLength());
 11835                            foreach (JsonElement item in document.RootElement.EnumerateArray())
 36                            {
 2837                                array.Add(ModelData.DeserializeModelData(item));
 38                            }
 1639                            value = array;
 4640                            return Response.FromValue(value, message.Response);
 3041                        }
 3042                    default:
 3243                        throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
 3044                }
 45            }
 246            catch (Exception ex)
 47            {
 448                scope.Failed(ex);
 449                throw;
 250            }
 1851        }
 252
 253        // The modelUpdates parameter needs to be changed from IEnumerable<object> to IEnumerable<string>
 254        // and not parsed like a json object.
 55        internal Response<IReadOnlyList<ModelData>> Add(IEnumerable<string> models = null, CancellationToken cancellatio
 056        {
 1857            using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinModelsClient.Add");
 2058            scope.Start();
 59            try
 260            {
 1861                using HttpMessage message = CreateAddRequest(models);
 2062                _pipeline.Send(message, cancellationToken);
 2063                switch (message.Response.Status)
 264                {
 65                    case 200:
 066                    case 201:
 67                        {
 268                            IReadOnlyList<ModelData> value = default;
 1669                            using var document = JsonDocument.Parse(message.Response.ContentStream);
 1670                            List<ModelData> array = new List<ModelData>(document.RootElement.GetArrayLength());
 8871                            foreach (JsonElement item in document.RootElement.EnumerateArray())
 72                            {
 2873                                array.Add(ModelData.DeserializeModelData(item));
 74                            }
 1675                            value = array;
 1676                            return Response.FromValue(value, message.Response);
 77                        }
 78                    default:
 279                        throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 80                }
 81            }
 282            catch (Exception ex)
 183            {
 384                scope.Failed(ex);
 385                throw;
 86            }
 1687        }
 88
 89        // The modelUpdates parameter needs to be changed from IEnumerable<object> to IEnumerable<string>
 190        // and not parsed like a json object.
 191        internal async Task<Response> UpdateAsync(string id, IEnumerable<string> modelUpdates, CancellationToken cancell
 192        {
 293            if (id == null)
 94            {
 095                throw new ArgumentNullException(nameof(id));
 96            }
 397            if (modelUpdates == null)
 98            {
 099                throw new ArgumentNullException(nameof(modelUpdates));
 100            }
 101
 2102            using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinModelsClient.Update");
 2103            scope.Start();
 104            try
 105            {
 2106                using HttpMessage message = CreateUpdateRequest(id, modelUpdates);
 2107                await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 2108                return message.Response.Status switch
 2109                {
 4110                    204 => message.Response,
 1111                    _ => throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwa
 3112                };
 1113            }
 0114            catch (Exception e)
 115            {
 0116                scope.Failed(e);
 0117                throw;
 1118            }
 3119        }
 1120
 121        // The modelUpdates parameter needs to be changed from IEnumerable<object> to IEnumerable<string>
 122        // and not parsed like a json object.
 0123        internal Response Update(string id, IEnumerable<string> modelUpdates, CancellationToken cancellationToken = defa
 124        {
 3125            if (id == null)
 126            {
 0127                throw new ArgumentNullException(nameof(id));
 128            }
 50129            if (modelUpdates == null)
 48130            {
 48131                throw new ArgumentNullException(nameof(modelUpdates));
 48132            }
 48133
 50134            using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinModelsClient.Update");
 50135            scope.Start();
 48136            try
 137            {
 50138                using HttpMessage message = CreateUpdateRequest(id, modelUpdates);
 2139                _pipeline.Send(message, cancellationToken);
 50140                return message.Response.Status switch
 50141                {
 52142                    204 => message.Response,
 0143                    _ => throw _clientDiagnostics.CreateRequestFailedException(message.Response),
 2144                };
 145            }
 0146            catch (Exception e)
 147            {
 0148                scope.Failed(e);
 0149                throw;
 150            }
 2151        }
 152
 153        // The strings are already json, so we do not want them to be serialized.
 154        // Instead, the payloads need to be concatenated into a json array.
 155        private HttpMessage CreateAddRequest(IEnumerable<string> models)
 156        {
 60157            HttpMessage message = _pipeline.CreateMessage();
 36158            Request request = message.Request;
 36159            request.Method = RequestMethod.Post;
 36160            var uri = new RawRequestUriBuilder();
 36161            uri.Reset(endpoint);
 60162            uri.AppendPath("/models", false);
 60163            uri.AppendQuery("api-version", apiVersion, true);
 60164            request.Uri = uri;
 36165            request.Headers.Add("Content-Type", "application/json; charset=utf-8");
 36166            if (models != null)
 167            {
 36168                string modelsJsonArray = PayloadHelper.BuildArrayPayload(models);
 42169                request.Content = new StringRequestContent(modelsJsonArray);
 6170            }
 42171            return message;
 172        }
 173
 18174        // The strings are already json, so we do not want them to be serialized.
 175        // Instead, the payloads need to be concatenated into a json array.
 6176        internal HttpMessage CreateUpdateRequest(string id, IEnumerable<string> modelUpdates)
 177        {
 4178            HttpMessage message = _pipeline.CreateMessage();
 4179            Request request = message.Request;
 4180            request.Method = RequestMethod.Patch;
 4181            var uri = new RawRequestUriBuilder();
 4182            uri.Reset(endpoint);
 4183            uri.AppendPath("/models/", false);
 4184            uri.AppendPath(id, true);
 4185            uri.AppendQuery("api-version", apiVersion, true);
 4186            request.Uri = uri;
 4187            request.Headers.Add("Content-Type", "application/json; charset=utf-8");
 4188            if (modelUpdates != null)
 189            {
 28190                string modelUpdatesArray = PayloadHelper.BuildArrayPayload(modelUpdates);
 4191                request.Content = new StringRequestContent(modelUpdatesArray);
 0192            }
 4193            return message;
 194        }
 24195
 24196        #region null overrides
 24197
 198        // The following methods are only declared so that autorest does not create these functions in the generated cod
 199        // For methods that we need to override, when the parameter list is the same, autorest knows not to generate the
 200        // When the parameter list changes, autorest generates the methods again.
 201        // As such, these methods are declared here and made private, while the public method is declared above, too.
 6202        // These methods should never be called.
 6203
 6204#pragma warning disable CA1801, IDE0051, IDE0060 // Remove unused parameter
 205
 206        // Original return type is Task<Response<IReadOnlyList<ModelData>>>. Changing to object to allow returning null.
 18207        private object AddAsync(IEnumerable<object> models = null, CancellationToken cancellationToken = default) => nul
 208
 6209        private Response<IReadOnlyList<ModelData>> Add(IEnumerable<object> models = null, CancellationToken cancellation
 210
 211        // Original return type is ValueTask<Response>. Changing to object to allow returing null.
 0212        private object UpdateAsync(string id, IEnumerable<object> updateModel, CancellationToken cancellationToken = def
 0213
 0214        private Response Update(string id, IEnumerable<object> updateModel, CancellationToken cancellationToken = defaul
 0215
 0216        private HttpMessage CreateAddRequest(IEnumerable<object> models) => null;
 0217
 0218#pragma warning restore CA1801, IDE0051, IDE0060 // Remove unused parameter
 0219
 0220        #endregion null overrides
 0221    }
 0222}

C:\Git\azure-sdk-for-net\sdk\digitaltwins\Azure.DigitalTwins.Core\src\Generated\DigitalTwinModelsRestClient.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;
 16
 17namespace Azure.DigitalTwins.Core
 18{
 19    internal partial class DigitalTwinModelsRestClient
 20    {
 21        private Uri endpoint;
 22        private string apiVersion;
 23        private ClientDiagnostics _clientDiagnostics;
 24        private HttpPipeline _pipeline;
 25
 26        /// <summary> Initializes a new instance of DigitalTwinModelsRestClient. </summary>
 27        /// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
 28        /// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
 29        /// <param name="endpoint"> server parameter. </param>
 30        /// <param name="apiVersion"> Api Version. </param>
 31        /// <exception cref="ArgumentNullException"> <paramref name="apiVersion"/> is null. </exception>
 3032        public DigitalTwinModelsRestClient(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, Uri endpoint = nu
 33        {
 3034            endpoint ??= new Uri("https://digitaltwins-name.digitaltwins.azure.net");
 3035            if (apiVersion == null)
 36            {
 037                throw new ArgumentNullException(nameof(apiVersion));
 38            }
 39
 3040            this.endpoint = endpoint;
 3041            this.apiVersion = apiVersion;
 3042            _clientDiagnostics = clientDiagnostics;
 3043            _pipeline = pipeline;
 3044        }
 45
 46        internal HttpMessage CreateListRequest(IEnumerable<string> dependenciesFor, bool? includeModelDefinition, GetMod
 47        {
 248            var message = _pipeline.CreateMessage();
 249            var request = message.Request;
 250            request.Method = RequestMethod.Get;
 251            var uri = new RawRequestUriBuilder();
 252            uri.Reset(endpoint);
 253            uri.AppendPath("/models", false);
 254            if (dependenciesFor != null)
 55            {
 056                uri.AppendQueryDelimited("dependenciesFor", dependenciesFor, ",", true);
 57            }
 258            if (includeModelDefinition != null)
 59            {
 260                uri.AppendQuery("includeModelDefinition", includeModelDefinition.Value, true);
 61            }
 262            uri.AppendQuery("api-version", apiVersion, true);
 263            request.Uri = uri;
 264            if (digitalTwinModelsListOptions?.MaxItemCount != null)
 65            {
 066                request.Headers.Add("x-ms-max-item-count", digitalTwinModelsListOptions.MaxItemCount.Value);
 67            }
 268            return message;
 69        }
 70
 71        /// <summary>
 72        /// Retrieves model metadata and, optionally, model definitions.
 73        /// Status codes:
 74        /// 200 (OK): Success.
 75        /// 400 (Bad Request): The request is invalid.
 76        /// </summary>
 77        /// <param name="dependenciesFor"> The set of the models which will have their dependencies retrieved. If omitte
 78        /// <param name="includeModelDefinition"> When true the model definition will be returned as part of the result.
 79        /// <param name="digitalTwinModelsListOptions"> Parameter group. </param>
 80        /// <param name="cancellationToken"> The cancellation token to use. </param>
 81        public async Task<Response<PagedModelDataCollection>> ListAsync(IEnumerable<string> dependenciesFor = null, bool
 82        {
 183            using var message = CreateListRequest(dependenciesFor, includeModelDefinition, digitalTwinModelsListOptions)
 184            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 185            switch (message.Response.Status)
 86            {
 87                case 200:
 88                    {
 89                        PagedModelDataCollection value = default;
 190                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 191                        value = PagedModelDataCollection.DeserializePagedModelDataCollection(document.RootElement);
 192                        return Response.FromValue(value, message.Response);
 93                    }
 94                default:
 095                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 96            }
 197        }
 98
 99        /// <summary>
 100        /// Retrieves model metadata and, optionally, model definitions.
 101        /// Status codes:
 102        /// 200 (OK): Success.
 103        /// 400 (Bad Request): The request is invalid.
 104        /// </summary>
 105        /// <param name="dependenciesFor"> The set of the models which will have their dependencies retrieved. If omitte
 106        /// <param name="includeModelDefinition"> When true the model definition will be returned as part of the result.
 107        /// <param name="digitalTwinModelsListOptions"> Parameter group. </param>
 108        /// <param name="cancellationToken"> The cancellation token to use. </param>
 109        public Response<PagedModelDataCollection> List(IEnumerable<string> dependenciesFor = null, bool? includeModelDef
 110        {
 1111            using var message = CreateListRequest(dependenciesFor, includeModelDefinition, digitalTwinModelsListOptions)
 1112            _pipeline.Send(message, cancellationToken);
 1113            switch (message.Response.Status)
 114            {
 115                case 200:
 116                    {
 117                        PagedModelDataCollection value = default;
 1118                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 1119                        value = PagedModelDataCollection.DeserializePagedModelDataCollection(document.RootElement);
 1120                        return Response.FromValue(value, message.Response);
 121                    }
 122                default:
 0123                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 124            }
 1125        }
 126
 127        internal HttpMessage CreateGetByIdRequest(string id, bool? includeModelDefinition)
 128        {
 48129            var message = _pipeline.CreateMessage();
 48130            var request = message.Request;
 48131            request.Method = RequestMethod.Get;
 48132            var uri = new RawRequestUriBuilder();
 48133            uri.Reset(endpoint);
 48134            uri.AppendPath("/models/", false);
 48135            uri.AppendPath(id, true);
 48136            if (includeModelDefinition != null)
 137            {
 48138                uri.AppendQuery("includeModelDefinition", includeModelDefinition.Value, true);
 139            }
 48140            uri.AppendQuery("api-version", apiVersion, true);
 48141            request.Uri = uri;
 48142            return message;
 143        }
 144
 145        /// <summary>
 146        /// Retrieves model metadata and optionally the model definition.
 147        /// Status codes:
 148        /// 200 (OK): Success.
 149        /// 404 (Not Found): There is no model with the provided id.
 150        /// </summary>
 151        /// <param name="id"> The id for the model. The id is globally unique and case sensitive. </param>
 152        /// <param name="includeModelDefinition"> When true the model definition will be returned as part of the result.
 153        /// <param name="cancellationToken"> The cancellation token to use. </param>
 154        /// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
 155        public async Task<Response<ModelData>> GetByIdAsync(string id, bool? includeModelDefinition = null, Cancellation
 156        {
 24157            if (id == null)
 158            {
 0159                throw new ArgumentNullException(nameof(id));
 160            }
 161
 24162            using var message = CreateGetByIdRequest(id, includeModelDefinition);
 24163            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 24164            switch (message.Response.Status)
 165            {
 166                case 200:
 167                    {
 168                        ModelData value = default;
 6169                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 6170                        value = ModelData.DeserializeModelData(document.RootElement);
 6171                        return Response.FromValue(value, message.Response);
 172                    }
 173                default:
 18174                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 175            }
 6176        }
 177
 178        /// <summary>
 179        /// Retrieves model metadata and optionally the model definition.
 180        /// Status codes:
 181        /// 200 (OK): Success.
 182        /// 404 (Not Found): There is no model with the provided id.
 183        /// </summary>
 184        /// <param name="id"> The id for the model. The id is globally unique and case sensitive. </param>
 185        /// <param name="includeModelDefinition"> When true the model definition will be returned as part of the result.
 186        /// <param name="cancellationToken"> The cancellation token to use. </param>
 187        /// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
 188        public Response<ModelData> GetById(string id, bool? includeModelDefinition = null, CancellationToken cancellatio
 189        {
 24190            if (id == null)
 191            {
 0192                throw new ArgumentNullException(nameof(id));
 193            }
 194
 24195            using var message = CreateGetByIdRequest(id, includeModelDefinition);
 24196            _pipeline.Send(message, cancellationToken);
 24197            switch (message.Response.Status)
 198            {
 199                case 200:
 200                    {
 201                        ModelData value = default;
 6202                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 6203                        value = ModelData.DeserializeModelData(document.RootElement);
 6204                        return Response.FromValue(value, message.Response);
 205                    }
 206                default:
 18207                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 208            }
 6209        }
 210
 211        internal HttpMessage CreateUpdateRequest(string id, IEnumerable<object> updateModel)
 212        {
 0213            var message = _pipeline.CreateMessage();
 0214            var request = message.Request;
 0215            request.Method = RequestMethod.Patch;
 0216            var uri = new RawRequestUriBuilder();
 0217            uri.Reset(endpoint);
 0218            uri.AppendPath("/models/", false);
 0219            uri.AppendPath(id, true);
 0220            uri.AppendQuery("api-version", apiVersion, true);
 0221            request.Uri = uri;
 0222            request.Headers.Add("Content-Type", "application/json-patch+json");
 0223            var content = new Utf8JsonRequestContent();
 0224            content.JsonWriter.WriteStartArray();
 0225            foreach (var item in updateModel)
 226            {
 0227                content.JsonWriter.WriteObjectValue(item);
 228            }
 0229            content.JsonWriter.WriteEndArray();
 0230            request.Content = content;
 0231            return message;
 232        }
 233
 234        internal HttpMessage CreateDeleteRequest(string id)
 235        {
 24236            var message = _pipeline.CreateMessage();
 24237            var request = message.Request;
 24238            request.Method = RequestMethod.Delete;
 24239            var uri = new RawRequestUriBuilder();
 24240            uri.Reset(endpoint);
 24241            uri.AppendPath("/models/", false);
 24242            uri.AppendPath(id, true);
 24243            uri.AppendQuery("api-version", apiVersion, true);
 24244            request.Uri = uri;
 24245            return message;
 246        }
 247
 248        /// <summary>
 249        /// Deletes a model. A model can only be deleted if no other models reference it.
 250        /// Status codes:
 251        /// 204 (No Content): Success.
 252        /// 400 (Bad Request): The request is invalid.
 253        /// 404 (Not Found): There is no model with the provided id.
 254        /// 409 (Conflict): There are dependencies on the model that prevent it from being deleted.
 255        /// </summary>
 256        /// <param name="id"> The id for the model. The id is globally unique and case sensitive. </param>
 257        /// <param name="cancellationToken"> The cancellation token to use. </param>
 258        /// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
 259        public async Task<Response> DeleteAsync(string id, CancellationToken cancellationToken = default)
 260        {
 12261            if (id == null)
 262            {
 0263                throw new ArgumentNullException(nameof(id));
 264            }
 265
 12266            using var message = CreateDeleteRequest(id);
 12267            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 12268            switch (message.Response.Status)
 269            {
 270                case 204:
 12271                    return message.Response;
 272                default:
 0273                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 274            }
 12275        }
 276
 277        /// <summary>
 278        /// Deletes a model. A model can only be deleted if no other models reference it.
 279        /// Status codes:
 280        /// 204 (No Content): Success.
 281        /// 400 (Bad Request): The request is invalid.
 282        /// 404 (Not Found): There is no model with the provided id.
 283        /// 409 (Conflict): There are dependencies on the model that prevent it from being deleted.
 284        /// </summary>
 285        /// <param name="id"> The id for the model. The id is globally unique and case sensitive. </param>
 286        /// <param name="cancellationToken"> The cancellation token to use. </param>
 287        /// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
 288        public Response Delete(string id, CancellationToken cancellationToken = default)
 289        {
 12290            if (id == null)
 291            {
 0292                throw new ArgumentNullException(nameof(id));
 293            }
 294
 12295            using var message = CreateDeleteRequest(id);
 12296            _pipeline.Send(message, cancellationToken);
 12297            switch (message.Response.Status)
 298            {
 299                case 204:
 12300                    return message.Response;
 301                default:
 0302                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 303            }
 12304        }
 305
 306        internal HttpMessage CreateListNextPageRequest(string nextLink, IEnumerable<string> dependenciesFor, bool? inclu
 307        {
 0308            var message = _pipeline.CreateMessage();
 0309            var request = message.Request;
 0310            request.Method = RequestMethod.Get;
 0311            var uri = new RawRequestUriBuilder();
 0312            uri.Reset(endpoint);
 0313            uri.AppendRawNextLink(nextLink, false);
 0314            request.Uri = uri;
 0315            if (digitalTwinModelsListOptions?.MaxItemCount != null)
 316            {
 0317                request.Headers.Add("x-ms-max-item-count", digitalTwinModelsListOptions.MaxItemCount.Value);
 318            }
 0319            return message;
 320        }
 321
 322        /// <summary>
 323        /// Retrieves model metadata and, optionally, model definitions.
 324        /// Status codes:
 325        /// 200 (OK): Success.
 326        /// 400 (Bad Request): The request is invalid.
 327        /// </summary>
 328        /// <param name="nextLink"> The URL to the next page of results. </param>
 329        /// <param name="dependenciesFor"> The set of the models which will have their dependencies retrieved. If omitte
 330        /// <param name="includeModelDefinition"> When true the model definition will be returned as part of the result.
 331        /// <param name="digitalTwinModelsListOptions"> Parameter group. </param>
 332        /// <param name="cancellationToken"> The cancellation token to use. </param>
 333        /// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> is null. </exception>
 334        public async Task<Response<PagedModelDataCollection>> ListNextPageAsync(string nextLink, IEnumerable<string> dep
 335        {
 0336            if (nextLink == null)
 337            {
 0338                throw new ArgumentNullException(nameof(nextLink));
 339            }
 340
 0341            using var message = CreateListNextPageRequest(nextLink, dependenciesFor, includeModelDefinition, digitalTwin
 0342            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0343            switch (message.Response.Status)
 344            {
 345                case 200:
 346                    {
 347                        PagedModelDataCollection value = default;
 0348                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0349                        value = PagedModelDataCollection.DeserializePagedModelDataCollection(document.RootElement);
 0350                        return Response.FromValue(value, message.Response);
 351                    }
 352                default:
 0353                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 354            }
 0355        }
 356
 357        /// <summary>
 358        /// Retrieves model metadata and, optionally, model definitions.
 359        /// Status codes:
 360        /// 200 (OK): Success.
 361        /// 400 (Bad Request): The request is invalid.
 362        /// </summary>
 363        /// <param name="nextLink"> The URL to the next page of results. </param>
 364        /// <param name="dependenciesFor"> The set of the models which will have their dependencies retrieved. If omitte
 365        /// <param name="includeModelDefinition"> When true the model definition will be returned as part of the result.
 366        /// <param name="digitalTwinModelsListOptions"> Parameter group. </param>
 367        /// <param name="cancellationToken"> The cancellation token to use. </param>
 368        /// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> is null. </exception>
 369        public Response<PagedModelDataCollection> ListNextPage(string nextLink, IEnumerable<string> dependenciesFor = nu
 370        {
 0371            if (nextLink == null)
 372            {
 0373                throw new ArgumentNullException(nameof(nextLink));
 374            }
 375
 0376            using var message = CreateListNextPageRequest(nextLink, dependenciesFor, includeModelDefinition, digitalTwin
 0377            _pipeline.Send(message, cancellationToken);
 0378            switch (message.Response.Status)
 379            {
 380                case 200:
 381                    {
 382                        PagedModelDataCollection value = default;
 0383                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0384                        value = PagedModelDataCollection.DeserializePagedModelDataCollection(document.RootElement);
 0385                        return Response.FromValue(value, message.Response);
 386                    }
 387                default:
 0388                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 389            }
 0390        }
 391    }
 392}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:41 PM
GitHub | www.palmmedia.de

Methods/Properties

AddAsync()
.ctor(...)
CreateListRequest(...)
Add(...)
ListAsync()
UpdateAsync()
List(...)
Update(...)
CreateGetByIdRequest(...)
CreateAddRequest(...)
GetByIdAsync()
CreateUpdateRequest(...)
GetById(...)
AddAsync(...)
Add(...)
UpdateAsync(...)
CreateUpdateRequest(...)
Update(...)
CreateAddRequest(...)
.ctor(...)
CreateListRequest(...)
ListAsync()
List(...)
CreateGetByIdRequest(...)
GetByIdAsync()
GetById(...)
CreateUpdateRequest(...)
CreateDeleteRequest(...)
DeleteAsync()
Delete(...)
CreateListNextPageRequest(...)
ListNextPageAsync()
ListNextPage(...)