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