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// LoadBalancersClient contains the methods for the LoadBalancers group.
23// Don't use this type directly, use NewLoadBalancersClient() instead.
24type LoadBalancersClient struct {
25	con            *armcore.Connection
26	subscriptionID string
27}
28
29// NewLoadBalancersClient creates a new instance of LoadBalancersClient with the specified values.
30func NewLoadBalancersClient(con *armcore.Connection, subscriptionID string) *LoadBalancersClient {
31	return &LoadBalancersClient{con: con, subscriptionID: subscriptionID}
32}
33
34// BeginCreateOrUpdate - Creates or updates a load balancer.
35// If the operation fails it returns the *CloudError error type.
36func (client *LoadBalancersClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters LoadBalancer, options *LoadBalancersBeginCreateOrUpdateOptions) (LoadBalancerPollerResponse, error) {
37	resp, err := client.createOrUpdate(ctx, resourceGroupName, loadBalancerName, parameters, options)
38	if err != nil {
39		return LoadBalancerPollerResponse{}, err
40	}
41	result := LoadBalancerPollerResponse{
42		RawResponse: resp.Response,
43	}
44	pt, err := armcore.NewLROPoller("LoadBalancersClient.CreateOrUpdate", "azure-async-operation", resp, client.con.Pipeline(), client.createOrUpdateHandleError)
45	if err != nil {
46		return LoadBalancerPollerResponse{}, err
47	}
48	poller := &loadBalancerPoller{
49		pt: pt,
50	}
51	result.Poller = poller
52	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (LoadBalancerResponse, error) {
53		return poller.pollUntilDone(ctx, frequency)
54	}
55	return result, nil
56}
57
58// ResumeCreateOrUpdate creates a new LoadBalancerPoller from the specified resume token.
59// token - The value must come from a previous call to LoadBalancerPoller.ResumeToken().
60func (client *LoadBalancersClient) ResumeCreateOrUpdate(ctx context.Context, token string) (LoadBalancerPollerResponse, error) {
61	pt, err := armcore.NewLROPollerFromResumeToken("LoadBalancersClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError)
62	if err != nil {
63		return LoadBalancerPollerResponse{}, err
64	}
65	poller := &loadBalancerPoller{
66		pt: pt,
67	}
68	resp, err := poller.Poll(ctx)
69	if err != nil {
70		return LoadBalancerPollerResponse{}, err
71	}
72	result := LoadBalancerPollerResponse{
73		RawResponse: resp,
74	}
75	result.Poller = poller
76	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (LoadBalancerResponse, error) {
77		return poller.pollUntilDone(ctx, frequency)
78	}
79	return result, nil
80}
81
82// CreateOrUpdate - Creates or updates a load balancer.
83// If the operation fails it returns the *CloudError error type.
84func (client *LoadBalancersClient) createOrUpdate(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters LoadBalancer, options *LoadBalancersBeginCreateOrUpdateOptions) (*azcore.Response, error) {
85	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, loadBalancerName, 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 *LoadBalancersClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters LoadBalancer, options *LoadBalancersBeginCreateOrUpdateOptions) (*azcore.Request, error) {
101	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}"
102	if resourceGroupName == "" {
103		return nil, errors.New("parameter resourceGroupName cannot be empty")
104	}
105	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
106	if loadBalancerName == "" {
107		return nil, errors.New("parameter loadBalancerName cannot be empty")
108	}
109	urlPath = strings.ReplaceAll(urlPath, "{loadBalancerName}", url.PathEscape(loadBalancerName))
110	if client.subscriptionID == "" {
111		return nil, errors.New("parameter client.subscriptionID cannot be empty")
112	}
113	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
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 *LoadBalancersClient) 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 load balancer.
140// If the operation fails it returns the *CloudError error type.
141func (client *LoadBalancersClient) BeginDelete(ctx context.Context, resourceGroupName string, loadBalancerName string, options *LoadBalancersBeginDeleteOptions) (HTTPPollerResponse, error) {
142	resp, err := client.deleteOperation(ctx, resourceGroupName, loadBalancerName, options)
143	if err != nil {
144		return HTTPPollerResponse{}, err
145	}
146	result := HTTPPollerResponse{
147		RawResponse: resp.Response,
148	}
149	pt, err := armcore.NewLROPoller("LoadBalancersClient.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 *LoadBalancersClient) ResumeDelete(ctx context.Context, token string) (HTTPPollerResponse, error) {
166	pt, err := armcore.NewLROPollerFromResumeToken("LoadBalancersClient.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 load balancer.
188// If the operation fails it returns the *CloudError error type.
189func (client *LoadBalancersClient) deleteOperation(ctx context.Context, resourceGroupName string, loadBalancerName string, options *LoadBalancersBeginDeleteOptions) (*azcore.Response, error) {
190	req, err := client.deleteCreateRequest(ctx, resourceGroupName, loadBalancerName, 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 *LoadBalancersClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, loadBalancerName string, options *LoadBalancersBeginDeleteOptions) (*azcore.Request, error) {
206	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}"
207	if resourceGroupName == "" {
208		return nil, errors.New("parameter resourceGroupName cannot be empty")
209	}
210	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
211	if loadBalancerName == "" {
212		return nil, errors.New("parameter loadBalancerName cannot be empty")
213	}
214	urlPath = strings.ReplaceAll(urlPath, "{loadBalancerName}", url.PathEscape(loadBalancerName))
215	if client.subscriptionID == "" {
216		return nil, errors.New("parameter client.subscriptionID cannot be empty")
217	}
218	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
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 *LoadBalancersClient) 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// Get - Gets the specified load balancer.
245// If the operation fails it returns the *CloudError error type.
246func (client *LoadBalancersClient) Get(ctx context.Context, resourceGroupName string, loadBalancerName string, options *LoadBalancersGetOptions) (LoadBalancerResponse, error) {
247	req, err := client.getCreateRequest(ctx, resourceGroupName, loadBalancerName, options)
248	if err != nil {
249		return LoadBalancerResponse{}, err
250	}
251	resp, err := client.con.Pipeline().Do(req)
252	if err != nil {
253		return LoadBalancerResponse{}, err
254	}
255	if !resp.HasStatusCode(http.StatusOK) {
256		return LoadBalancerResponse{}, client.getHandleError(resp)
257	}
258	return client.getHandleResponse(resp)
259}
260
261// getCreateRequest creates the Get request.
262func (client *LoadBalancersClient) getCreateRequest(ctx context.Context, resourceGroupName string, loadBalancerName string, options *LoadBalancersGetOptions) (*azcore.Request, error) {
263	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}"
264	if resourceGroupName == "" {
265		return nil, errors.New("parameter resourceGroupName cannot be empty")
266	}
267	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
268	if loadBalancerName == "" {
269		return nil, errors.New("parameter loadBalancerName cannot be empty")
270	}
271	urlPath = strings.ReplaceAll(urlPath, "{loadBalancerName}", url.PathEscape(loadBalancerName))
272	if client.subscriptionID == "" {
273		return nil, errors.New("parameter client.subscriptionID cannot be empty")
274	}
275	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
276	req, err := azcore.NewRequest(ctx, http.MethodGet, 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	if options != nil && options.Expand != nil {
284		reqQP.Set("$expand", *options.Expand)
285	}
286	req.URL.RawQuery = reqQP.Encode()
287	req.Header.Set("Accept", "application/json")
288	return req, nil
289}
290
291// getHandleResponse handles the Get response.
292func (client *LoadBalancersClient) getHandleResponse(resp *azcore.Response) (LoadBalancerResponse, error) {
293	var val *LoadBalancer
294	if err := resp.UnmarshalAsJSON(&val); err != nil {
295		return LoadBalancerResponse{}, err
296	}
297	return LoadBalancerResponse{RawResponse: resp.Response, LoadBalancer: val}, nil
298}
299
300// getHandleError handles the Get error response.
301func (client *LoadBalancersClient) getHandleError(resp *azcore.Response) error {
302	body, err := resp.Payload()
303	if err != nil {
304		return azcore.NewResponseError(err, resp.Response)
305	}
306	errType := CloudError{raw: string(body)}
307	if err := resp.UnmarshalAsJSON(&errType); err != nil {
308		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
309	}
310	return azcore.NewResponseError(&errType, resp.Response)
311}
312
313// List - Gets all the load balancers in a resource group.
314// If the operation fails it returns the *CloudError error type.
315func (client *LoadBalancersClient) List(resourceGroupName string, options *LoadBalancersListOptions) LoadBalancerListResultPager {
316	return &loadBalancerListResultPager{
317		pipeline: client.con.Pipeline(),
318		requester: func(ctx context.Context) (*azcore.Request, error) {
319			return client.listCreateRequest(ctx, resourceGroupName, options)
320		},
321		responder: client.listHandleResponse,
322		errorer:   client.listHandleError,
323		advancer: func(ctx context.Context, resp LoadBalancerListResultResponse) (*azcore.Request, error) {
324			return azcore.NewRequest(ctx, http.MethodGet, *resp.LoadBalancerListResult.NextLink)
325		},
326		statusCodes: []int{http.StatusOK},
327	}
328}
329
330// listCreateRequest creates the List request.
331func (client *LoadBalancersClient) listCreateRequest(ctx context.Context, resourceGroupName string, options *LoadBalancersListOptions) (*azcore.Request, error) {
332	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers"
333	if resourceGroupName == "" {
334		return nil, errors.New("parameter resourceGroupName cannot be empty")
335	}
336	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
337	if client.subscriptionID == "" {
338		return nil, errors.New("parameter client.subscriptionID cannot be empty")
339	}
340	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
341	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
342	if err != nil {
343		return nil, err
344	}
345	req.Telemetry(telemetryInfo)
346	reqQP := req.URL.Query()
347	reqQP.Set("api-version", "2021-02-01")
348	req.URL.RawQuery = reqQP.Encode()
349	req.Header.Set("Accept", "application/json")
350	return req, nil
351}
352
353// listHandleResponse handles the List response.
354func (client *LoadBalancersClient) listHandleResponse(resp *azcore.Response) (LoadBalancerListResultResponse, error) {
355	var val *LoadBalancerListResult
356	if err := resp.UnmarshalAsJSON(&val); err != nil {
357		return LoadBalancerListResultResponse{}, err
358	}
359	return LoadBalancerListResultResponse{RawResponse: resp.Response, LoadBalancerListResult: val}, nil
360}
361
362// listHandleError handles the List error response.
363func (client *LoadBalancersClient) listHandleError(resp *azcore.Response) error {
364	body, err := resp.Payload()
365	if err != nil {
366		return azcore.NewResponseError(err, resp.Response)
367	}
368	errType := CloudError{raw: string(body)}
369	if err := resp.UnmarshalAsJSON(&errType); err != nil {
370		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
371	}
372	return azcore.NewResponseError(&errType, resp.Response)
373}
374
375// ListAll - Gets all the load balancers in a subscription.
376// If the operation fails it returns the *CloudError error type.
377func (client *LoadBalancersClient) ListAll(options *LoadBalancersListAllOptions) LoadBalancerListResultPager {
378	return &loadBalancerListResultPager{
379		pipeline: client.con.Pipeline(),
380		requester: func(ctx context.Context) (*azcore.Request, error) {
381			return client.listAllCreateRequest(ctx, options)
382		},
383		responder: client.listAllHandleResponse,
384		errorer:   client.listAllHandleError,
385		advancer: func(ctx context.Context, resp LoadBalancerListResultResponse) (*azcore.Request, error) {
386			return azcore.NewRequest(ctx, http.MethodGet, *resp.LoadBalancerListResult.NextLink)
387		},
388		statusCodes: []int{http.StatusOK},
389	}
390}
391
392// listAllCreateRequest creates the ListAll request.
393func (client *LoadBalancersClient) listAllCreateRequest(ctx context.Context, options *LoadBalancersListAllOptions) (*azcore.Request, error) {
394	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Network/loadBalancers"
395	if client.subscriptionID == "" {
396		return nil, errors.New("parameter client.subscriptionID cannot be empty")
397	}
398	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
399	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
400	if err != nil {
401		return nil, err
402	}
403	req.Telemetry(telemetryInfo)
404	reqQP := req.URL.Query()
405	reqQP.Set("api-version", "2021-02-01")
406	req.URL.RawQuery = reqQP.Encode()
407	req.Header.Set("Accept", "application/json")
408	return req, nil
409}
410
411// listAllHandleResponse handles the ListAll response.
412func (client *LoadBalancersClient) listAllHandleResponse(resp *azcore.Response) (LoadBalancerListResultResponse, error) {
413	var val *LoadBalancerListResult
414	if err := resp.UnmarshalAsJSON(&val); err != nil {
415		return LoadBalancerListResultResponse{}, err
416	}
417	return LoadBalancerListResultResponse{RawResponse: resp.Response, LoadBalancerListResult: val}, nil
418}
419
420// listAllHandleError handles the ListAll error response.
421func (client *LoadBalancersClient) listAllHandleError(resp *azcore.Response) error {
422	body, err := resp.Payload()
423	if err != nil {
424		return azcore.NewResponseError(err, resp.Response)
425	}
426	errType := CloudError{raw: string(body)}
427	if err := resp.UnmarshalAsJSON(&errType); err != nil {
428		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
429	}
430	return azcore.NewResponseError(&errType, resp.Response)
431}
432
433// BeginSwapPublicIPAddresses - Swaps VIPs between two load balancers.
434// If the operation fails it returns the *CloudError error type.
435func (client *LoadBalancersClient) BeginSwapPublicIPAddresses(ctx context.Context, location string, parameters LoadBalancerVipSwapRequest, options *LoadBalancersBeginSwapPublicIPAddressesOptions) (HTTPPollerResponse, error) {
436	resp, err := client.swapPublicIPAddresses(ctx, location, parameters, options)
437	if err != nil {
438		return HTTPPollerResponse{}, err
439	}
440	result := HTTPPollerResponse{
441		RawResponse: resp.Response,
442	}
443	pt, err := armcore.NewLROPoller("LoadBalancersClient.SwapPublicIPAddresses", "location", resp, client.con.Pipeline(), client.swapPublicIPAddressesHandleError)
444	if err != nil {
445		return HTTPPollerResponse{}, err
446	}
447	poller := &httpPoller{
448		pt: pt,
449	}
450	result.Poller = poller
451	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
452		return poller.pollUntilDone(ctx, frequency)
453	}
454	return result, nil
455}
456
457// ResumeSwapPublicIPAddresses creates a new HTTPPoller from the specified resume token.
458// token - The value must come from a previous call to HTTPPoller.ResumeToken().
459func (client *LoadBalancersClient) ResumeSwapPublicIPAddresses(ctx context.Context, token string) (HTTPPollerResponse, error) {
460	pt, err := armcore.NewLROPollerFromResumeToken("LoadBalancersClient.SwapPublicIPAddresses", token, client.con.Pipeline(), client.swapPublicIPAddressesHandleError)
461	if err != nil {
462		return HTTPPollerResponse{}, err
463	}
464	poller := &httpPoller{
465		pt: pt,
466	}
467	resp, err := poller.Poll(ctx)
468	if err != nil {
469		return HTTPPollerResponse{}, err
470	}
471	result := HTTPPollerResponse{
472		RawResponse: resp,
473	}
474	result.Poller = poller
475	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
476		return poller.pollUntilDone(ctx, frequency)
477	}
478	return result, nil
479}
480
481// SwapPublicIPAddresses - Swaps VIPs between two load balancers.
482// If the operation fails it returns the *CloudError error type.
483func (client *LoadBalancersClient) swapPublicIPAddresses(ctx context.Context, location string, parameters LoadBalancerVipSwapRequest, options *LoadBalancersBeginSwapPublicIPAddressesOptions) (*azcore.Response, error) {
484	req, err := client.swapPublicIPAddressesCreateRequest(ctx, location, parameters, options)
485	if err != nil {
486		return nil, err
487	}
488	resp, err := client.con.Pipeline().Do(req)
489	if err != nil {
490		return nil, err
491	}
492	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
493		return nil, client.swapPublicIPAddressesHandleError(resp)
494	}
495	return resp, nil
496}
497
498// swapPublicIPAddressesCreateRequest creates the SwapPublicIPAddresses request.
499func (client *LoadBalancersClient) swapPublicIPAddressesCreateRequest(ctx context.Context, location string, parameters LoadBalancerVipSwapRequest, options *LoadBalancersBeginSwapPublicIPAddressesOptions) (*azcore.Request, error) {
500	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Network/locations/{location}/setLoadBalancerFrontendPublicIpAddresses"
501	if location == "" {
502		return nil, errors.New("parameter location cannot be empty")
503	}
504	urlPath = strings.ReplaceAll(urlPath, "{location}", url.PathEscape(location))
505	if client.subscriptionID == "" {
506		return nil, errors.New("parameter client.subscriptionID cannot be empty")
507	}
508	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
509	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
510	if err != nil {
511		return nil, err
512	}
513	req.Telemetry(telemetryInfo)
514	reqQP := req.URL.Query()
515	reqQP.Set("api-version", "2021-02-01")
516	req.URL.RawQuery = reqQP.Encode()
517	req.Header.Set("Accept", "application/json")
518	return req, req.MarshalAsJSON(parameters)
519}
520
521// swapPublicIPAddressesHandleError handles the SwapPublicIPAddresses error response.
522func (client *LoadBalancersClient) swapPublicIPAddressesHandleError(resp *azcore.Response) error {
523	body, err := resp.Payload()
524	if err != nil {
525		return azcore.NewResponseError(err, resp.Response)
526	}
527	errType := CloudError{raw: string(body)}
528	if err := resp.UnmarshalAsJSON(&errType); err != nil {
529		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
530	}
531	return azcore.NewResponseError(&errType, resp.Response)
532}
533
534// UpdateTags - Updates a load balancer tags.
535// If the operation fails it returns the *CloudError error type.
536func (client *LoadBalancersClient) UpdateTags(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters TagsObject, options *LoadBalancersUpdateTagsOptions) (LoadBalancerResponse, error) {
537	req, err := client.updateTagsCreateRequest(ctx, resourceGroupName, loadBalancerName, parameters, options)
538	if err != nil {
539		return LoadBalancerResponse{}, err
540	}
541	resp, err := client.con.Pipeline().Do(req)
542	if err != nil {
543		return LoadBalancerResponse{}, err
544	}
545	if !resp.HasStatusCode(http.StatusOK) {
546		return LoadBalancerResponse{}, client.updateTagsHandleError(resp)
547	}
548	return client.updateTagsHandleResponse(resp)
549}
550
551// updateTagsCreateRequest creates the UpdateTags request.
552func (client *LoadBalancersClient) updateTagsCreateRequest(ctx context.Context, resourceGroupName string, loadBalancerName string, parameters TagsObject, options *LoadBalancersUpdateTagsOptions) (*azcore.Request, error) {
553	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}"
554	if resourceGroupName == "" {
555		return nil, errors.New("parameter resourceGroupName cannot be empty")
556	}
557	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
558	if loadBalancerName == "" {
559		return nil, errors.New("parameter loadBalancerName cannot be empty")
560	}
561	urlPath = strings.ReplaceAll(urlPath, "{loadBalancerName}", url.PathEscape(loadBalancerName))
562	if client.subscriptionID == "" {
563		return nil, errors.New("parameter client.subscriptionID cannot be empty")
564	}
565	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
566	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
567	if err != nil {
568		return nil, err
569	}
570	req.Telemetry(telemetryInfo)
571	reqQP := req.URL.Query()
572	reqQP.Set("api-version", "2021-02-01")
573	req.URL.RawQuery = reqQP.Encode()
574	req.Header.Set("Accept", "application/json")
575	return req, req.MarshalAsJSON(parameters)
576}
577
578// updateTagsHandleResponse handles the UpdateTags response.
579func (client *LoadBalancersClient) updateTagsHandleResponse(resp *azcore.Response) (LoadBalancerResponse, error) {
580	var val *LoadBalancer
581	if err := resp.UnmarshalAsJSON(&val); err != nil {
582		return LoadBalancerResponse{}, err
583	}
584	return LoadBalancerResponse{RawResponse: resp.Response, LoadBalancer: val}, nil
585}
586
587// updateTagsHandleError handles the UpdateTags error response.
588func (client *LoadBalancersClient) updateTagsHandleError(resp *azcore.Response) error {
589	body, err := resp.Payload()
590	if err != nil {
591		return azcore.NewResponseError(err, resp.Response)
592	}
593	errType := CloudError{raw: string(body)}
594	if err := resp.UnmarshalAsJSON(&errType); err != nil {
595		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
596	}
597	return azcore.NewResponseError(&errType, resp.Response)
598}
599