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)
21
22// SubscriptionClient contains the methods for the Subscription group.
23// Don't use this type directly, use NewSubscriptionClient() instead.
24type SubscriptionClient struct {
25	con            *armcore.Connection
26	subscriptionID string
27}
28
29// NewSubscriptionClient creates a new instance of SubscriptionClient with the specified values.
30func NewSubscriptionClient(con *armcore.Connection, subscriptionID string) *SubscriptionClient {
31	return &SubscriptionClient{con: con, subscriptionID: subscriptionID}
32}
33
34// CreateOrUpdate - Creates or updates the subscription of specified user to the specified product.
35// If the operation fails it returns the *ErrorResponse error type.
36func (client *SubscriptionClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, serviceName string, sid string, parameters SubscriptionCreateParameters, options *SubscriptionCreateOrUpdateOptions) (SubscriptionCreateOrUpdateResponse, error) {
37	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, serviceName, sid, parameters, options)
38	if err != nil {
39		return SubscriptionCreateOrUpdateResponse{}, err
40	}
41	resp, err := client.con.Pipeline().Do(req)
42	if err != nil {
43		return SubscriptionCreateOrUpdateResponse{}, err
44	}
45	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
46		return SubscriptionCreateOrUpdateResponse{}, client.createOrUpdateHandleError(resp)
47	}
48	return client.createOrUpdateHandleResponse(resp)
49}
50
51// createOrUpdateCreateRequest creates the CreateOrUpdate request.
52func (client *SubscriptionClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, sid string, parameters SubscriptionCreateParameters, options *SubscriptionCreateOrUpdateOptions) (*azcore.Request, error) {
53	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions/{sid}"
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 serviceName == "" {
59		return nil, errors.New("parameter serviceName cannot be empty")
60	}
61	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
62	if sid == "" {
63		return nil, errors.New("parameter sid cannot be empty")
64	}
65	urlPath = strings.ReplaceAll(urlPath, "{sid}", url.PathEscape(sid))
66	if client.subscriptionID == "" {
67		return nil, errors.New("parameter client.subscriptionID cannot be empty")
68	}
69	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
70	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
71	if err != nil {
72		return nil, err
73	}
74	req.Telemetry(telemetryInfo)
75	reqQP := req.URL.Query()
76	if options != nil && options.Notify != nil {
77		reqQP.Set("notify", strconv.FormatBool(*options.Notify))
78	}
79	reqQP.Set("api-version", "2020-12-01")
80	if options != nil && options.AppType != nil {
81		reqQP.Set("appType", string(*options.AppType))
82	}
83	req.URL.RawQuery = reqQP.Encode()
84	if options != nil && options.IfMatch != nil {
85		req.Header.Set("If-Match", *options.IfMatch)
86	}
87	req.Header.Set("Accept", "application/json")
88	return req, req.MarshalAsJSON(parameters)
89}
90
91// createOrUpdateHandleResponse handles the CreateOrUpdate response.
92func (client *SubscriptionClient) createOrUpdateHandleResponse(resp *azcore.Response) (SubscriptionCreateOrUpdateResponse, error) {
93	result := SubscriptionCreateOrUpdateResponse{RawResponse: resp.Response}
94	if val := resp.Header.Get("ETag"); val != "" {
95		result.ETag = &val
96	}
97	if err := resp.UnmarshalAsJSON(&result.SubscriptionContract); err != nil {
98		return SubscriptionCreateOrUpdateResponse{}, err
99	}
100	return result, nil
101}
102
103// createOrUpdateHandleError handles the CreateOrUpdate error response.
104func (client *SubscriptionClient) createOrUpdateHandleError(resp *azcore.Response) error {
105	body, err := resp.Payload()
106	if err != nil {
107		return azcore.NewResponseError(err, resp.Response)
108	}
109	errType := ErrorResponse{raw: string(body)}
110	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
111		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
112	}
113	return azcore.NewResponseError(&errType, resp.Response)
114}
115
116// Delete - Deletes the specified subscription.
117// If the operation fails it returns the *ErrorResponse error type.
118func (client *SubscriptionClient) Delete(ctx context.Context, resourceGroupName string, serviceName string, sid string, ifMatch string, options *SubscriptionDeleteOptions) (SubscriptionDeleteResponse, error) {
119	req, err := client.deleteCreateRequest(ctx, resourceGroupName, serviceName, sid, ifMatch, options)
120	if err != nil {
121		return SubscriptionDeleteResponse{}, err
122	}
123	resp, err := client.con.Pipeline().Do(req)
124	if err != nil {
125		return SubscriptionDeleteResponse{}, err
126	}
127	if !resp.HasStatusCode(http.StatusOK, http.StatusNoContent) {
128		return SubscriptionDeleteResponse{}, client.deleteHandleError(resp)
129	}
130	return SubscriptionDeleteResponse{RawResponse: resp.Response}, nil
131}
132
133// deleteCreateRequest creates the Delete request.
134func (client *SubscriptionClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, sid string, ifMatch string, options *SubscriptionDeleteOptions) (*azcore.Request, error) {
135	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions/{sid}"
136	if resourceGroupName == "" {
137		return nil, errors.New("parameter resourceGroupName cannot be empty")
138	}
139	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
140	if serviceName == "" {
141		return nil, errors.New("parameter serviceName cannot be empty")
142	}
143	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
144	if sid == "" {
145		return nil, errors.New("parameter sid cannot be empty")
146	}
147	urlPath = strings.ReplaceAll(urlPath, "{sid}", url.PathEscape(sid))
148	if client.subscriptionID == "" {
149		return nil, errors.New("parameter client.subscriptionID cannot be empty")
150	}
151	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
152	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
153	if err != nil {
154		return nil, err
155	}
156	req.Telemetry(telemetryInfo)
157	reqQP := req.URL.Query()
158	reqQP.Set("api-version", "2020-12-01")
159	req.URL.RawQuery = reqQP.Encode()
160	req.Header.Set("If-Match", ifMatch)
161	req.Header.Set("Accept", "application/json")
162	return req, nil
163}
164
165// deleteHandleError handles the Delete error response.
166func (client *SubscriptionClient) deleteHandleError(resp *azcore.Response) error {
167	body, err := resp.Payload()
168	if err != nil {
169		return azcore.NewResponseError(err, resp.Response)
170	}
171	errType := ErrorResponse{raw: string(body)}
172	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
173		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
174	}
175	return azcore.NewResponseError(&errType, resp.Response)
176}
177
178// Get - Gets the specified Subscription entity.
179// If the operation fails it returns the *ErrorResponse error type.
180func (client *SubscriptionClient) Get(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionGetOptions) (SubscriptionGetResponse, error) {
181	req, err := client.getCreateRequest(ctx, resourceGroupName, serviceName, sid, options)
182	if err != nil {
183		return SubscriptionGetResponse{}, err
184	}
185	resp, err := client.con.Pipeline().Do(req)
186	if err != nil {
187		return SubscriptionGetResponse{}, err
188	}
189	if !resp.HasStatusCode(http.StatusOK) {
190		return SubscriptionGetResponse{}, client.getHandleError(resp)
191	}
192	return client.getHandleResponse(resp)
193}
194
195// getCreateRequest creates the Get request.
196func (client *SubscriptionClient) getCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionGetOptions) (*azcore.Request, error) {
197	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions/{sid}"
198	if resourceGroupName == "" {
199		return nil, errors.New("parameter resourceGroupName cannot be empty")
200	}
201	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
202	if serviceName == "" {
203		return nil, errors.New("parameter serviceName cannot be empty")
204	}
205	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
206	if sid == "" {
207		return nil, errors.New("parameter sid cannot be empty")
208	}
209	urlPath = strings.ReplaceAll(urlPath, "{sid}", url.PathEscape(sid))
210	if client.subscriptionID == "" {
211		return nil, errors.New("parameter client.subscriptionID cannot be empty")
212	}
213	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
214	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
215	if err != nil {
216		return nil, err
217	}
218	req.Telemetry(telemetryInfo)
219	reqQP := req.URL.Query()
220	reqQP.Set("api-version", "2020-12-01")
221	req.URL.RawQuery = reqQP.Encode()
222	req.Header.Set("Accept", "application/json")
223	return req, nil
224}
225
226// getHandleResponse handles the Get response.
227func (client *SubscriptionClient) getHandleResponse(resp *azcore.Response) (SubscriptionGetResponse, error) {
228	result := SubscriptionGetResponse{RawResponse: resp.Response}
229	if val := resp.Header.Get("ETag"); val != "" {
230		result.ETag = &val
231	}
232	if err := resp.UnmarshalAsJSON(&result.SubscriptionContract); err != nil {
233		return SubscriptionGetResponse{}, err
234	}
235	return result, nil
236}
237
238// getHandleError handles the Get error response.
239func (client *SubscriptionClient) getHandleError(resp *azcore.Response) error {
240	body, err := resp.Payload()
241	if err != nil {
242		return azcore.NewResponseError(err, resp.Response)
243	}
244	errType := ErrorResponse{raw: string(body)}
245	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
246		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
247	}
248	return azcore.NewResponseError(&errType, resp.Response)
249}
250
251// GetEntityTag - Gets the entity state (Etag) version of the apimanagement subscription specified by its identifier.
252// If the operation fails it returns the *ErrorResponse error type.
253func (client *SubscriptionClient) GetEntityTag(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionGetEntityTagOptions) (SubscriptionGetEntityTagResponse, error) {
254	req, err := client.getEntityTagCreateRequest(ctx, resourceGroupName, serviceName, sid, options)
255	if err != nil {
256		return SubscriptionGetEntityTagResponse{}, err
257	}
258	resp, err := client.con.Pipeline().Do(req)
259	if err != nil {
260		return SubscriptionGetEntityTagResponse{}, err
261	}
262	return client.getEntityTagHandleResponse(resp)
263}
264
265// getEntityTagCreateRequest creates the GetEntityTag request.
266func (client *SubscriptionClient) getEntityTagCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionGetEntityTagOptions) (*azcore.Request, error) {
267	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions/{sid}"
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 serviceName == "" {
273		return nil, errors.New("parameter serviceName cannot be empty")
274	}
275	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
276	if sid == "" {
277		return nil, errors.New("parameter sid cannot be empty")
278	}
279	urlPath = strings.ReplaceAll(urlPath, "{sid}", url.PathEscape(sid))
280	if client.subscriptionID == "" {
281		return nil, errors.New("parameter client.subscriptionID cannot be empty")
282	}
283	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
284	req, err := azcore.NewRequest(ctx, http.MethodHead, azcore.JoinPaths(client.con.Endpoint(), urlPath))
285	if err != nil {
286		return nil, err
287	}
288	req.Telemetry(telemetryInfo)
289	reqQP := req.URL.Query()
290	reqQP.Set("api-version", "2020-12-01")
291	req.URL.RawQuery = reqQP.Encode()
292	req.Header.Set("Accept", "application/json")
293	return req, nil
294}
295
296// getEntityTagHandleResponse handles the GetEntityTag response.
297func (client *SubscriptionClient) getEntityTagHandleResponse(resp *azcore.Response) (SubscriptionGetEntityTagResponse, error) {
298	result := SubscriptionGetEntityTagResponse{RawResponse: resp.Response}
299	if val := resp.Header.Get("ETag"); val != "" {
300		result.ETag = &val
301	}
302	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
303		result.Success = true
304	}
305	return result, nil
306}
307
308// List - Lists all subscriptions of the API Management service instance.
309// If the operation fails it returns the *ErrorResponse error type.
310func (client *SubscriptionClient) List(resourceGroupName string, serviceName string, options *SubscriptionListOptions) SubscriptionListPager {
311	return &subscriptionListPager{
312		client: client,
313		requester: func(ctx context.Context) (*azcore.Request, error) {
314			return client.listCreateRequest(ctx, resourceGroupName, serviceName, options)
315		},
316		advancer: func(ctx context.Context, resp SubscriptionListResponse) (*azcore.Request, error) {
317			return azcore.NewRequest(ctx, http.MethodGet, *resp.SubscriptionCollection.NextLink)
318		},
319	}
320}
321
322// listCreateRequest creates the List request.
323func (client *SubscriptionClient) listCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, options *SubscriptionListOptions) (*azcore.Request, error) {
324	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions"
325	if resourceGroupName == "" {
326		return nil, errors.New("parameter resourceGroupName cannot be empty")
327	}
328	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
329	if serviceName == "" {
330		return nil, errors.New("parameter serviceName cannot be empty")
331	}
332	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
333	if client.subscriptionID == "" {
334		return nil, errors.New("parameter client.subscriptionID cannot be empty")
335	}
336	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
337	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
338	if err != nil {
339		return nil, err
340	}
341	req.Telemetry(telemetryInfo)
342	reqQP := req.URL.Query()
343	if options != nil && options.Filter != nil {
344		reqQP.Set("$filter", *options.Filter)
345	}
346	if options != nil && options.Top != nil {
347		reqQP.Set("$top", strconv.FormatInt(int64(*options.Top), 10))
348	}
349	if options != nil && options.Skip != nil {
350		reqQP.Set("$skip", strconv.FormatInt(int64(*options.Skip), 10))
351	}
352	reqQP.Set("api-version", "2020-12-01")
353	req.URL.RawQuery = reqQP.Encode()
354	req.Header.Set("Accept", "application/json")
355	return req, nil
356}
357
358// listHandleResponse handles the List response.
359func (client *SubscriptionClient) listHandleResponse(resp *azcore.Response) (SubscriptionListResponse, error) {
360	result := SubscriptionListResponse{RawResponse: resp.Response}
361	if err := resp.UnmarshalAsJSON(&result.SubscriptionCollection); err != nil {
362		return SubscriptionListResponse{}, err
363	}
364	return result, nil
365}
366
367// listHandleError handles the List error response.
368func (client *SubscriptionClient) listHandleError(resp *azcore.Response) error {
369	body, err := resp.Payload()
370	if err != nil {
371		return azcore.NewResponseError(err, resp.Response)
372	}
373	errType := ErrorResponse{raw: string(body)}
374	if err := resp.UnmarshalAsJSON(&errType.InnerError); 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// ListSecrets - Gets the specified Subscription keys.
381// If the operation fails it returns the *ErrorResponse error type.
382func (client *SubscriptionClient) ListSecrets(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionListSecretsOptions) (SubscriptionListSecretsResponse, error) {
383	req, err := client.listSecretsCreateRequest(ctx, resourceGroupName, serviceName, sid, options)
384	if err != nil {
385		return SubscriptionListSecretsResponse{}, err
386	}
387	resp, err := client.con.Pipeline().Do(req)
388	if err != nil {
389		return SubscriptionListSecretsResponse{}, err
390	}
391	if !resp.HasStatusCode(http.StatusOK) {
392		return SubscriptionListSecretsResponse{}, client.listSecretsHandleError(resp)
393	}
394	return client.listSecretsHandleResponse(resp)
395}
396
397// listSecretsCreateRequest creates the ListSecrets request.
398func (client *SubscriptionClient) listSecretsCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionListSecretsOptions) (*azcore.Request, error) {
399	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions/{sid}/listSecrets"
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 serviceName == "" {
405		return nil, errors.New("parameter serviceName cannot be empty")
406	}
407	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
408	if sid == "" {
409		return nil, errors.New("parameter sid cannot be empty")
410	}
411	urlPath = strings.ReplaceAll(urlPath, "{sid}", url.PathEscape(sid))
412	if client.subscriptionID == "" {
413		return nil, errors.New("parameter client.subscriptionID cannot be empty")
414	}
415	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
416	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
417	if err != nil {
418		return nil, err
419	}
420	req.Telemetry(telemetryInfo)
421	reqQP := req.URL.Query()
422	reqQP.Set("api-version", "2020-12-01")
423	req.URL.RawQuery = reqQP.Encode()
424	req.Header.Set("Accept", "application/json")
425	return req, nil
426}
427
428// listSecretsHandleResponse handles the ListSecrets response.
429func (client *SubscriptionClient) listSecretsHandleResponse(resp *azcore.Response) (SubscriptionListSecretsResponse, error) {
430	result := SubscriptionListSecretsResponse{RawResponse: resp.Response}
431	if val := resp.Header.Get("ETag"); val != "" {
432		result.ETag = &val
433	}
434	if err := resp.UnmarshalAsJSON(&result.SubscriptionKeysContract); err != nil {
435		return SubscriptionListSecretsResponse{}, err
436	}
437	return result, nil
438}
439
440// listSecretsHandleError handles the ListSecrets error response.
441func (client *SubscriptionClient) listSecretsHandleError(resp *azcore.Response) error {
442	body, err := resp.Payload()
443	if err != nil {
444		return azcore.NewResponseError(err, resp.Response)
445	}
446	errType := ErrorResponse{raw: string(body)}
447	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
448		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
449	}
450	return azcore.NewResponseError(&errType, resp.Response)
451}
452
453// RegeneratePrimaryKey - Regenerates primary key of existing subscription of the API Management service instance.
454// If the operation fails it returns the *ErrorResponse error type.
455func (client *SubscriptionClient) RegeneratePrimaryKey(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionRegeneratePrimaryKeyOptions) (SubscriptionRegeneratePrimaryKeyResponse, error) {
456	req, err := client.regeneratePrimaryKeyCreateRequest(ctx, resourceGroupName, serviceName, sid, options)
457	if err != nil {
458		return SubscriptionRegeneratePrimaryKeyResponse{}, err
459	}
460	resp, err := client.con.Pipeline().Do(req)
461	if err != nil {
462		return SubscriptionRegeneratePrimaryKeyResponse{}, err
463	}
464	if !resp.HasStatusCode(http.StatusNoContent) {
465		return SubscriptionRegeneratePrimaryKeyResponse{}, client.regeneratePrimaryKeyHandleError(resp)
466	}
467	return SubscriptionRegeneratePrimaryKeyResponse{RawResponse: resp.Response}, nil
468}
469
470// regeneratePrimaryKeyCreateRequest creates the RegeneratePrimaryKey request.
471func (client *SubscriptionClient) regeneratePrimaryKeyCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionRegeneratePrimaryKeyOptions) (*azcore.Request, error) {
472	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions/{sid}/regeneratePrimaryKey"
473	if resourceGroupName == "" {
474		return nil, errors.New("parameter resourceGroupName cannot be empty")
475	}
476	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
477	if serviceName == "" {
478		return nil, errors.New("parameter serviceName cannot be empty")
479	}
480	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
481	if sid == "" {
482		return nil, errors.New("parameter sid cannot be empty")
483	}
484	urlPath = strings.ReplaceAll(urlPath, "{sid}", url.PathEscape(sid))
485	if client.subscriptionID == "" {
486		return nil, errors.New("parameter client.subscriptionID cannot be empty")
487	}
488	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
489	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
490	if err != nil {
491		return nil, err
492	}
493	req.Telemetry(telemetryInfo)
494	reqQP := req.URL.Query()
495	reqQP.Set("api-version", "2020-12-01")
496	req.URL.RawQuery = reqQP.Encode()
497	req.Header.Set("Accept", "application/json")
498	return req, nil
499}
500
501// regeneratePrimaryKeyHandleError handles the RegeneratePrimaryKey error response.
502func (client *SubscriptionClient) regeneratePrimaryKeyHandleError(resp *azcore.Response) error {
503	body, err := resp.Payload()
504	if err != nil {
505		return azcore.NewResponseError(err, resp.Response)
506	}
507	errType := ErrorResponse{raw: string(body)}
508	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
509		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
510	}
511	return azcore.NewResponseError(&errType, resp.Response)
512}
513
514// RegenerateSecondaryKey - Regenerates secondary key of existing subscription of the API Management service instance.
515// If the operation fails it returns the *ErrorResponse error type.
516func (client *SubscriptionClient) RegenerateSecondaryKey(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionRegenerateSecondaryKeyOptions) (SubscriptionRegenerateSecondaryKeyResponse, error) {
517	req, err := client.regenerateSecondaryKeyCreateRequest(ctx, resourceGroupName, serviceName, sid, options)
518	if err != nil {
519		return SubscriptionRegenerateSecondaryKeyResponse{}, err
520	}
521	resp, err := client.con.Pipeline().Do(req)
522	if err != nil {
523		return SubscriptionRegenerateSecondaryKeyResponse{}, err
524	}
525	if !resp.HasStatusCode(http.StatusNoContent) {
526		return SubscriptionRegenerateSecondaryKeyResponse{}, client.regenerateSecondaryKeyHandleError(resp)
527	}
528	return SubscriptionRegenerateSecondaryKeyResponse{RawResponse: resp.Response}, nil
529}
530
531// regenerateSecondaryKeyCreateRequest creates the RegenerateSecondaryKey request.
532func (client *SubscriptionClient) regenerateSecondaryKeyCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, sid string, options *SubscriptionRegenerateSecondaryKeyOptions) (*azcore.Request, error) {
533	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions/{sid}/regenerateSecondaryKey"
534	if resourceGroupName == "" {
535		return nil, errors.New("parameter resourceGroupName cannot be empty")
536	}
537	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
538	if serviceName == "" {
539		return nil, errors.New("parameter serviceName cannot be empty")
540	}
541	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
542	if sid == "" {
543		return nil, errors.New("parameter sid cannot be empty")
544	}
545	urlPath = strings.ReplaceAll(urlPath, "{sid}", url.PathEscape(sid))
546	if client.subscriptionID == "" {
547		return nil, errors.New("parameter client.subscriptionID cannot be empty")
548	}
549	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
550	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
551	if err != nil {
552		return nil, err
553	}
554	req.Telemetry(telemetryInfo)
555	reqQP := req.URL.Query()
556	reqQP.Set("api-version", "2020-12-01")
557	req.URL.RawQuery = reqQP.Encode()
558	req.Header.Set("Accept", "application/json")
559	return req, nil
560}
561
562// regenerateSecondaryKeyHandleError handles the RegenerateSecondaryKey error response.
563func (client *SubscriptionClient) regenerateSecondaryKeyHandleError(resp *azcore.Response) error {
564	body, err := resp.Payload()
565	if err != nil {
566		return azcore.NewResponseError(err, resp.Response)
567	}
568	errType := ErrorResponse{raw: string(body)}
569	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
570		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
571	}
572	return azcore.NewResponseError(&errType, resp.Response)
573}
574
575// Update - Updates the details of a subscription specified by its identifier.
576// If the operation fails it returns the *ErrorResponse error type.
577func (client *SubscriptionClient) Update(ctx context.Context, resourceGroupName string, serviceName string, sid string, ifMatch string, parameters SubscriptionUpdateParameters, options *SubscriptionUpdateOptions) (SubscriptionUpdateResponse, error) {
578	req, err := client.updateCreateRequest(ctx, resourceGroupName, serviceName, sid, ifMatch, parameters, options)
579	if err != nil {
580		return SubscriptionUpdateResponse{}, err
581	}
582	resp, err := client.con.Pipeline().Do(req)
583	if err != nil {
584		return SubscriptionUpdateResponse{}, err
585	}
586	if !resp.HasStatusCode(http.StatusOK) {
587		return SubscriptionUpdateResponse{}, client.updateHandleError(resp)
588	}
589	return client.updateHandleResponse(resp)
590}
591
592// updateCreateRequest creates the Update request.
593func (client *SubscriptionClient) updateCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, sid string, ifMatch string, parameters SubscriptionUpdateParameters, options *SubscriptionUpdateOptions) (*azcore.Request, error) {
594	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/subscriptions/{sid}"
595	if resourceGroupName == "" {
596		return nil, errors.New("parameter resourceGroupName cannot be empty")
597	}
598	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
599	if serviceName == "" {
600		return nil, errors.New("parameter serviceName cannot be empty")
601	}
602	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
603	if sid == "" {
604		return nil, errors.New("parameter sid cannot be empty")
605	}
606	urlPath = strings.ReplaceAll(urlPath, "{sid}", url.PathEscape(sid))
607	if client.subscriptionID == "" {
608		return nil, errors.New("parameter client.subscriptionID cannot be empty")
609	}
610	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
611	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
612	if err != nil {
613		return nil, err
614	}
615	req.Telemetry(telemetryInfo)
616	reqQP := req.URL.Query()
617	if options != nil && options.Notify != nil {
618		reqQP.Set("notify", strconv.FormatBool(*options.Notify))
619	}
620	reqQP.Set("api-version", "2020-12-01")
621	if options != nil && options.AppType != nil {
622		reqQP.Set("appType", string(*options.AppType))
623	}
624	req.URL.RawQuery = reqQP.Encode()
625	req.Header.Set("If-Match", ifMatch)
626	req.Header.Set("Accept", "application/json")
627	return req, req.MarshalAsJSON(parameters)
628}
629
630// updateHandleResponse handles the Update response.
631func (client *SubscriptionClient) updateHandleResponse(resp *azcore.Response) (SubscriptionUpdateResponse, error) {
632	result := SubscriptionUpdateResponse{RawResponse: resp.Response}
633	if val := resp.Header.Get("ETag"); val != "" {
634		result.ETag = &val
635	}
636	if err := resp.UnmarshalAsJSON(&result.SubscriptionContract); err != nil {
637		return SubscriptionUpdateResponse{}, err
638	}
639	return result, nil
640}
641
642// updateHandleError handles the Update error response.
643func (client *SubscriptionClient) updateHandleError(resp *azcore.Response) error {
644	body, err := resp.Payload()
645	if err != nil {
646		return azcore.NewResponseError(err, resp.Response)
647	}
648	errType := ErrorResponse{raw: string(body)}
649	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
650		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
651	}
652	return azcore.NewResponseError(&errType, resp.Response)
653}
654