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 armapimanagement
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	"strconv"
19	"strings"
20	"time"
21)
22
23// NamedValueClient contains the methods for the NamedValue group.
24// Don't use this type directly, use NewNamedValueClient() instead.
25type NamedValueClient struct {
26	con            *armcore.Connection
27	subscriptionID string
28}
29
30// NewNamedValueClient creates a new instance of NamedValueClient with the specified values.
31func NewNamedValueClient(con *armcore.Connection, subscriptionID string) *NamedValueClient {
32	return &NamedValueClient{con: con, subscriptionID: subscriptionID}
33}
34
35// BeginCreateOrUpdate - Creates or updates named value.
36// If the operation fails it returns the *ErrorResponse error type.
37func (client *NamedValueClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, parameters NamedValueCreateContract, options *NamedValueBeginCreateOrUpdateOptions) (NamedValueCreateOrUpdatePollerResponse, error) {
38	resp, err := client.createOrUpdate(ctx, resourceGroupName, serviceName, namedValueID, parameters, options)
39	if err != nil {
40		return NamedValueCreateOrUpdatePollerResponse{}, err
41	}
42	result := NamedValueCreateOrUpdatePollerResponse{
43		RawResponse: resp.Response,
44	}
45	pt, err := armcore.NewLROPoller("NamedValueClient.CreateOrUpdate", "location", resp, client.con.Pipeline(), client.createOrUpdateHandleError)
46	if err != nil {
47		return NamedValueCreateOrUpdatePollerResponse{}, err
48	}
49	poller := &namedValueCreateOrUpdatePoller{
50		pt: pt,
51	}
52	result.Poller = poller
53	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (NamedValueCreateOrUpdateResponse, error) {
54		return poller.pollUntilDone(ctx, frequency)
55	}
56	return result, nil
57}
58
59// ResumeCreateOrUpdate creates a new NamedValueCreateOrUpdatePoller from the specified resume token.
60// token - The value must come from a previous call to NamedValueCreateOrUpdatePoller.ResumeToken().
61func (client *NamedValueClient) ResumeCreateOrUpdate(ctx context.Context, token string) (NamedValueCreateOrUpdatePollerResponse, error) {
62	pt, err := armcore.NewLROPollerFromResumeToken("NamedValueClient.CreateOrUpdate", token, client.con.Pipeline(), client.createOrUpdateHandleError)
63	if err != nil {
64		return NamedValueCreateOrUpdatePollerResponse{}, err
65	}
66	poller := &namedValueCreateOrUpdatePoller{
67		pt: pt,
68	}
69	resp, err := poller.Poll(ctx)
70	if err != nil {
71		return NamedValueCreateOrUpdatePollerResponse{}, err
72	}
73	result := NamedValueCreateOrUpdatePollerResponse{
74		RawResponse: resp,
75	}
76	result.Poller = poller
77	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (NamedValueCreateOrUpdateResponse, error) {
78		return poller.pollUntilDone(ctx, frequency)
79	}
80	return result, nil
81}
82
83// CreateOrUpdate - Creates or updates named value.
84// If the operation fails it returns the *ErrorResponse error type.
85func (client *NamedValueClient) createOrUpdate(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, parameters NamedValueCreateContract, options *NamedValueBeginCreateOrUpdateOptions) (*azcore.Response, error) {
86	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, serviceName, namedValueID, parameters, options)
87	if err != nil {
88		return nil, err
89	}
90	resp, err := client.con.Pipeline().Do(req)
91	if err != nil {
92		return nil, err
93	}
94	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated, http.StatusAccepted) {
95		return nil, client.createOrUpdateHandleError(resp)
96	}
97	return resp, nil
98}
99
100// createOrUpdateCreateRequest creates the CreateOrUpdate request.
101func (client *NamedValueClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, parameters NamedValueCreateContract, options *NamedValueBeginCreateOrUpdateOptions) (*azcore.Request, error) {
102	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/namedValues/{namedValueId}"
103	if resourceGroupName == "" {
104		return nil, errors.New("parameter resourceGroupName cannot be empty")
105	}
106	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
107	if serviceName == "" {
108		return nil, errors.New("parameter serviceName cannot be empty")
109	}
110	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
111	if namedValueID == "" {
112		return nil, errors.New("parameter namedValueID cannot be empty")
113	}
114	urlPath = strings.ReplaceAll(urlPath, "{namedValueId}", url.PathEscape(namedValueID))
115	if client.subscriptionID == "" {
116		return nil, errors.New("parameter client.subscriptionID cannot be empty")
117	}
118	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
119	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
120	if err != nil {
121		return nil, err
122	}
123	req.Telemetry(telemetryInfo)
124	reqQP := req.URL.Query()
125	reqQP.Set("api-version", "2020-12-01")
126	req.URL.RawQuery = reqQP.Encode()
127	if options != nil && options.IfMatch != nil {
128		req.Header.Set("If-Match", *options.IfMatch)
129	}
130	req.Header.Set("Accept", "application/json")
131	return req, req.MarshalAsJSON(parameters)
132}
133
134// createOrUpdateHandleError handles the CreateOrUpdate error response.
135func (client *NamedValueClient) createOrUpdateHandleError(resp *azcore.Response) error {
136	body, err := resp.Payload()
137	if err != nil {
138		return azcore.NewResponseError(err, resp.Response)
139	}
140	errType := ErrorResponse{raw: string(body)}
141	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
142		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
143	}
144	return azcore.NewResponseError(&errType, resp.Response)
145}
146
147// Delete - Deletes specific named value from the API Management service instance.
148// If the operation fails it returns the *ErrorResponse error type.
149func (client *NamedValueClient) Delete(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, ifMatch string, options *NamedValueDeleteOptions) (NamedValueDeleteResponse, error) {
150	req, err := client.deleteCreateRequest(ctx, resourceGroupName, serviceName, namedValueID, ifMatch, options)
151	if err != nil {
152		return NamedValueDeleteResponse{}, err
153	}
154	resp, err := client.con.Pipeline().Do(req)
155	if err != nil {
156		return NamedValueDeleteResponse{}, err
157	}
158	if !resp.HasStatusCode(http.StatusOK, http.StatusNoContent) {
159		return NamedValueDeleteResponse{}, client.deleteHandleError(resp)
160	}
161	return NamedValueDeleteResponse{RawResponse: resp.Response}, nil
162}
163
164// deleteCreateRequest creates the Delete request.
165func (client *NamedValueClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, ifMatch string, options *NamedValueDeleteOptions) (*azcore.Request, error) {
166	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/namedValues/{namedValueId}"
167	if resourceGroupName == "" {
168		return nil, errors.New("parameter resourceGroupName cannot be empty")
169	}
170	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
171	if serviceName == "" {
172		return nil, errors.New("parameter serviceName cannot be empty")
173	}
174	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
175	if namedValueID == "" {
176		return nil, errors.New("parameter namedValueID cannot be empty")
177	}
178	urlPath = strings.ReplaceAll(urlPath, "{namedValueId}", url.PathEscape(namedValueID))
179	if client.subscriptionID == "" {
180		return nil, errors.New("parameter client.subscriptionID cannot be empty")
181	}
182	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
183	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
184	if err != nil {
185		return nil, err
186	}
187	req.Telemetry(telemetryInfo)
188	reqQP := req.URL.Query()
189	reqQP.Set("api-version", "2020-12-01")
190	req.URL.RawQuery = reqQP.Encode()
191	req.Header.Set("If-Match", ifMatch)
192	req.Header.Set("Accept", "application/json")
193	return req, nil
194}
195
196// deleteHandleError handles the Delete error response.
197func (client *NamedValueClient) deleteHandleError(resp *azcore.Response) error {
198	body, err := resp.Payload()
199	if err != nil {
200		return azcore.NewResponseError(err, resp.Response)
201	}
202	errType := ErrorResponse{raw: string(body)}
203	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
204		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
205	}
206	return azcore.NewResponseError(&errType, resp.Response)
207}
208
209// Get - Gets the details of the named value specified by its identifier.
210// If the operation fails it returns the *ErrorResponse error type.
211func (client *NamedValueClient) Get(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, options *NamedValueGetOptions) (NamedValueGetResponse, error) {
212	req, err := client.getCreateRequest(ctx, resourceGroupName, serviceName, namedValueID, options)
213	if err != nil {
214		return NamedValueGetResponse{}, err
215	}
216	resp, err := client.con.Pipeline().Do(req)
217	if err != nil {
218		return NamedValueGetResponse{}, err
219	}
220	if !resp.HasStatusCode(http.StatusOK) {
221		return NamedValueGetResponse{}, client.getHandleError(resp)
222	}
223	return client.getHandleResponse(resp)
224}
225
226// getCreateRequest creates the Get request.
227func (client *NamedValueClient) getCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, options *NamedValueGetOptions) (*azcore.Request, error) {
228	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/namedValues/{namedValueId}"
229	if resourceGroupName == "" {
230		return nil, errors.New("parameter resourceGroupName cannot be empty")
231	}
232	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
233	if serviceName == "" {
234		return nil, errors.New("parameter serviceName cannot be empty")
235	}
236	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
237	if namedValueID == "" {
238		return nil, errors.New("parameter namedValueID cannot be empty")
239	}
240	urlPath = strings.ReplaceAll(urlPath, "{namedValueId}", url.PathEscape(namedValueID))
241	if client.subscriptionID == "" {
242		return nil, errors.New("parameter client.subscriptionID cannot be empty")
243	}
244	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
245	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
246	if err != nil {
247		return nil, err
248	}
249	req.Telemetry(telemetryInfo)
250	reqQP := req.URL.Query()
251	reqQP.Set("api-version", "2020-12-01")
252	req.URL.RawQuery = reqQP.Encode()
253	req.Header.Set("Accept", "application/json")
254	return req, nil
255}
256
257// getHandleResponse handles the Get response.
258func (client *NamedValueClient) getHandleResponse(resp *azcore.Response) (NamedValueGetResponse, error) {
259	result := NamedValueGetResponse{RawResponse: resp.Response}
260	if val := resp.Header.Get("ETag"); val != "" {
261		result.ETag = &val
262	}
263	if err := resp.UnmarshalAsJSON(&result.NamedValueContract); err != nil {
264		return NamedValueGetResponse{}, err
265	}
266	return result, nil
267}
268
269// getHandleError handles the Get error response.
270func (client *NamedValueClient) getHandleError(resp *azcore.Response) error {
271	body, err := resp.Payload()
272	if err != nil {
273		return azcore.NewResponseError(err, resp.Response)
274	}
275	errType := ErrorResponse{raw: string(body)}
276	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
277		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
278	}
279	return azcore.NewResponseError(&errType, resp.Response)
280}
281
282// GetEntityTag - Gets the entity state (Etag) version of the named value specified by its identifier.
283// If the operation fails it returns the *ErrorResponse error type.
284func (client *NamedValueClient) GetEntityTag(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, options *NamedValueGetEntityTagOptions) (NamedValueGetEntityTagResponse, error) {
285	req, err := client.getEntityTagCreateRequest(ctx, resourceGroupName, serviceName, namedValueID, options)
286	if err != nil {
287		return NamedValueGetEntityTagResponse{}, err
288	}
289	resp, err := client.con.Pipeline().Do(req)
290	if err != nil {
291		return NamedValueGetEntityTagResponse{}, err
292	}
293	return client.getEntityTagHandleResponse(resp)
294}
295
296// getEntityTagCreateRequest creates the GetEntityTag request.
297func (client *NamedValueClient) getEntityTagCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, options *NamedValueGetEntityTagOptions) (*azcore.Request, error) {
298	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/namedValues/{namedValueId}"
299	if resourceGroupName == "" {
300		return nil, errors.New("parameter resourceGroupName cannot be empty")
301	}
302	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
303	if serviceName == "" {
304		return nil, errors.New("parameter serviceName cannot be empty")
305	}
306	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
307	if namedValueID == "" {
308		return nil, errors.New("parameter namedValueID cannot be empty")
309	}
310	urlPath = strings.ReplaceAll(urlPath, "{namedValueId}", url.PathEscape(namedValueID))
311	if client.subscriptionID == "" {
312		return nil, errors.New("parameter client.subscriptionID cannot be empty")
313	}
314	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
315	req, err := azcore.NewRequest(ctx, http.MethodHead, azcore.JoinPaths(client.con.Endpoint(), urlPath))
316	if err != nil {
317		return nil, err
318	}
319	req.Telemetry(telemetryInfo)
320	reqQP := req.URL.Query()
321	reqQP.Set("api-version", "2020-12-01")
322	req.URL.RawQuery = reqQP.Encode()
323	req.Header.Set("Accept", "application/json")
324	return req, nil
325}
326
327// getEntityTagHandleResponse handles the GetEntityTag response.
328func (client *NamedValueClient) getEntityTagHandleResponse(resp *azcore.Response) (NamedValueGetEntityTagResponse, error) {
329	result := NamedValueGetEntityTagResponse{RawResponse: resp.Response}
330	if val := resp.Header.Get("ETag"); val != "" {
331		result.ETag = &val
332	}
333	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
334		result.Success = true
335	}
336	return result, nil
337}
338
339// ListByService - Lists a collection of named values defined within a service instance.
340// If the operation fails it returns the *ErrorResponse error type.
341func (client *NamedValueClient) ListByService(resourceGroupName string, serviceName string, options *NamedValueListByServiceOptions) NamedValueListByServicePager {
342	return &namedValueListByServicePager{
343		client: client,
344		requester: func(ctx context.Context) (*azcore.Request, error) {
345			return client.listByServiceCreateRequest(ctx, resourceGroupName, serviceName, options)
346		},
347		advancer: func(ctx context.Context, resp NamedValueListByServiceResponse) (*azcore.Request, error) {
348			return azcore.NewRequest(ctx, http.MethodGet, *resp.NamedValueCollection.NextLink)
349		},
350	}
351}
352
353// listByServiceCreateRequest creates the ListByService request.
354func (client *NamedValueClient) listByServiceCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, options *NamedValueListByServiceOptions) (*azcore.Request, error) {
355	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/namedValues"
356	if resourceGroupName == "" {
357		return nil, errors.New("parameter resourceGroupName cannot be empty")
358	}
359	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
360	if serviceName == "" {
361		return nil, errors.New("parameter serviceName cannot be empty")
362	}
363	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
364	if client.subscriptionID == "" {
365		return nil, errors.New("parameter client.subscriptionID cannot be empty")
366	}
367	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
368	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
369	if err != nil {
370		return nil, err
371	}
372	req.Telemetry(telemetryInfo)
373	reqQP := req.URL.Query()
374	if options != nil && options.Filter != nil {
375		reqQP.Set("$filter", *options.Filter)
376	}
377	if options != nil && options.Top != nil {
378		reqQP.Set("$top", strconv.FormatInt(int64(*options.Top), 10))
379	}
380	if options != nil && options.Skip != nil {
381		reqQP.Set("$skip", strconv.FormatInt(int64(*options.Skip), 10))
382	}
383	if options != nil && options.IsKeyVaultRefreshFailed != nil {
384		reqQP.Set("isKeyVaultRefreshFailed", strconv.FormatBool(*options.IsKeyVaultRefreshFailed))
385	}
386	reqQP.Set("api-version", "2020-12-01")
387	req.URL.RawQuery = reqQP.Encode()
388	req.Header.Set("Accept", "application/json")
389	return req, nil
390}
391
392// listByServiceHandleResponse handles the ListByService response.
393func (client *NamedValueClient) listByServiceHandleResponse(resp *azcore.Response) (NamedValueListByServiceResponse, error) {
394	result := NamedValueListByServiceResponse{RawResponse: resp.Response}
395	if err := resp.UnmarshalAsJSON(&result.NamedValueCollection); err != nil {
396		return NamedValueListByServiceResponse{}, err
397	}
398	return result, nil
399}
400
401// listByServiceHandleError handles the ListByService error response.
402func (client *NamedValueClient) listByServiceHandleError(resp *azcore.Response) error {
403	body, err := resp.Payload()
404	if err != nil {
405		return azcore.NewResponseError(err, resp.Response)
406	}
407	errType := ErrorResponse{raw: string(body)}
408	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
409		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
410	}
411	return azcore.NewResponseError(&errType, resp.Response)
412}
413
414// ListValue - Gets the secret of the named value specified by its identifier.
415// If the operation fails it returns the *ErrorResponse error type.
416func (client *NamedValueClient) ListValue(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, options *NamedValueListValueOptions) (NamedValueListValueResponse, error) {
417	req, err := client.listValueCreateRequest(ctx, resourceGroupName, serviceName, namedValueID, options)
418	if err != nil {
419		return NamedValueListValueResponse{}, err
420	}
421	resp, err := client.con.Pipeline().Do(req)
422	if err != nil {
423		return NamedValueListValueResponse{}, err
424	}
425	if !resp.HasStatusCode(http.StatusOK) {
426		return NamedValueListValueResponse{}, client.listValueHandleError(resp)
427	}
428	return client.listValueHandleResponse(resp)
429}
430
431// listValueCreateRequest creates the ListValue request.
432func (client *NamedValueClient) listValueCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, options *NamedValueListValueOptions) (*azcore.Request, error) {
433	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/namedValues/{namedValueId}/listValue"
434	if resourceGroupName == "" {
435		return nil, errors.New("parameter resourceGroupName cannot be empty")
436	}
437	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
438	if serviceName == "" {
439		return nil, errors.New("parameter serviceName cannot be empty")
440	}
441	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
442	if namedValueID == "" {
443		return nil, errors.New("parameter namedValueID cannot be empty")
444	}
445	urlPath = strings.ReplaceAll(urlPath, "{namedValueId}", url.PathEscape(namedValueID))
446	if client.subscriptionID == "" {
447		return nil, errors.New("parameter client.subscriptionID cannot be empty")
448	}
449	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
450	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
451	if err != nil {
452		return nil, err
453	}
454	req.Telemetry(telemetryInfo)
455	reqQP := req.URL.Query()
456	reqQP.Set("api-version", "2020-12-01")
457	req.URL.RawQuery = reqQP.Encode()
458	req.Header.Set("Accept", "application/json")
459	return req, nil
460}
461
462// listValueHandleResponse handles the ListValue response.
463func (client *NamedValueClient) listValueHandleResponse(resp *azcore.Response) (NamedValueListValueResponse, error) {
464	result := NamedValueListValueResponse{RawResponse: resp.Response}
465	if val := resp.Header.Get("ETag"); val != "" {
466		result.ETag = &val
467	}
468	if err := resp.UnmarshalAsJSON(&result.NamedValueSecretContract); err != nil {
469		return NamedValueListValueResponse{}, err
470	}
471	return result, nil
472}
473
474// listValueHandleError handles the ListValue error response.
475func (client *NamedValueClient) listValueHandleError(resp *azcore.Response) error {
476	body, err := resp.Payload()
477	if err != nil {
478		return azcore.NewResponseError(err, resp.Response)
479	}
480	errType := ErrorResponse{raw: string(body)}
481	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
482		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
483	}
484	return azcore.NewResponseError(&errType, resp.Response)
485}
486
487// BeginRefreshSecret - Refresh the secret of the named value specified by its identifier.
488// If the operation fails it returns the *ErrorResponse error type.
489func (client *NamedValueClient) BeginRefreshSecret(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, options *NamedValueBeginRefreshSecretOptions) (NamedValueRefreshSecretPollerResponse, error) {
490	resp, err := client.refreshSecret(ctx, resourceGroupName, serviceName, namedValueID, options)
491	if err != nil {
492		return NamedValueRefreshSecretPollerResponse{}, err
493	}
494	result := NamedValueRefreshSecretPollerResponse{
495		RawResponse: resp.Response,
496	}
497	pt, err := armcore.NewLROPoller("NamedValueClient.RefreshSecret", "location", resp, client.con.Pipeline(), client.refreshSecretHandleError)
498	if err != nil {
499		return NamedValueRefreshSecretPollerResponse{}, err
500	}
501	poller := &namedValueRefreshSecretPoller{
502		pt: pt,
503	}
504	result.Poller = poller
505	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (NamedValueRefreshSecretResponse, error) {
506		return poller.pollUntilDone(ctx, frequency)
507	}
508	return result, nil
509}
510
511// ResumeRefreshSecret creates a new NamedValueRefreshSecretPoller from the specified resume token.
512// token - The value must come from a previous call to NamedValueRefreshSecretPoller.ResumeToken().
513func (client *NamedValueClient) ResumeRefreshSecret(ctx context.Context, token string) (NamedValueRefreshSecretPollerResponse, error) {
514	pt, err := armcore.NewLROPollerFromResumeToken("NamedValueClient.RefreshSecret", token, client.con.Pipeline(), client.refreshSecretHandleError)
515	if err != nil {
516		return NamedValueRefreshSecretPollerResponse{}, err
517	}
518	poller := &namedValueRefreshSecretPoller{
519		pt: pt,
520	}
521	resp, err := poller.Poll(ctx)
522	if err != nil {
523		return NamedValueRefreshSecretPollerResponse{}, err
524	}
525	result := NamedValueRefreshSecretPollerResponse{
526		RawResponse: resp,
527	}
528	result.Poller = poller
529	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (NamedValueRefreshSecretResponse, error) {
530		return poller.pollUntilDone(ctx, frequency)
531	}
532	return result, nil
533}
534
535// RefreshSecret - Refresh the secret of the named value specified by its identifier.
536// If the operation fails it returns the *ErrorResponse error type.
537func (client *NamedValueClient) refreshSecret(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, options *NamedValueBeginRefreshSecretOptions) (*azcore.Response, error) {
538	req, err := client.refreshSecretCreateRequest(ctx, resourceGroupName, serviceName, namedValueID, options)
539	if err != nil {
540		return nil, err
541	}
542	resp, err := client.con.Pipeline().Do(req)
543	if err != nil {
544		return nil, err
545	}
546	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
547		return nil, client.refreshSecretHandleError(resp)
548	}
549	return resp, nil
550}
551
552// refreshSecretCreateRequest creates the RefreshSecret request.
553func (client *NamedValueClient) refreshSecretCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, options *NamedValueBeginRefreshSecretOptions) (*azcore.Request, error) {
554	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/namedValues/{namedValueId}/refreshSecret"
555	if resourceGroupName == "" {
556		return nil, errors.New("parameter resourceGroupName cannot be empty")
557	}
558	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
559	if serviceName == "" {
560		return nil, errors.New("parameter serviceName cannot be empty")
561	}
562	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
563	if namedValueID == "" {
564		return nil, errors.New("parameter namedValueID cannot be empty")
565	}
566	urlPath = strings.ReplaceAll(urlPath, "{namedValueId}", url.PathEscape(namedValueID))
567	if client.subscriptionID == "" {
568		return nil, errors.New("parameter client.subscriptionID cannot be empty")
569	}
570	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
571	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
572	if err != nil {
573		return nil, err
574	}
575	req.Telemetry(telemetryInfo)
576	reqQP := req.URL.Query()
577	reqQP.Set("api-version", "2020-12-01")
578	req.URL.RawQuery = reqQP.Encode()
579	req.Header.Set("Accept", "application/json")
580	return req, nil
581}
582
583// refreshSecretHandleError handles the RefreshSecret error response.
584func (client *NamedValueClient) refreshSecretHandleError(resp *azcore.Response) error {
585	body, err := resp.Payload()
586	if err != nil {
587		return azcore.NewResponseError(err, resp.Response)
588	}
589	errType := ErrorResponse{raw: string(body)}
590	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
591		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
592	}
593	return azcore.NewResponseError(&errType, resp.Response)
594}
595
596// BeginUpdate - Updates the specific named value.
597// If the operation fails it returns the *ErrorResponse error type.
598func (client *NamedValueClient) BeginUpdate(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, ifMatch string, parameters NamedValueUpdateParameters, options *NamedValueBeginUpdateOptions) (NamedValueUpdatePollerResponse, error) {
599	resp, err := client.update(ctx, resourceGroupName, serviceName, namedValueID, ifMatch, parameters, options)
600	if err != nil {
601		return NamedValueUpdatePollerResponse{}, err
602	}
603	result := NamedValueUpdatePollerResponse{
604		RawResponse: resp.Response,
605	}
606	pt, err := armcore.NewLROPoller("NamedValueClient.Update", "location", resp, client.con.Pipeline(), client.updateHandleError)
607	if err != nil {
608		return NamedValueUpdatePollerResponse{}, err
609	}
610	poller := &namedValueUpdatePoller{
611		pt: pt,
612	}
613	result.Poller = poller
614	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (NamedValueUpdateResponse, error) {
615		return poller.pollUntilDone(ctx, frequency)
616	}
617	return result, nil
618}
619
620// ResumeUpdate creates a new NamedValueUpdatePoller from the specified resume token.
621// token - The value must come from a previous call to NamedValueUpdatePoller.ResumeToken().
622func (client *NamedValueClient) ResumeUpdate(ctx context.Context, token string) (NamedValueUpdatePollerResponse, error) {
623	pt, err := armcore.NewLROPollerFromResumeToken("NamedValueClient.Update", token, client.con.Pipeline(), client.updateHandleError)
624	if err != nil {
625		return NamedValueUpdatePollerResponse{}, err
626	}
627	poller := &namedValueUpdatePoller{
628		pt: pt,
629	}
630	resp, err := poller.Poll(ctx)
631	if err != nil {
632		return NamedValueUpdatePollerResponse{}, err
633	}
634	result := NamedValueUpdatePollerResponse{
635		RawResponse: resp,
636	}
637	result.Poller = poller
638	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (NamedValueUpdateResponse, error) {
639		return poller.pollUntilDone(ctx, frequency)
640	}
641	return result, nil
642}
643
644// Update - Updates the specific named value.
645// If the operation fails it returns the *ErrorResponse error type.
646func (client *NamedValueClient) update(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, ifMatch string, parameters NamedValueUpdateParameters, options *NamedValueBeginUpdateOptions) (*azcore.Response, error) {
647	req, err := client.updateCreateRequest(ctx, resourceGroupName, serviceName, namedValueID, ifMatch, parameters, options)
648	if err != nil {
649		return nil, err
650	}
651	resp, err := client.con.Pipeline().Do(req)
652	if err != nil {
653		return nil, err
654	}
655	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
656		return nil, client.updateHandleError(resp)
657	}
658	return resp, nil
659}
660
661// updateCreateRequest creates the Update request.
662func (client *NamedValueClient) updateCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, namedValueID string, ifMatch string, parameters NamedValueUpdateParameters, options *NamedValueBeginUpdateOptions) (*azcore.Request, error) {
663	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/namedValues/{namedValueId}"
664	if resourceGroupName == "" {
665		return nil, errors.New("parameter resourceGroupName cannot be empty")
666	}
667	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
668	if serviceName == "" {
669		return nil, errors.New("parameter serviceName cannot be empty")
670	}
671	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
672	if namedValueID == "" {
673		return nil, errors.New("parameter namedValueID cannot be empty")
674	}
675	urlPath = strings.ReplaceAll(urlPath, "{namedValueId}", url.PathEscape(namedValueID))
676	if client.subscriptionID == "" {
677		return nil, errors.New("parameter client.subscriptionID cannot be empty")
678	}
679	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
680	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
681	if err != nil {
682		return nil, err
683	}
684	req.Telemetry(telemetryInfo)
685	reqQP := req.URL.Query()
686	reqQP.Set("api-version", "2020-12-01")
687	req.URL.RawQuery = reqQP.Encode()
688	req.Header.Set("If-Match", ifMatch)
689	req.Header.Set("Accept", "application/json")
690	return req, req.MarshalAsJSON(parameters)
691}
692
693// updateHandleError handles the Update error response.
694func (client *NamedValueClient) updateHandleError(resp *azcore.Response) error {
695	body, err := resp.Payload()
696	if err != nil {
697		return azcore.NewResponseError(err, resp.Response)
698	}
699	errType := ErrorResponse{raw: string(body)}
700	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
701		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
702	}
703	return azcore.NewResponseError(&errType, resp.Response)
704}
705