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// VirtualNetworksClient contains the methods for the VirtualNetworks group.
23// Don't use this type directly, use NewVirtualNetworksClient() instead.
24type VirtualNetworksClient struct {
25	con            *armcore.Connection
26	subscriptionID string
27}
28
29// NewVirtualNetworksClient creates a new instance of VirtualNetworksClient with the specified values.
30func NewVirtualNetworksClient(con *armcore.Connection, subscriptionID string) *VirtualNetworksClient {
31	return &VirtualNetworksClient{con: con, subscriptionID: subscriptionID}
32}
33
34// CheckIPAddressAvailability - Checks whether a private IP address is available for use.
35// If the operation fails it returns the *CloudError error type.
36func (client *VirtualNetworksClient) CheckIPAddressAvailability(ctx context.Context, resourceGroupName string, virtualNetworkName string, ipAddress string, options *VirtualNetworksCheckIPAddressAvailabilityOptions) (IPAddressAvailabilityResultResponse, error) {
37	req, err := client.checkIPAddressAvailabilityCreateRequest(ctx, resourceGroupName, virtualNetworkName, ipAddress, options)
38	if err != nil {
39		return IPAddressAvailabilityResultResponse{}, err
40	}
41	resp, err := client.con.Pipeline().Do(req)
42	if err != nil {
43		return IPAddressAvailabilityResultResponse{}, err
44	}
45	if !resp.HasStatusCode(http.StatusOK) {
46		return IPAddressAvailabilityResultResponse{}, client.checkIPAddressAvailabilityHandleError(resp)
47	}
48	return client.checkIPAddressAvailabilityHandleResponse(resp)
49}
50
51// checkIPAddressAvailabilityCreateRequest creates the CheckIPAddressAvailability request.
52func (client *VirtualNetworksClient) checkIPAddressAvailabilityCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, ipAddress string, options *VirtualNetworksCheckIPAddressAvailabilityOptions) (*azcore.Request, error) {
53	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/CheckIPAddressAvailability"
54	if resourceGroupName == "" {
55		return nil, errors.New("parameter resourceGroupName cannot be empty")
56	}
57	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
58	if virtualNetworkName == "" {
59		return nil, errors.New("parameter virtualNetworkName cannot be empty")
60	}
61	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
62	if client.subscriptionID == "" {
63		return nil, errors.New("parameter client.subscriptionID cannot be empty")
64	}
65	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
66	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
67	if err != nil {
68		return nil, err
69	}
70	req.Telemetry(telemetryInfo)
71	reqQP := req.URL.Query()
72	reqQP.Set("ipAddress", ipAddress)
73	reqQP.Set("api-version", "2021-02-01")
74	req.URL.RawQuery = reqQP.Encode()
75	req.Header.Set("Accept", "application/json")
76	return req, nil
77}
78
79// checkIPAddressAvailabilityHandleResponse handles the CheckIPAddressAvailability response.
80func (client *VirtualNetworksClient) checkIPAddressAvailabilityHandleResponse(resp *azcore.Response) (IPAddressAvailabilityResultResponse, error) {
81	var val *IPAddressAvailabilityResult
82	if err := resp.UnmarshalAsJSON(&val); err != nil {
83		return IPAddressAvailabilityResultResponse{}, err
84	}
85	return IPAddressAvailabilityResultResponse{RawResponse: resp.Response, IPAddressAvailabilityResult: val}, nil
86}
87
88// checkIPAddressAvailabilityHandleError handles the CheckIPAddressAvailability error response.
89func (client *VirtualNetworksClient) checkIPAddressAvailabilityHandleError(resp *azcore.Response) error {
90	body, err := resp.Payload()
91	if err != nil {
92		return azcore.NewResponseError(err, resp.Response)
93	}
94	errType := CloudError{raw: string(body)}
95	if err := resp.UnmarshalAsJSON(&errType); err != nil {
96		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
97	}
98	return azcore.NewResponseError(&errType, resp.Response)
99}
100
101// BeginCreateOrUpdate - Creates or updates a virtual network in the specified resource group.
102// If the operation fails it returns the *CloudError error type.
103func (client *VirtualNetworksClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters VirtualNetwork, options *VirtualNetworksBeginCreateOrUpdateOptions) (VirtualNetworkPollerResponse, error) {
104	resp, err := client.createOrUpdate(ctx, resourceGroupName, virtualNetworkName, parameters, options)
105	if err != nil {
106		return VirtualNetworkPollerResponse{}, err
107	}
108	result := VirtualNetworkPollerResponse{
109		RawResponse: resp.Response,
110	}
111	pt, err := armcore.NewLROPoller("VirtualNetworksClient.CreateOrUpdate", "azure-async-operation", resp, client.con.Pipeline(), client.createOrUpdateHandleError)
112	if err != nil {
113		return VirtualNetworkPollerResponse{}, err
114	}
115	poller := &virtualNetworkPoller{
116		pt: pt,
117	}
118	result.Poller = poller
119	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VirtualNetworkResponse, error) {
120		return poller.pollUntilDone(ctx, frequency)
121	}
122	return result, nil
123}
124
125// ResumeCreateOrUpdate creates a new VirtualNetworkPoller from the specified resume token.
126// token - The value must come from a previous call to VirtualNetworkPoller.ResumeToken().
127func (client *VirtualNetworksClient) ResumeCreateOrUpdate(ctx context.Context, token string) (VirtualNetworkPollerResponse, error) {
128	pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworksClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError)
129	if err != nil {
130		return VirtualNetworkPollerResponse{}, err
131	}
132	poller := &virtualNetworkPoller{
133		pt: pt,
134	}
135	resp, err := poller.Poll(ctx)
136	if err != nil {
137		return VirtualNetworkPollerResponse{}, err
138	}
139	result := VirtualNetworkPollerResponse{
140		RawResponse: resp,
141	}
142	result.Poller = poller
143	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (VirtualNetworkResponse, error) {
144		return poller.pollUntilDone(ctx, frequency)
145	}
146	return result, nil
147}
148
149// CreateOrUpdate - Creates or updates a virtual network in the specified resource group.
150// If the operation fails it returns the *CloudError error type.
151func (client *VirtualNetworksClient) createOrUpdate(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters VirtualNetwork, options *VirtualNetworksBeginCreateOrUpdateOptions) (*azcore.Response, error) {
152	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, virtualNetworkName, parameters, options)
153	if err != nil {
154		return nil, err
155	}
156	resp, err := client.con.Pipeline().Do(req)
157	if err != nil {
158		return nil, err
159	}
160	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
161		return nil, client.createOrUpdateHandleError(resp)
162	}
163	return resp, nil
164}
165
166// createOrUpdateCreateRequest creates the CreateOrUpdate request.
167func (client *VirtualNetworksClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters VirtualNetwork, options *VirtualNetworksBeginCreateOrUpdateOptions) (*azcore.Request, error) {
168	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}"
169	if resourceGroupName == "" {
170		return nil, errors.New("parameter resourceGroupName cannot be empty")
171	}
172	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
173	if virtualNetworkName == "" {
174		return nil, errors.New("parameter virtualNetworkName cannot be empty")
175	}
176	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
177	if client.subscriptionID == "" {
178		return nil, errors.New("parameter client.subscriptionID cannot be empty")
179	}
180	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
181	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
182	if err != nil {
183		return nil, err
184	}
185	req.Telemetry(telemetryInfo)
186	reqQP := req.URL.Query()
187	reqQP.Set("api-version", "2021-02-01")
188	req.URL.RawQuery = reqQP.Encode()
189	req.Header.Set("Accept", "application/json")
190	return req, req.MarshalAsJSON(parameters)
191}
192
193// createOrUpdateHandleError handles the CreateOrUpdate error response.
194func (client *VirtualNetworksClient) createOrUpdateHandleError(resp *azcore.Response) error {
195	body, err := resp.Payload()
196	if err != nil {
197		return azcore.NewResponseError(err, resp.Response)
198	}
199	errType := CloudError{raw: string(body)}
200	if err := resp.UnmarshalAsJSON(&errType); err != nil {
201		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
202	}
203	return azcore.NewResponseError(&errType, resp.Response)
204}
205
206// BeginDelete - Deletes the specified virtual network.
207// If the operation fails it returns the *CloudError error type.
208func (client *VirtualNetworksClient) BeginDelete(ctx context.Context, resourceGroupName string, virtualNetworkName string, options *VirtualNetworksBeginDeleteOptions) (HTTPPollerResponse, error) {
209	resp, err := client.deleteOperation(ctx, resourceGroupName, virtualNetworkName, options)
210	if err != nil {
211		return HTTPPollerResponse{}, err
212	}
213	result := HTTPPollerResponse{
214		RawResponse: resp.Response,
215	}
216	pt, err := armcore.NewLROPoller("VirtualNetworksClient.Delete", "location", resp, client.con.Pipeline(), client.deleteHandleError)
217	if err != nil {
218		return HTTPPollerResponse{}, err
219	}
220	poller := &httpPoller{
221		pt: pt,
222	}
223	result.Poller = poller
224	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
225		return poller.pollUntilDone(ctx, frequency)
226	}
227	return result, nil
228}
229
230// ResumeDelete creates a new HTTPPoller from the specified resume token.
231// token - The value must come from a previous call to HTTPPoller.ResumeToken().
232func (client *VirtualNetworksClient) ResumeDelete(ctx context.Context, token string) (HTTPPollerResponse, error) {
233	pt, err := armcore.NewLROPollerFromResumeToken("VirtualNetworksClient.Delete", token, client.con.Pipeline(), client.deleteHandleError)
234	if err != nil {
235		return HTTPPollerResponse{}, err
236	}
237	poller := &httpPoller{
238		pt: pt,
239	}
240	resp, err := poller.Poll(ctx)
241	if err != nil {
242		return HTTPPollerResponse{}, err
243	}
244	result := HTTPPollerResponse{
245		RawResponse: resp,
246	}
247	result.Poller = poller
248	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
249		return poller.pollUntilDone(ctx, frequency)
250	}
251	return result, nil
252}
253
254// Delete - Deletes the specified virtual network.
255// If the operation fails it returns the *CloudError error type.
256func (client *VirtualNetworksClient) deleteOperation(ctx context.Context, resourceGroupName string, virtualNetworkName string, options *VirtualNetworksBeginDeleteOptions) (*azcore.Response, error) {
257	req, err := client.deleteCreateRequest(ctx, resourceGroupName, virtualNetworkName, options)
258	if err != nil {
259		return nil, err
260	}
261	resp, err := client.con.Pipeline().Do(req)
262	if err != nil {
263		return nil, err
264	}
265	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent) {
266		return nil, client.deleteHandleError(resp)
267	}
268	return resp, nil
269}
270
271// deleteCreateRequest creates the Delete request.
272func (client *VirtualNetworksClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, options *VirtualNetworksBeginDeleteOptions) (*azcore.Request, error) {
273	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}"
274	if resourceGroupName == "" {
275		return nil, errors.New("parameter resourceGroupName cannot be empty")
276	}
277	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
278	if virtualNetworkName == "" {
279		return nil, errors.New("parameter virtualNetworkName cannot be empty")
280	}
281	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
282	if client.subscriptionID == "" {
283		return nil, errors.New("parameter client.subscriptionID cannot be empty")
284	}
285	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
286	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
287	if err != nil {
288		return nil, err
289	}
290	req.Telemetry(telemetryInfo)
291	reqQP := req.URL.Query()
292	reqQP.Set("api-version", "2021-02-01")
293	req.URL.RawQuery = reqQP.Encode()
294	req.Header.Set("Accept", "application/json")
295	return req, nil
296}
297
298// deleteHandleError handles the Delete error response.
299func (client *VirtualNetworksClient) deleteHandleError(resp *azcore.Response) error {
300	body, err := resp.Payload()
301	if err != nil {
302		return azcore.NewResponseError(err, resp.Response)
303	}
304	errType := CloudError{raw: string(body)}
305	if err := resp.UnmarshalAsJSON(&errType); err != nil {
306		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
307	}
308	return azcore.NewResponseError(&errType, resp.Response)
309}
310
311// Get - Gets the specified virtual network by resource group.
312// If the operation fails it returns the *CloudError error type.
313func (client *VirtualNetworksClient) Get(ctx context.Context, resourceGroupName string, virtualNetworkName string, options *VirtualNetworksGetOptions) (VirtualNetworkResponse, error) {
314	req, err := client.getCreateRequest(ctx, resourceGroupName, virtualNetworkName, options)
315	if err != nil {
316		return VirtualNetworkResponse{}, err
317	}
318	resp, err := client.con.Pipeline().Do(req)
319	if err != nil {
320		return VirtualNetworkResponse{}, err
321	}
322	if !resp.HasStatusCode(http.StatusOK) {
323		return VirtualNetworkResponse{}, client.getHandleError(resp)
324	}
325	return client.getHandleResponse(resp)
326}
327
328// getCreateRequest creates the Get request.
329func (client *VirtualNetworksClient) getCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, options *VirtualNetworksGetOptions) (*azcore.Request, error) {
330	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}"
331	if resourceGroupName == "" {
332		return nil, errors.New("parameter resourceGroupName cannot be empty")
333	}
334	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
335	if virtualNetworkName == "" {
336		return nil, errors.New("parameter virtualNetworkName cannot be empty")
337	}
338	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
339	if client.subscriptionID == "" {
340		return nil, errors.New("parameter client.subscriptionID cannot be empty")
341	}
342	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
343	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
344	if err != nil {
345		return nil, err
346	}
347	req.Telemetry(telemetryInfo)
348	reqQP := req.URL.Query()
349	reqQP.Set("api-version", "2021-02-01")
350	if options != nil && options.Expand != nil {
351		reqQP.Set("$expand", *options.Expand)
352	}
353	req.URL.RawQuery = reqQP.Encode()
354	req.Header.Set("Accept", "application/json")
355	return req, nil
356}
357
358// getHandleResponse handles the Get response.
359func (client *VirtualNetworksClient) getHandleResponse(resp *azcore.Response) (VirtualNetworkResponse, error) {
360	var val *VirtualNetwork
361	if err := resp.UnmarshalAsJSON(&val); err != nil {
362		return VirtualNetworkResponse{}, err
363	}
364	return VirtualNetworkResponse{RawResponse: resp.Response, VirtualNetwork: val}, nil
365}
366
367// getHandleError handles the Get error response.
368func (client *VirtualNetworksClient) getHandleError(resp *azcore.Response) error {
369	body, err := resp.Payload()
370	if err != nil {
371		return azcore.NewResponseError(err, resp.Response)
372	}
373	errType := CloudError{raw: string(body)}
374	if err := resp.UnmarshalAsJSON(&errType); err != nil {
375		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
376	}
377	return azcore.NewResponseError(&errType, resp.Response)
378}
379
380// List - Gets all virtual networks in a resource group.
381// If the operation fails it returns the *CloudError error type.
382func (client *VirtualNetworksClient) List(resourceGroupName string, options *VirtualNetworksListOptions) VirtualNetworkListResultPager {
383	return &virtualNetworkListResultPager{
384		pipeline: client.con.Pipeline(),
385		requester: func(ctx context.Context) (*azcore.Request, error) {
386			return client.listCreateRequest(ctx, resourceGroupName, options)
387		},
388		responder: client.listHandleResponse,
389		errorer:   client.listHandleError,
390		advancer: func(ctx context.Context, resp VirtualNetworkListResultResponse) (*azcore.Request, error) {
391			return azcore.NewRequest(ctx, http.MethodGet, *resp.VirtualNetworkListResult.NextLink)
392		},
393		statusCodes: []int{http.StatusOK},
394	}
395}
396
397// listCreateRequest creates the List request.
398func (client *VirtualNetworksClient) listCreateRequest(ctx context.Context, resourceGroupName string, options *VirtualNetworksListOptions) (*azcore.Request, error) {
399	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks"
400	if resourceGroupName == "" {
401		return nil, errors.New("parameter resourceGroupName cannot be empty")
402	}
403	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
404	if client.subscriptionID == "" {
405		return nil, errors.New("parameter client.subscriptionID cannot be empty")
406	}
407	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
408	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
409	if err != nil {
410		return nil, err
411	}
412	req.Telemetry(telemetryInfo)
413	reqQP := req.URL.Query()
414	reqQP.Set("api-version", "2021-02-01")
415	req.URL.RawQuery = reqQP.Encode()
416	req.Header.Set("Accept", "application/json")
417	return req, nil
418}
419
420// listHandleResponse handles the List response.
421func (client *VirtualNetworksClient) listHandleResponse(resp *azcore.Response) (VirtualNetworkListResultResponse, error) {
422	var val *VirtualNetworkListResult
423	if err := resp.UnmarshalAsJSON(&val); err != nil {
424		return VirtualNetworkListResultResponse{}, err
425	}
426	return VirtualNetworkListResultResponse{RawResponse: resp.Response, VirtualNetworkListResult: val}, nil
427}
428
429// listHandleError handles the List error response.
430func (client *VirtualNetworksClient) listHandleError(resp *azcore.Response) error {
431	body, err := resp.Payload()
432	if err != nil {
433		return azcore.NewResponseError(err, resp.Response)
434	}
435	errType := CloudError{raw: string(body)}
436	if err := resp.UnmarshalAsJSON(&errType); err != nil {
437		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
438	}
439	return azcore.NewResponseError(&errType, resp.Response)
440}
441
442// ListAll - Gets all virtual networks in a subscription.
443// If the operation fails it returns the *CloudError error type.
444func (client *VirtualNetworksClient) ListAll(options *VirtualNetworksListAllOptions) VirtualNetworkListResultPager {
445	return &virtualNetworkListResultPager{
446		pipeline: client.con.Pipeline(),
447		requester: func(ctx context.Context) (*azcore.Request, error) {
448			return client.listAllCreateRequest(ctx, options)
449		},
450		responder: client.listAllHandleResponse,
451		errorer:   client.listAllHandleError,
452		advancer: func(ctx context.Context, resp VirtualNetworkListResultResponse) (*azcore.Request, error) {
453			return azcore.NewRequest(ctx, http.MethodGet, *resp.VirtualNetworkListResult.NextLink)
454		},
455		statusCodes: []int{http.StatusOK},
456	}
457}
458
459// listAllCreateRequest creates the ListAll request.
460func (client *VirtualNetworksClient) listAllCreateRequest(ctx context.Context, options *VirtualNetworksListAllOptions) (*azcore.Request, error) {
461	urlPath := "/subscriptions/{subscriptionId}/providers/Microsoft.Network/virtualNetworks"
462	if client.subscriptionID == "" {
463		return nil, errors.New("parameter client.subscriptionID cannot be empty")
464	}
465	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
466	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
467	if err != nil {
468		return nil, err
469	}
470	req.Telemetry(telemetryInfo)
471	reqQP := req.URL.Query()
472	reqQP.Set("api-version", "2021-02-01")
473	req.URL.RawQuery = reqQP.Encode()
474	req.Header.Set("Accept", "application/json")
475	return req, nil
476}
477
478// listAllHandleResponse handles the ListAll response.
479func (client *VirtualNetworksClient) listAllHandleResponse(resp *azcore.Response) (VirtualNetworkListResultResponse, error) {
480	var val *VirtualNetworkListResult
481	if err := resp.UnmarshalAsJSON(&val); err != nil {
482		return VirtualNetworkListResultResponse{}, err
483	}
484	return VirtualNetworkListResultResponse{RawResponse: resp.Response, VirtualNetworkListResult: val}, nil
485}
486
487// listAllHandleError handles the ListAll error response.
488func (client *VirtualNetworksClient) listAllHandleError(resp *azcore.Response) error {
489	body, err := resp.Payload()
490	if err != nil {
491		return azcore.NewResponseError(err, resp.Response)
492	}
493	errType := CloudError{raw: string(body)}
494	if err := resp.UnmarshalAsJSON(&errType); err != nil {
495		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
496	}
497	return azcore.NewResponseError(&errType, resp.Response)
498}
499
500// ListUsage - Lists usage stats.
501// If the operation fails it returns the *CloudError error type.
502func (client *VirtualNetworksClient) ListUsage(resourceGroupName string, virtualNetworkName string, options *VirtualNetworksListUsageOptions) VirtualNetworkListUsageResultPager {
503	return &virtualNetworkListUsageResultPager{
504		pipeline: client.con.Pipeline(),
505		requester: func(ctx context.Context) (*azcore.Request, error) {
506			return client.listUsageCreateRequest(ctx, resourceGroupName, virtualNetworkName, options)
507		},
508		responder: client.listUsageHandleResponse,
509		errorer:   client.listUsageHandleError,
510		advancer: func(ctx context.Context, resp VirtualNetworkListUsageResultResponse) (*azcore.Request, error) {
511			return azcore.NewRequest(ctx, http.MethodGet, *resp.VirtualNetworkListUsageResult.NextLink)
512		},
513		statusCodes: []int{http.StatusOK},
514	}
515}
516
517// listUsageCreateRequest creates the ListUsage request.
518func (client *VirtualNetworksClient) listUsageCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, options *VirtualNetworksListUsageOptions) (*azcore.Request, error) {
519	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/usages"
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 virtualNetworkName == "" {
525		return nil, errors.New("parameter virtualNetworkName cannot be empty")
526	}
527	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
528	if client.subscriptionID == "" {
529		return nil, errors.New("parameter client.subscriptionID cannot be empty")
530	}
531	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
532	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
533	if err != nil {
534		return nil, err
535	}
536	req.Telemetry(telemetryInfo)
537	reqQP := req.URL.Query()
538	reqQP.Set("api-version", "2021-02-01")
539	req.URL.RawQuery = reqQP.Encode()
540	req.Header.Set("Accept", "application/json")
541	return req, nil
542}
543
544// listUsageHandleResponse handles the ListUsage response.
545func (client *VirtualNetworksClient) listUsageHandleResponse(resp *azcore.Response) (VirtualNetworkListUsageResultResponse, error) {
546	var val *VirtualNetworkListUsageResult
547	if err := resp.UnmarshalAsJSON(&val); err != nil {
548		return VirtualNetworkListUsageResultResponse{}, err
549	}
550	return VirtualNetworkListUsageResultResponse{RawResponse: resp.Response, VirtualNetworkListUsageResult: val}, nil
551}
552
553// listUsageHandleError handles the ListUsage error response.
554func (client *VirtualNetworksClient) listUsageHandleError(resp *azcore.Response) error {
555	body, err := resp.Payload()
556	if err != nil {
557		return azcore.NewResponseError(err, resp.Response)
558	}
559	errType := CloudError{raw: string(body)}
560	if err := resp.UnmarshalAsJSON(&errType); err != nil {
561		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
562	}
563	return azcore.NewResponseError(&errType, resp.Response)
564}
565
566// UpdateTags - Updates a virtual network tags.
567// If the operation fails it returns the *CloudError error type.
568func (client *VirtualNetworksClient) UpdateTags(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters TagsObject, options *VirtualNetworksUpdateTagsOptions) (VirtualNetworkResponse, error) {
569	req, err := client.updateTagsCreateRequest(ctx, resourceGroupName, virtualNetworkName, parameters, options)
570	if err != nil {
571		return VirtualNetworkResponse{}, err
572	}
573	resp, err := client.con.Pipeline().Do(req)
574	if err != nil {
575		return VirtualNetworkResponse{}, err
576	}
577	if !resp.HasStatusCode(http.StatusOK) {
578		return VirtualNetworkResponse{}, client.updateTagsHandleError(resp)
579	}
580	return client.updateTagsHandleResponse(resp)
581}
582
583// updateTagsCreateRequest creates the UpdateTags request.
584func (client *VirtualNetworksClient) updateTagsCreateRequest(ctx context.Context, resourceGroupName string, virtualNetworkName string, parameters TagsObject, options *VirtualNetworksUpdateTagsOptions) (*azcore.Request, error) {
585	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}"
586	if resourceGroupName == "" {
587		return nil, errors.New("parameter resourceGroupName cannot be empty")
588	}
589	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
590	if virtualNetworkName == "" {
591		return nil, errors.New("parameter virtualNetworkName cannot be empty")
592	}
593	urlPath = strings.ReplaceAll(urlPath, "{virtualNetworkName}", url.PathEscape(virtualNetworkName))
594	if client.subscriptionID == "" {
595		return nil, errors.New("parameter client.subscriptionID cannot be empty")
596	}
597	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
598	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
599	if err != nil {
600		return nil, err
601	}
602	req.Telemetry(telemetryInfo)
603	reqQP := req.URL.Query()
604	reqQP.Set("api-version", "2021-02-01")
605	req.URL.RawQuery = reqQP.Encode()
606	req.Header.Set("Accept", "application/json")
607	return req, req.MarshalAsJSON(parameters)
608}
609
610// updateTagsHandleResponse handles the UpdateTags response.
611func (client *VirtualNetworksClient) updateTagsHandleResponse(resp *azcore.Response) (VirtualNetworkResponse, error) {
612	var val *VirtualNetwork
613	if err := resp.UnmarshalAsJSON(&val); err != nil {
614		return VirtualNetworkResponse{}, err
615	}
616	return VirtualNetworkResponse{RawResponse: resp.Response, VirtualNetwork: val}, nil
617}
618
619// updateTagsHandleError handles the UpdateTags error response.
620func (client *VirtualNetworksClient) updateTagsHandleError(resp *azcore.Response) error {
621	body, err := resp.Payload()
622	if err != nil {
623		return azcore.NewResponseError(err, resp.Response)
624	}
625	errType := CloudError{raw: string(body)}
626	if err := resp.UnmarshalAsJSON(&errType); err != nil {
627		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
628	}
629	return azcore.NewResponseError(&errType, resp.Response)
630}
631