1// +build go1.13
2
3// Copyright (c) Microsoft Corporation. All rights reserved.
4// Licensed under the MIT License. See License.txt in the project root for license information.
5// Code generated by Microsoft (R) AutoRest Code Generator.
6// Changes may cause incorrect behavior and will be lost if the code is regenerated.
7
8package armnetwork
9
10import (
11	"context"
12	"errors"
13	"fmt"
14	"github.com/Azure/azure-sdk-for-go/sdk/armcore"
15	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
16	"net/http"
17	"net/url"
18	"strings"
19	"time"
20)
21
22// ExpressRoutePortsClient contains the methods for the ExpressRoutePorts group.
23// Don't use this type directly, use NewExpressRoutePortsClient() instead.
24type ExpressRoutePortsClient struct {
25	con            *armcore.Connection
26	subscriptionID string
27}
28
29// NewExpressRoutePortsClient creates a new instance of ExpressRoutePortsClient with the specified values.
30func NewExpressRoutePortsClient(con *armcore.Connection, subscriptionID string) *ExpressRoutePortsClient {
31	return &ExpressRoutePortsClient{con: con, subscriptionID: subscriptionID}
32}
33
34// BeginCreateOrUpdate - Creates or updates the specified ExpressRoutePort resource.
35// If the operation fails it returns the *CloudError error type.
36func (client *ExpressRoutePortsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters ExpressRoutePort, options *ExpressRoutePortsBeginCreateOrUpdateOptions) (ExpressRoutePortPollerResponse, error) {
37	resp, err := client.createOrUpdate(ctx, resourceGroupName, expressRoutePortName, parameters, options)
38	if err != nil {
39		return ExpressRoutePortPollerResponse{}, err
40	}
41	result := ExpressRoutePortPollerResponse{
42		RawResponse: resp.Response,
43	}
44	pt, err := armcore.NewLROPoller("ExpressRoutePortsClient.CreateOrUpdate", "azure-async-operation", resp, client.con.Pipeline(), client.createOrUpdateHandleError)
45	if err != nil {
46		return ExpressRoutePortPollerResponse{}, err
47	}
48	poller := &expressRoutePortPoller{
49		pt: pt,
50	}
51	result.Poller = poller
52	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRoutePortResponse, error) {
53		return poller.pollUntilDone(ctx, frequency)
54	}
55	return result, nil
56}
57
58// ResumeCreateOrUpdate creates a new ExpressRoutePortPoller from the specified resume token.
59// token - The value must come from a previous call to ExpressRoutePortPoller.ResumeToken().
60func (client *ExpressRoutePortsClient) ResumeCreateOrUpdate(ctx context.Context, token string) (ExpressRoutePortPollerResponse, error) {
61	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRoutePortsClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError)
62	if err != nil {
63		return ExpressRoutePortPollerResponse{}, err
64	}
65	poller := &expressRoutePortPoller{
66		pt: pt,
67	}
68	resp, err := poller.Poll(ctx)
69	if err != nil {
70		return ExpressRoutePortPollerResponse{}, err
71	}
72	result := ExpressRoutePortPollerResponse{
73		RawResponse: resp,
74	}
75	result.Poller = poller
76	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (ExpressRoutePortResponse, error) {
77		return poller.pollUntilDone(ctx, frequency)
78	}
79	return result, nil
80}
81
82// CreateOrUpdate - Creates or updates the specified ExpressRoutePort resource.
83// If the operation fails it returns the *CloudError error type.
84func (client *ExpressRoutePortsClient) createOrUpdate(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters ExpressRoutePort, options *ExpressRoutePortsBeginCreateOrUpdateOptions) (*azcore.Response, error) {
85	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, expressRoutePortName, parameters, options)
86	if err != nil {
87		return nil, err
88	}
89	resp, err := client.con.Pipeline().Do(req)
90	if err != nil {
91		return nil, err
92	}
93	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
94		return nil, client.createOrUpdateHandleError(resp)
95	}
96	return resp, nil
97}
98
99// createOrUpdateCreateRequest creates the CreateOrUpdate request.
100func (client *ExpressRoutePortsClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters ExpressRoutePort, options *ExpressRoutePortsBeginCreateOrUpdateOptions) (*azcore.Request, error) {
101	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts/{expressRoutePortName}"
102	if client.subscriptionID == "" {
103		return nil, errors.New("parameter client.subscriptionID cannot be empty")
104	}
105	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
106	if resourceGroupName == "" {
107		return nil, errors.New("parameter resourceGroupName cannot be empty")
108	}
109	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
110	if expressRoutePortName == "" {
111		return nil, errors.New("parameter expressRoutePortName cannot be empty")
112	}
113	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
114	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
115	if err != nil {
116		return nil, err
117	}
118	req.Telemetry(telemetryInfo)
119	reqQP := req.URL.Query()
120	reqQP.Set("api-version", "2021-02-01")
121	req.URL.RawQuery = reqQP.Encode()
122	req.Header.Set("Accept", "application/json")
123	return req, req.MarshalAsJSON(parameters)
124}
125
126// createOrUpdateHandleError handles the CreateOrUpdate error response.
127func (client *ExpressRoutePortsClient) createOrUpdateHandleError(resp *azcore.Response) error {
128	body, err := resp.Payload()
129	if err != nil {
130		return azcore.NewResponseError(err, resp.Response)
131	}
132	errType := CloudError{raw: string(body)}
133	if err := resp.UnmarshalAsJSON(&errType); err != nil {
134		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
135	}
136	return azcore.NewResponseError(&errType, resp.Response)
137}
138
139// BeginDelete - Deletes the specified ExpressRoutePort resource.
140// If the operation fails it returns the *CloudError error type.
141func (client *ExpressRoutePortsClient) BeginDelete(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsBeginDeleteOptions) (HTTPPollerResponse, error) {
142	resp, err := client.deleteOperation(ctx, resourceGroupName, expressRoutePortName, options)
143	if err != nil {
144		return HTTPPollerResponse{}, err
145	}
146	result := HTTPPollerResponse{
147		RawResponse: resp.Response,
148	}
149	pt, err := armcore.NewLROPoller("ExpressRoutePortsClient.Delete", "location", resp, client.con.Pipeline(), client.deleteHandleError)
150	if err != nil {
151		return HTTPPollerResponse{}, err
152	}
153	poller := &httpPoller{
154		pt: pt,
155	}
156	result.Poller = poller
157	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
158		return poller.pollUntilDone(ctx, frequency)
159	}
160	return result, nil
161}
162
163// ResumeDelete creates a new HTTPPoller from the specified resume token.
164// token - The value must come from a previous call to HTTPPoller.ResumeToken().
165func (client *ExpressRoutePortsClient) ResumeDelete(ctx context.Context, token string) (HTTPPollerResponse, error) {
166	pt, err := armcore.NewLROPollerFromResumeToken("ExpressRoutePortsClient.Delete", token, client.con.Pipeline(), client.deleteHandleError)
167	if err != nil {
168		return HTTPPollerResponse{}, err
169	}
170	poller := &httpPoller{
171		pt: pt,
172	}
173	resp, err := poller.Poll(ctx)
174	if err != nil {
175		return HTTPPollerResponse{}, err
176	}
177	result := HTTPPollerResponse{
178		RawResponse: resp,
179	}
180	result.Poller = poller
181	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
182		return poller.pollUntilDone(ctx, frequency)
183	}
184	return result, nil
185}
186
187// Delete - Deletes the specified ExpressRoutePort resource.
188// If the operation fails it returns the *CloudError error type.
189func (client *ExpressRoutePortsClient) deleteOperation(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsBeginDeleteOptions) (*azcore.Response, error) {
190	req, err := client.deleteCreateRequest(ctx, resourceGroupName, expressRoutePortName, options)
191	if err != nil {
192		return nil, err
193	}
194	resp, err := client.con.Pipeline().Do(req)
195	if err != nil {
196		return nil, err
197	}
198	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent) {
199		return nil, client.deleteHandleError(resp)
200	}
201	return resp, nil
202}
203
204// deleteCreateRequest creates the Delete request.
205func (client *ExpressRoutePortsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsBeginDeleteOptions) (*azcore.Request, error) {
206	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts/{expressRoutePortName}"
207	if client.subscriptionID == "" {
208		return nil, errors.New("parameter client.subscriptionID cannot be empty")
209	}
210	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
211	if resourceGroupName == "" {
212		return nil, errors.New("parameter resourceGroupName cannot be empty")
213	}
214	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
215	if expressRoutePortName == "" {
216		return nil, errors.New("parameter expressRoutePortName cannot be empty")
217	}
218	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
219	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
220	if err != nil {
221		return nil, err
222	}
223	req.Telemetry(telemetryInfo)
224	reqQP := req.URL.Query()
225	reqQP.Set("api-version", "2021-02-01")
226	req.URL.RawQuery = reqQP.Encode()
227	req.Header.Set("Accept", "application/json")
228	return req, nil
229}
230
231// deleteHandleError handles the Delete error response.
232func (client *ExpressRoutePortsClient) deleteHandleError(resp *azcore.Response) error {
233	body, err := resp.Payload()
234	if err != nil {
235		return azcore.NewResponseError(err, resp.Response)
236	}
237	errType := CloudError{raw: string(body)}
238	if err := resp.UnmarshalAsJSON(&errType); err != nil {
239		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
240	}
241	return azcore.NewResponseError(&errType, resp.Response)
242}
243
244// GenerateLOA - Generate a letter of authorization for the requested ExpressRoutePort resource.
245// If the operation fails it returns the *CloudError error type.
246func (client *ExpressRoutePortsClient) GenerateLOA(ctx context.Context, resourceGroupName string, expressRoutePortName string, request GenerateExpressRoutePortsLOARequest, options *ExpressRoutePortsGenerateLOAOptions) (GenerateExpressRoutePortsLOAResultResponse, error) {
247	req, err := client.generateLOACreateRequest(ctx, resourceGroupName, expressRoutePortName, request, options)
248	if err != nil {
249		return GenerateExpressRoutePortsLOAResultResponse{}, err
250	}
251	resp, err := client.con.Pipeline().Do(req)
252	if err != nil {
253		return GenerateExpressRoutePortsLOAResultResponse{}, err
254	}
255	if !resp.HasStatusCode(http.StatusOK) {
256		return GenerateExpressRoutePortsLOAResultResponse{}, client.generateLOAHandleError(resp)
257	}
258	return client.generateLOAHandleResponse(resp)
259}
260
261// generateLOACreateRequest creates the GenerateLOA request.
262func (client *ExpressRoutePortsClient) generateLOACreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, request GenerateExpressRoutePortsLOARequest, options *ExpressRoutePortsGenerateLOAOptions) (*azcore.Request, error) {
263	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/expressRoutePorts/{expressRoutePortName}/generateLoa"
264	if client.subscriptionID == "" {
265		return nil, errors.New("parameter client.subscriptionID cannot be empty")
266	}
267	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
268	if resourceGroupName == "" {
269		return nil, errors.New("parameter resourceGroupName cannot be empty")
270	}
271	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
272	if expressRoutePortName == "" {
273		return nil, errors.New("parameter expressRoutePortName cannot be empty")
274	}
275	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
276	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
277	if err != nil {
278		return nil, err
279	}
280	req.Telemetry(telemetryInfo)
281	reqQP := req.URL.Query()
282	reqQP.Set("api-version", "2021-02-01")
283	req.URL.RawQuery = reqQP.Encode()
284	req.Header.Set("Accept", "application/json")
285	return req, req.MarshalAsJSON(request)
286}
287
288// generateLOAHandleResponse handles the GenerateLOA response.
289func (client *ExpressRoutePortsClient) generateLOAHandleResponse(resp *azcore.Response) (GenerateExpressRoutePortsLOAResultResponse, error) {
290	var val *GenerateExpressRoutePortsLOAResult
291	if err := resp.UnmarshalAsJSON(&val); err != nil {
292		return GenerateExpressRoutePortsLOAResultResponse{}, err
293	}
294	return GenerateExpressRoutePortsLOAResultResponse{RawResponse: resp.Response, GenerateExpressRoutePortsLOAResult: val}, nil
295}
296
297// generateLOAHandleError handles the GenerateLOA error response.
298func (client *ExpressRoutePortsClient) generateLOAHandleError(resp *azcore.Response) error {
299	body, err := resp.Payload()
300	if err != nil {
301		return azcore.NewResponseError(err, resp.Response)
302	}
303	errType := CloudError{raw: string(body)}
304	if err := resp.UnmarshalAsJSON(&errType); err != nil {
305		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
306	}
307	return azcore.NewResponseError(&errType, resp.Response)
308}
309
310// Get - Retrieves the requested ExpressRoutePort resource.
311// If the operation fails it returns the *CloudError error type.
312func (client *ExpressRoutePortsClient) Get(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsGetOptions) (ExpressRoutePortResponse, error) {
313	req, err := client.getCreateRequest(ctx, resourceGroupName, expressRoutePortName, options)
314	if err != nil {
315		return ExpressRoutePortResponse{}, err
316	}
317	resp, err := client.con.Pipeline().Do(req)
318	if err != nil {
319		return ExpressRoutePortResponse{}, err
320	}
321	if !resp.HasStatusCode(http.StatusOK) {
322		return ExpressRoutePortResponse{}, client.getHandleError(resp)
323	}
324	return client.getHandleResponse(resp)
325}
326
327// getCreateRequest creates the Get request.
328func (client *ExpressRoutePortsClient) getCreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, options *ExpressRoutePortsGetOptions) (*azcore.Request, error) {
329	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts/{expressRoutePortName}"
330	if client.subscriptionID == "" {
331		return nil, errors.New("parameter client.subscriptionID cannot be empty")
332	}
333	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
334	if resourceGroupName == "" {
335		return nil, errors.New("parameter resourceGroupName cannot be empty")
336	}
337	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
338	if expressRoutePortName == "" {
339		return nil, errors.New("parameter expressRoutePortName cannot be empty")
340	}
341	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
342	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
343	if err != nil {
344		return nil, err
345	}
346	req.Telemetry(telemetryInfo)
347	reqQP := req.URL.Query()
348	reqQP.Set("api-version", "2021-02-01")
349	req.URL.RawQuery = reqQP.Encode()
350	req.Header.Set("Accept", "application/json")
351	return req, nil
352}
353
354// getHandleResponse handles the Get response.
355func (client *ExpressRoutePortsClient) getHandleResponse(resp *azcore.Response) (ExpressRoutePortResponse, error) {
356	var val *ExpressRoutePort
357	if err := resp.UnmarshalAsJSON(&val); err != nil {
358		return ExpressRoutePortResponse{}, err
359	}
360	return ExpressRoutePortResponse{RawResponse: resp.Response, ExpressRoutePort: val}, nil
361}
362
363// getHandleError handles the Get error response.
364func (client *ExpressRoutePortsClient) getHandleError(resp *azcore.Response) error {
365	body, err := resp.Payload()
366	if err != nil {
367		return azcore.NewResponseError(err, resp.Response)
368	}
369	errType := CloudError{raw: string(body)}
370	if err := resp.UnmarshalAsJSON(&errType); err != nil {
371		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
372	}
373	return azcore.NewResponseError(&errType, resp.Response)
374}
375
376// List - List all the ExpressRoutePort resources in the specified subscription.
377// If the operation fails it returns the *CloudError error type.
378func (client *ExpressRoutePortsClient) List(options *ExpressRoutePortsListOptions) ExpressRoutePortListResultPager {
379	return &expressRoutePortListResultPager{
380		pipeline: client.con.Pipeline(),
381		requester: func(ctx context.Context) (*azcore.Request, error) {
382			return client.listCreateRequest(ctx, options)
383		},
384		responder: client.listHandleResponse,
385		errorer:   client.listHandleError,
386		advancer: func(ctx context.Context, resp ExpressRoutePortListResultResponse) (*azcore.Request, error) {
387			return azcore.NewRequest(ctx, http.MethodGet, *resp.ExpressRoutePortListResult.NextLink)
388		},
389		statusCodes: []int{http.StatusOK},
390	}
391}
392
393// listCreateRequest creates the List request.
394func (client *ExpressRoutePortsClient) listCreateRequest(ctx context.Context, options *ExpressRoutePortsListOptions) (*azcore.Request, error) {
395	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Network/ExpressRoutePorts"
396	if client.subscriptionID == "" {
397		return nil, errors.New("parameter client.subscriptionID cannot be empty")
398	}
399	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
400	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
401	if err != nil {
402		return nil, err
403	}
404	req.Telemetry(telemetryInfo)
405	reqQP := req.URL.Query()
406	reqQP.Set("api-version", "2021-02-01")
407	req.URL.RawQuery = reqQP.Encode()
408	req.Header.Set("Accept", "application/json")
409	return req, nil
410}
411
412// listHandleResponse handles the List response.
413func (client *ExpressRoutePortsClient) listHandleResponse(resp *azcore.Response) (ExpressRoutePortListResultResponse, error) {
414	var val *ExpressRoutePortListResult
415	if err := resp.UnmarshalAsJSON(&val); err != nil {
416		return ExpressRoutePortListResultResponse{}, err
417	}
418	return ExpressRoutePortListResultResponse{RawResponse: resp.Response, ExpressRoutePortListResult: val}, nil
419}
420
421// listHandleError handles the List error response.
422func (client *ExpressRoutePortsClient) listHandleError(resp *azcore.Response) error {
423	body, err := resp.Payload()
424	if err != nil {
425		return azcore.NewResponseError(err, resp.Response)
426	}
427	errType := CloudError{raw: string(body)}
428	if err := resp.UnmarshalAsJSON(&errType); err != nil {
429		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
430	}
431	return azcore.NewResponseError(&errType, resp.Response)
432}
433
434// ListByResourceGroup - List all the ExpressRoutePort resources in the specified resource group.
435// If the operation fails it returns the *CloudError error type.
436func (client *ExpressRoutePortsClient) ListByResourceGroup(resourceGroupName string, options *ExpressRoutePortsListByResourceGroupOptions) ExpressRoutePortListResultPager {
437	return &expressRoutePortListResultPager{
438		pipeline: client.con.Pipeline(),
439		requester: func(ctx context.Context) (*azcore.Request, error) {
440			return client.listByResourceGroupCreateRequest(ctx, resourceGroupName, options)
441		},
442		responder: client.listByResourceGroupHandleResponse,
443		errorer:   client.listByResourceGroupHandleError,
444		advancer: func(ctx context.Context, resp ExpressRoutePortListResultResponse) (*azcore.Request, error) {
445			return azcore.NewRequest(ctx, http.MethodGet, *resp.ExpressRoutePortListResult.NextLink)
446		},
447		statusCodes: []int{http.StatusOK},
448	}
449}
450
451// listByResourceGroupCreateRequest creates the ListByResourceGroup request.
452func (client *ExpressRoutePortsClient) listByResourceGroupCreateRequest(ctx context.Context, resourceGroupName string, options *ExpressRoutePortsListByResourceGroupOptions) (*azcore.Request, error) {
453	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts"
454	if client.subscriptionID == "" {
455		return nil, errors.New("parameter client.subscriptionID cannot be empty")
456	}
457	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
458	if resourceGroupName == "" {
459		return nil, errors.New("parameter resourceGroupName cannot be empty")
460	}
461	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
462	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
463	if err != nil {
464		return nil, err
465	}
466	req.Telemetry(telemetryInfo)
467	reqQP := req.URL.Query()
468	reqQP.Set("api-version", "2021-02-01")
469	req.URL.RawQuery = reqQP.Encode()
470	req.Header.Set("Accept", "application/json")
471	return req, nil
472}
473
474// listByResourceGroupHandleResponse handles the ListByResourceGroup response.
475func (client *ExpressRoutePortsClient) listByResourceGroupHandleResponse(resp *azcore.Response) (ExpressRoutePortListResultResponse, error) {
476	var val *ExpressRoutePortListResult
477	if err := resp.UnmarshalAsJSON(&val); err != nil {
478		return ExpressRoutePortListResultResponse{}, err
479	}
480	return ExpressRoutePortListResultResponse{RawResponse: resp.Response, ExpressRoutePortListResult: val}, nil
481}
482
483// listByResourceGroupHandleError handles the ListByResourceGroup error response.
484func (client *ExpressRoutePortsClient) listByResourceGroupHandleError(resp *azcore.Response) error {
485	body, err := resp.Payload()
486	if err != nil {
487		return azcore.NewResponseError(err, resp.Response)
488	}
489	errType := CloudError{raw: string(body)}
490	if err := resp.UnmarshalAsJSON(&errType); err != nil {
491		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
492	}
493	return azcore.NewResponseError(&errType, resp.Response)
494}
495
496// UpdateTags - Update ExpressRoutePort tags.
497// If the operation fails it returns the *CloudError error type.
498func (client *ExpressRoutePortsClient) UpdateTags(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters TagsObject, options *ExpressRoutePortsUpdateTagsOptions) (ExpressRoutePortResponse, error) {
499	req, err := client.updateTagsCreateRequest(ctx, resourceGroupName, expressRoutePortName, parameters, options)
500	if err != nil {
501		return ExpressRoutePortResponse{}, err
502	}
503	resp, err := client.con.Pipeline().Do(req)
504	if err != nil {
505		return ExpressRoutePortResponse{}, err
506	}
507	if !resp.HasStatusCode(http.StatusOK) {
508		return ExpressRoutePortResponse{}, client.updateTagsHandleError(resp)
509	}
510	return client.updateTagsHandleResponse(resp)
511}
512
513// updateTagsCreateRequest creates the UpdateTags request.
514func (client *ExpressRoutePortsClient) updateTagsCreateRequest(ctx context.Context, resourceGroupName string, expressRoutePortName string, parameters TagsObject, options *ExpressRoutePortsUpdateTagsOptions) (*azcore.Request, error) {
515	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/ExpressRoutePorts/{expressRoutePortName}"
516	if client.subscriptionID == "" {
517		return nil, errors.New("parameter client.subscriptionID cannot be empty")
518	}
519	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
520	if resourceGroupName == "" {
521		return nil, errors.New("parameter resourceGroupName cannot be empty")
522	}
523	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
524	if expressRoutePortName == "" {
525		return nil, errors.New("parameter expressRoutePortName cannot be empty")
526	}
527	urlPath = strings.ReplaceAll(urlPath, "{expressRoutePortName}", url.PathEscape(expressRoutePortName))
528	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
529	if err != nil {
530		return nil, err
531	}
532	req.Telemetry(telemetryInfo)
533	reqQP := req.URL.Query()
534	reqQP.Set("api-version", "2021-02-01")
535	req.URL.RawQuery = reqQP.Encode()
536	req.Header.Set("Accept", "application/json")
537	return req, req.MarshalAsJSON(parameters)
538}
539
540// updateTagsHandleResponse handles the UpdateTags response.
541func (client *ExpressRoutePortsClient) updateTagsHandleResponse(resp *azcore.Response) (ExpressRoutePortResponse, error) {
542	var val *ExpressRoutePort
543	if err := resp.UnmarshalAsJSON(&val); err != nil {
544		return ExpressRoutePortResponse{}, err
545	}
546	return ExpressRoutePortResponse{RawResponse: resp.Response, ExpressRoutePort: val}, nil
547}
548
549// updateTagsHandleError handles the UpdateTags error response.
550func (client *ExpressRoutePortsClient) updateTagsHandleError(resp *azcore.Response) error {
551	body, err := resp.Payload()
552	if err != nil {
553		return azcore.NewResponseError(err, resp.Response)
554	}
555	errType := CloudError{raw: string(body)}
556	if err := resp.UnmarshalAsJSON(&errType); err != nil {
557		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
558	}
559	return azcore.NewResponseError(&errType, resp.Response)
560}
561