< Summary

Class:Azure.Analytics.Synapse.Artifacts.NotebookRestClient
Assembly:Azure.Analytics.Synapse.Artifacts
File(s):C:\Git\azure-sdk-for-net\sdk\synapse\Azure.Analytics.Synapse.Artifacts\src\Generated\NotebookRestClient.cs
Covered lines:58
Uncovered lines:158
Coverable lines:216
Total lines:513
Line coverage:26.8% (58 of 216)
Covered branches:9
Total branches:68
Branch coverage:13.2% (9 of 68)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.ctor(...)-80%50%
CreateGetNotebooksByWorkspaceRequest()-100%100%
GetNotebooksByWorkspaceAsync()-87.5%50%
GetNotebooksByWorkspace(...)-87.5%50%
CreateGetNotebookSummaryByWorkSpaceRequest()-0%100%
GetNotebookSummaryByWorkSpaceAsync()-0%0%
GetNotebookSummaryByWorkSpace(...)-0%0%
CreateCreateOrUpdateNotebookRequest(...)-0%0%
CreateOrUpdateNotebookAsync()-0%0%
CreateOrUpdateNotebook(...)-0%0%
CreateGetNotebookRequest(...)-91.67%50%
GetNotebookAsync()-72.73%33.33%
GetNotebook(...)-72.73%33.33%
CreateDeleteNotebookRequest(...)-0%100%
DeleteNotebookAsync()-0%0%
DeleteNotebook(...)-0%0%
CreateGetNotebooksByWorkspaceNextPageRequest(...)-0%100%
GetNotebooksByWorkspaceNextPageAsync()-0%0%
GetNotebooksByWorkspaceNextPage(...)-0%0%
CreateGetNotebookSummaryByWorkSpaceNextPageRequest(...)-0%100%
GetNotebookSummaryByWorkSpaceNextPageAsync()-0%0%
GetNotebookSummaryByWorkSpaceNextPage(...)-0%0%

File(s)

C:\Git\azure-sdk-for-net\sdk\synapse\Azure.Analytics.Synapse.Artifacts\src\Generated\NotebookRestClient.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.Text.Json;
 10using System.Threading;
 11using System.Threading.Tasks;
 12using Azure;
 13using Azure.Analytics.Synapse.Artifacts.Models;
 14using Azure.Core;
 15using Azure.Core.Pipeline;
 16
 17namespace Azure.Analytics.Synapse.Artifacts
 18{
 19    internal partial class NotebookRestClient
 20    {
 21        private string endpoint;
 22        private string apiVersion;
 23        private ClientDiagnostics _clientDiagnostics;
 24        private HttpPipeline _pipeline;
 25
 26        /// <summary> Initializes a new instance of NotebookRestClient. </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"> The workspace development endpoint, for example https://myworkspace.dev.azuresynapse
 30        /// <param name="apiVersion"> Api Version. </param>
 31        /// <exception cref="ArgumentNullException"> <paramref name="endpoint"/> or <paramref name="apiVersion"/> is nul
 832        public NotebookRestClient(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, string endpoint, string ap
 33        {
 834            if (endpoint == null)
 35            {
 036                throw new ArgumentNullException(nameof(endpoint));
 37            }
 838            if (apiVersion == null)
 39            {
 040                throw new ArgumentNullException(nameof(apiVersion));
 41            }
 42
 843            this.endpoint = endpoint;
 844            this.apiVersion = apiVersion;
 845            _clientDiagnostics = clientDiagnostics;
 846            _pipeline = pipeline;
 847        }
 48
 49        internal HttpMessage CreateGetNotebooksByWorkspaceRequest()
 50        {
 451            var message = _pipeline.CreateMessage();
 452            var request = message.Request;
 453            request.Method = RequestMethod.Get;
 454            var uri = new RawRequestUriBuilder();
 455            uri.AppendRaw(endpoint, false);
 456            uri.AppendPath("/notebooks", false);
 457            uri.AppendQuery("api-version", apiVersion, true);
 458            request.Uri = uri;
 459            return message;
 60        }
 61
 62        /// <summary> Lists Notebooks. </summary>
 63        /// <param name="cancellationToken"> The cancellation token to use. </param>
 64        public async Task<Response<NotebookListResponse>> GetNotebooksByWorkspaceAsync(CancellationToken cancellationTok
 65        {
 266            using var message = CreateGetNotebooksByWorkspaceRequest();
 267            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 268            switch (message.Response.Status)
 69            {
 70                case 200:
 71                    {
 72                        NotebookListResponse value = default;
 273                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 274                        value = NotebookListResponse.DeserializeNotebookListResponse(document.RootElement);
 275                        return Response.FromValue(value, message.Response);
 76                    }
 77                default:
 078                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 79            }
 280        }
 81
 82        /// <summary> Lists Notebooks. </summary>
 83        /// <param name="cancellationToken"> The cancellation token to use. </param>
 84        public Response<NotebookListResponse> GetNotebooksByWorkspace(CancellationToken cancellationToken = default)
 85        {
 286            using var message = CreateGetNotebooksByWorkspaceRequest();
 287            _pipeline.Send(message, cancellationToken);
 288            switch (message.Response.Status)
 89            {
 90                case 200:
 91                    {
 92                        NotebookListResponse value = default;
 293                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 294                        value = NotebookListResponse.DeserializeNotebookListResponse(document.RootElement);
 295                        return Response.FromValue(value, message.Response);
 96                    }
 97                default:
 098                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 99            }
 2100        }
 101
 102        internal HttpMessage CreateGetNotebookSummaryByWorkSpaceRequest()
 103        {
 0104            var message = _pipeline.CreateMessage();
 0105            var request = message.Request;
 0106            request.Method = RequestMethod.Get;
 0107            var uri = new RawRequestUriBuilder();
 0108            uri.AppendRaw(endpoint, false);
 0109            uri.AppendPath("/notebooks/summary", false);
 0110            uri.AppendQuery("api-version", apiVersion, true);
 0111            request.Uri = uri;
 0112            return message;
 113        }
 114
 115        /// <summary> Lists a summary of Notebooks. </summary>
 116        /// <param name="cancellationToken"> The cancellation token to use. </param>
 117        public async Task<Response<NotebookListResponse>> GetNotebookSummaryByWorkSpaceAsync(CancellationToken cancellat
 118        {
 0119            using var message = CreateGetNotebookSummaryByWorkSpaceRequest();
 0120            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0121            switch (message.Response.Status)
 122            {
 123                case 200:
 124                    {
 125                        NotebookListResponse value = default;
 0126                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0127                        value = NotebookListResponse.DeserializeNotebookListResponse(document.RootElement);
 0128                        return Response.FromValue(value, message.Response);
 129                    }
 130                default:
 0131                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 132            }
 0133        }
 134
 135        /// <summary> Lists a summary of Notebooks. </summary>
 136        /// <param name="cancellationToken"> The cancellation token to use. </param>
 137        public Response<NotebookListResponse> GetNotebookSummaryByWorkSpace(CancellationToken cancellationToken = defaul
 138        {
 0139            using var message = CreateGetNotebookSummaryByWorkSpaceRequest();
 0140            _pipeline.Send(message, cancellationToken);
 0141            switch (message.Response.Status)
 142            {
 143                case 200:
 144                    {
 145                        NotebookListResponse value = default;
 0146                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0147                        value = NotebookListResponse.DeserializeNotebookListResponse(document.RootElement);
 0148                        return Response.FromValue(value, message.Response);
 149                    }
 150                default:
 0151                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 152            }
 0153        }
 154
 155        internal HttpMessage CreateCreateOrUpdateNotebookRequest(string notebookName, NotebookResource notebook, string 
 156        {
 0157            var message = _pipeline.CreateMessage();
 0158            var request = message.Request;
 0159            request.Method = RequestMethod.Put;
 0160            var uri = new RawRequestUriBuilder();
 0161            uri.AppendRaw(endpoint, false);
 0162            uri.AppendPath("/notebooks/", false);
 0163            uri.AppendPath(notebookName, true);
 0164            uri.AppendQuery("api-version", apiVersion, true);
 0165            request.Uri = uri;
 0166            if (ifMatch != null)
 167            {
 0168                request.Headers.Add("If-Match", ifMatch);
 169            }
 0170            request.Headers.Add("Content-Type", "application/json");
 0171            var content = new Utf8JsonRequestContent();
 0172            content.JsonWriter.WriteObjectValue(notebook);
 0173            request.Content = content;
 0174            return message;
 175        }
 176
 177        /// <summary> Creates or updates a Note Book. </summary>
 178        /// <param name="notebookName"> The notebook name. </param>
 179        /// <param name="notebook"> Note book resource definition. </param>
 180        /// <param name="ifMatch"> ETag of the Note book entity.  Should only be specified for update, for which it shou
 181        /// <param name="cancellationToken"> The cancellation token to use. </param>
 182        /// <exception cref="ArgumentNullException"> <paramref name="notebookName"/> or <paramref name="notebook"/> is n
 183        public async Task<Response<NotebookResource>> CreateOrUpdateNotebookAsync(string notebookName, NotebookResource 
 184        {
 0185            if (notebookName == null)
 186            {
 0187                throw new ArgumentNullException(nameof(notebookName));
 188            }
 0189            if (notebook == null)
 190            {
 0191                throw new ArgumentNullException(nameof(notebook));
 192            }
 193
 0194            using var message = CreateCreateOrUpdateNotebookRequest(notebookName, notebook, ifMatch);
 0195            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0196            switch (message.Response.Status)
 197            {
 198                case 200:
 199                    {
 200                        NotebookResource value = default;
 0201                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0202                        value = NotebookResource.DeserializeNotebookResource(document.RootElement);
 0203                        return Response.FromValue(value, message.Response);
 204                    }
 205                default:
 0206                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 207            }
 0208        }
 209
 210        /// <summary> Creates or updates a Note Book. </summary>
 211        /// <param name="notebookName"> The notebook name. </param>
 212        /// <param name="notebook"> Note book resource definition. </param>
 213        /// <param name="ifMatch"> ETag of the Note book entity.  Should only be specified for update, for which it shou
 214        /// <param name="cancellationToken"> The cancellation token to use. </param>
 215        /// <exception cref="ArgumentNullException"> <paramref name="notebookName"/> or <paramref name="notebook"/> is n
 216        public Response<NotebookResource> CreateOrUpdateNotebook(string notebookName, NotebookResource notebook, string 
 217        {
 0218            if (notebookName == null)
 219            {
 0220                throw new ArgumentNullException(nameof(notebookName));
 221            }
 0222            if (notebook == null)
 223            {
 0224                throw new ArgumentNullException(nameof(notebook));
 225            }
 226
 0227            using var message = CreateCreateOrUpdateNotebookRequest(notebookName, notebook, ifMatch);
 0228            _pipeline.Send(message, cancellationToken);
 0229            switch (message.Response.Status)
 230            {
 231                case 200:
 232                    {
 233                        NotebookResource value = default;
 0234                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0235                        value = NotebookResource.DeserializeNotebookResource(document.RootElement);
 0236                        return Response.FromValue(value, message.Response);
 237                    }
 238                default:
 0239                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 240            }
 0241        }
 242
 243        internal HttpMessage CreateGetNotebookRequest(string notebookName, string ifNoneMatch)
 244        {
 12245            var message = _pipeline.CreateMessage();
 12246            var request = message.Request;
 12247            request.Method = RequestMethod.Get;
 12248            var uri = new RawRequestUriBuilder();
 12249            uri.AppendRaw(endpoint, false);
 12250            uri.AppendPath("/notebooks/", false);
 12251            uri.AppendPath(notebookName, true);
 12252            uri.AppendQuery("api-version", apiVersion, true);
 12253            request.Uri = uri;
 12254            if (ifNoneMatch != null)
 255            {
 0256                request.Headers.Add("If-None-Match", ifNoneMatch);
 257            }
 12258            return message;
 259        }
 260
 261        /// <summary> Gets a Note Book. </summary>
 262        /// <param name="notebookName"> The notebook name. </param>
 263        /// <param name="ifNoneMatch"> ETag of the Notebook entity. Should only be specified for get. If the ETag matche
 264        /// <param name="cancellationToken"> The cancellation token to use. </param>
 265        /// <exception cref="ArgumentNullException"> <paramref name="notebookName"/> is null. </exception>
 266        public async Task<Response<NotebookResource>> GetNotebookAsync(string notebookName, string ifNoneMatch = null, C
 267        {
 6268            if (notebookName == null)
 269            {
 0270                throw new ArgumentNullException(nameof(notebookName));
 271            }
 272
 6273            using var message = CreateGetNotebookRequest(notebookName, ifNoneMatch);
 6274            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 6275            switch (message.Response.Status)
 276            {
 277                case 200:
 278                    {
 279                        NotebookResource value = default;
 6280                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 6281                        value = NotebookResource.DeserializeNotebookResource(document.RootElement);
 6282                        return Response.FromValue(value, message.Response);
 283                    }
 284                case 304:
 0285                    return Response.FromValue<NotebookResource>(null, message.Response);
 286                default:
 0287                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 288            }
 6289        }
 290
 291        /// <summary> Gets a Note Book. </summary>
 292        /// <param name="notebookName"> The notebook name. </param>
 293        /// <param name="ifNoneMatch"> ETag of the Notebook entity. Should only be specified for get. If the ETag matche
 294        /// <param name="cancellationToken"> The cancellation token to use. </param>
 295        /// <exception cref="ArgumentNullException"> <paramref name="notebookName"/> is null. </exception>
 296        public Response<NotebookResource> GetNotebook(string notebookName, string ifNoneMatch = null, CancellationToken 
 297        {
 6298            if (notebookName == null)
 299            {
 0300                throw new ArgumentNullException(nameof(notebookName));
 301            }
 302
 6303            using var message = CreateGetNotebookRequest(notebookName, ifNoneMatch);
 6304            _pipeline.Send(message, cancellationToken);
 6305            switch (message.Response.Status)
 306            {
 307                case 200:
 308                    {
 309                        NotebookResource value = default;
 6310                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 6311                        value = NotebookResource.DeserializeNotebookResource(document.RootElement);
 6312                        return Response.FromValue(value, message.Response);
 313                    }
 314                case 304:
 0315                    return Response.FromValue<NotebookResource>(null, message.Response);
 316                default:
 0317                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 318            }
 6319        }
 320
 321        internal HttpMessage CreateDeleteNotebookRequest(string notebookName)
 322        {
 0323            var message = _pipeline.CreateMessage();
 0324            var request = message.Request;
 0325            request.Method = RequestMethod.Delete;
 0326            var uri = new RawRequestUriBuilder();
 0327            uri.AppendRaw(endpoint, false);
 0328            uri.AppendPath("/notebooks/", false);
 0329            uri.AppendPath(notebookName, true);
 0330            uri.AppendQuery("api-version", apiVersion, true);
 0331            request.Uri = uri;
 0332            return message;
 333        }
 334
 335        /// <summary> Deletes a Note book. </summary>
 336        /// <param name="notebookName"> The notebook name. </param>
 337        /// <param name="cancellationToken"> The cancellation token to use. </param>
 338        /// <exception cref="ArgumentNullException"> <paramref name="notebookName"/> is null. </exception>
 339        public async Task<Response> DeleteNotebookAsync(string notebookName, CancellationToken cancellationToken = defau
 340        {
 0341            if (notebookName == null)
 342            {
 0343                throw new ArgumentNullException(nameof(notebookName));
 344            }
 345
 0346            using var message = CreateDeleteNotebookRequest(notebookName);
 0347            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0348            switch (message.Response.Status)
 349            {
 350                case 200:
 351                case 204:
 0352                    return message.Response;
 353                default:
 0354                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 355            }
 0356        }
 357
 358        /// <summary> Deletes a Note book. </summary>
 359        /// <param name="notebookName"> The notebook name. </param>
 360        /// <param name="cancellationToken"> The cancellation token to use. </param>
 361        /// <exception cref="ArgumentNullException"> <paramref name="notebookName"/> is null. </exception>
 362        public Response DeleteNotebook(string notebookName, CancellationToken cancellationToken = default)
 363        {
 0364            if (notebookName == null)
 365            {
 0366                throw new ArgumentNullException(nameof(notebookName));
 367            }
 368
 0369            using var message = CreateDeleteNotebookRequest(notebookName);
 0370            _pipeline.Send(message, cancellationToken);
 0371            switch (message.Response.Status)
 372            {
 373                case 200:
 374                case 204:
 0375                    return message.Response;
 376                default:
 0377                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 378            }
 0379        }
 380
 381        internal HttpMessage CreateGetNotebooksByWorkspaceNextPageRequest(string nextLink)
 382        {
 0383            var message = _pipeline.CreateMessage();
 0384            var request = message.Request;
 0385            request.Method = RequestMethod.Get;
 0386            var uri = new RawRequestUriBuilder();
 0387            uri.AppendRaw(endpoint, false);
 0388            uri.AppendRawNextLink(nextLink, false);
 0389            request.Uri = uri;
 0390            return message;
 391        }
 392
 393        /// <summary> Lists Notebooks. </summary>
 394        /// <param name="nextLink"> The URL to the next page of results. </param>
 395        /// <param name="cancellationToken"> The cancellation token to use. </param>
 396        /// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> is null. </exception>
 397        public async Task<Response<NotebookListResponse>> GetNotebooksByWorkspaceNextPageAsync(string nextLink, Cancella
 398        {
 0399            if (nextLink == null)
 400            {
 0401                throw new ArgumentNullException(nameof(nextLink));
 402            }
 403
 0404            using var message = CreateGetNotebooksByWorkspaceNextPageRequest(nextLink);
 0405            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0406            switch (message.Response.Status)
 407            {
 408                case 200:
 409                    {
 410                        NotebookListResponse value = default;
 0411                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0412                        value = NotebookListResponse.DeserializeNotebookListResponse(document.RootElement);
 0413                        return Response.FromValue(value, message.Response);
 414                    }
 415                default:
 0416                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 417            }
 0418        }
 419
 420        /// <summary> Lists Notebooks. </summary>
 421        /// <param name="nextLink"> The URL to the next page of results. </param>
 422        /// <param name="cancellationToken"> The cancellation token to use. </param>
 423        /// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> is null. </exception>
 424        public Response<NotebookListResponse> GetNotebooksByWorkspaceNextPage(string nextLink, CancellationToken cancell
 425        {
 0426            if (nextLink == null)
 427            {
 0428                throw new ArgumentNullException(nameof(nextLink));
 429            }
 430
 0431            using var message = CreateGetNotebooksByWorkspaceNextPageRequest(nextLink);
 0432            _pipeline.Send(message, cancellationToken);
 0433            switch (message.Response.Status)
 434            {
 435                case 200:
 436                    {
 437                        NotebookListResponse value = default;
 0438                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0439                        value = NotebookListResponse.DeserializeNotebookListResponse(document.RootElement);
 0440                        return Response.FromValue(value, message.Response);
 441                    }
 442                default:
 0443                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 444            }
 0445        }
 446
 447        internal HttpMessage CreateGetNotebookSummaryByWorkSpaceNextPageRequest(string nextLink)
 448        {
 0449            var message = _pipeline.CreateMessage();
 0450            var request = message.Request;
 0451            request.Method = RequestMethod.Get;
 0452            var uri = new RawRequestUriBuilder();
 0453            uri.AppendRaw(endpoint, false);
 0454            uri.AppendRawNextLink(nextLink, false);
 0455            request.Uri = uri;
 0456            return message;
 457        }
 458
 459        /// <summary> Lists a summary of Notebooks. </summary>
 460        /// <param name="nextLink"> The URL to the next page of results. </param>
 461        /// <param name="cancellationToken"> The cancellation token to use. </param>
 462        /// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> is null. </exception>
 463        public async Task<Response<NotebookListResponse>> GetNotebookSummaryByWorkSpaceNextPageAsync(string nextLink, Ca
 464        {
 0465            if (nextLink == null)
 466            {
 0467                throw new ArgumentNullException(nameof(nextLink));
 468            }
 469
 0470            using var message = CreateGetNotebookSummaryByWorkSpaceNextPageRequest(nextLink);
 0471            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0472            switch (message.Response.Status)
 473            {
 474                case 200:
 475                    {
 476                        NotebookListResponse value = default;
 0477                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0478                        value = NotebookListResponse.DeserializeNotebookListResponse(document.RootElement);
 0479                        return Response.FromValue(value, message.Response);
 480                    }
 481                default:
 0482                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 483            }
 0484        }
 485
 486        /// <summary> Lists a summary of Notebooks. </summary>
 487        /// <param name="nextLink"> The URL to the next page of results. </param>
 488        /// <param name="cancellationToken"> The cancellation token to use. </param>
 489        /// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> is null. </exception>
 490        public Response<NotebookListResponse> GetNotebookSummaryByWorkSpaceNextPage(string nextLink, CancellationToken c
 491        {
 0492            if (nextLink == null)
 493            {
 0494                throw new ArgumentNullException(nameof(nextLink));
 495            }
 496
 0497            using var message = CreateGetNotebookSummaryByWorkSpaceNextPageRequest(nextLink);
 0498            _pipeline.Send(message, cancellationToken);
 0499            switch (message.Response.Status)
 500            {
 501                case 200:
 502                    {
 503                        NotebookListResponse value = default;
 0504                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0505                        value = NotebookListResponse.DeserializeNotebookListResponse(document.RootElement);
 0506                        return Response.FromValue(value, message.Response);
 507                    }
 508                default:
 0509                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 510            }
 0511        }
 512    }
 513}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:40 PM
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
CreateGetNotebooksByWorkspaceRequest()
GetNotebooksByWorkspaceAsync()
GetNotebooksByWorkspace(...)
CreateGetNotebookSummaryByWorkSpaceRequest()
GetNotebookSummaryByWorkSpaceAsync()
GetNotebookSummaryByWorkSpace(...)
CreateCreateOrUpdateNotebookRequest(...)
CreateOrUpdateNotebookAsync()
CreateOrUpdateNotebook(...)
CreateGetNotebookRequest(...)
GetNotebookAsync()
GetNotebook(...)
CreateDeleteNotebookRequest(...)
DeleteNotebookAsync()
DeleteNotebook(...)
CreateGetNotebooksByWorkspaceNextPageRequest(...)
GetNotebooksByWorkspaceNextPageAsync()
GetNotebooksByWorkspaceNextPage(...)
CreateGetNotebookSummaryByWorkSpaceNextPageRequest(...)
GetNotebookSummaryByWorkSpaceNextPageAsync()
GetNotebookSummaryByWorkSpaceNextPage(...)