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// UserClient contains the methods for the User group.
23// Don't use this type directly, use NewUserClient() instead.
24type UserClient struct {
25	con            *armcore.Connection
26	subscriptionID string
27}
28
29// NewUserClient creates a new instance of UserClient with the specified values.
30func NewUserClient(con *armcore.Connection, subscriptionID string) *UserClient {
31	return &UserClient{con: con, subscriptionID: subscriptionID}
32}
33
34// CreateOrUpdate - Creates or Updates a user.
35// If the operation fails it returns the *ErrorResponse error type.
36func (client *UserClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, serviceName string, userID string, parameters UserCreateParameters, options *UserCreateOrUpdateOptions) (UserCreateOrUpdateResponse, error) {
37	req, err := client.createOrUpdateCreateRequest(ctx, resourceGroupName, serviceName, userID, parameters, options)
38	if err != nil {
39		return UserCreateOrUpdateResponse{}, err
40	}
41	resp, err := client.con.Pipeline().Do(req)
42	if err != nil {
43		return UserCreateOrUpdateResponse{}, err
44	}
45	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
46		return UserCreateOrUpdateResponse{}, client.createOrUpdateHandleError(resp)
47	}
48	return client.createOrUpdateHandleResponse(resp)
49}
50
51// createOrUpdateCreateRequest creates the CreateOrUpdate request.
52func (client *UserClient) createOrUpdateCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, userID string, parameters UserCreateParameters, options *UserCreateOrUpdateOptions) (*azcore.Request, error) {
53	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/users/{userId}"
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 userID == "" {
63		return nil, errors.New("parameter userID cannot be empty")
64	}
65	urlPath = strings.ReplaceAll(urlPath, "{userId}", url.PathEscape(userID))
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	req.URL.RawQuery = reqQP.Encode()
81	if options != nil && options.IfMatch != nil {
82		req.Header.Set("If-Match", *options.IfMatch)
83	}
84	req.Header.Set("Accept", "application/json")
85	return req, req.MarshalAsJSON(parameters)
86}
87
88// createOrUpdateHandleResponse handles the CreateOrUpdate response.
89func (client *UserClient) createOrUpdateHandleResponse(resp *azcore.Response) (UserCreateOrUpdateResponse, error) {
90	result := UserCreateOrUpdateResponse{RawResponse: resp.Response}
91	if val := resp.Header.Get("ETag"); val != "" {
92		result.ETag = &val
93	}
94	if err := resp.UnmarshalAsJSON(&result.UserContract); err != nil {
95		return UserCreateOrUpdateResponse{}, err
96	}
97	return result, nil
98}
99
100// createOrUpdateHandleError handles the CreateOrUpdate error response.
101func (client *UserClient) createOrUpdateHandleError(resp *azcore.Response) error {
102	body, err := resp.Payload()
103	if err != nil {
104		return azcore.NewResponseError(err, resp.Response)
105	}
106	errType := ErrorResponse{raw: string(body)}
107	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
108		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
109	}
110	return azcore.NewResponseError(&errType, resp.Response)
111}
112
113// Delete - Deletes specific user.
114// If the operation fails it returns the *ErrorResponse error type.
115func (client *UserClient) Delete(ctx context.Context, resourceGroupName string, serviceName string, userID string, ifMatch string, options *UserDeleteOptions) (UserDeleteResponse, error) {
116	req, err := client.deleteCreateRequest(ctx, resourceGroupName, serviceName, userID, ifMatch, options)
117	if err != nil {
118		return UserDeleteResponse{}, err
119	}
120	resp, err := client.con.Pipeline().Do(req)
121	if err != nil {
122		return UserDeleteResponse{}, err
123	}
124	if !resp.HasStatusCode(http.StatusOK, http.StatusNoContent) {
125		return UserDeleteResponse{}, client.deleteHandleError(resp)
126	}
127	return UserDeleteResponse{RawResponse: resp.Response}, nil
128}
129
130// deleteCreateRequest creates the Delete request.
131func (client *UserClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, userID string, ifMatch string, options *UserDeleteOptions) (*azcore.Request, error) {
132	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/users/{userId}"
133	if resourceGroupName == "" {
134		return nil, errors.New("parameter resourceGroupName cannot be empty")
135	}
136	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
137	if serviceName == "" {
138		return nil, errors.New("parameter serviceName cannot be empty")
139	}
140	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
141	if userID == "" {
142		return nil, errors.New("parameter userID cannot be empty")
143	}
144	urlPath = strings.ReplaceAll(urlPath, "{userId}", url.PathEscape(userID))
145	if client.subscriptionID == "" {
146		return nil, errors.New("parameter client.subscriptionID cannot be empty")
147	}
148	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
149	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
150	if err != nil {
151		return nil, err
152	}
153	req.Telemetry(telemetryInfo)
154	reqQP := req.URL.Query()
155	if options != nil && options.DeleteSubscriptions != nil {
156		reqQP.Set("deleteSubscriptions", strconv.FormatBool(*options.DeleteSubscriptions))
157	}
158	if options != nil && options.Notify != nil {
159		reqQP.Set("notify", strconv.FormatBool(*options.Notify))
160	}
161	reqQP.Set("api-version", "2020-12-01")
162	if options != nil && options.AppType != nil {
163		reqQP.Set("appType", string(*options.AppType))
164	}
165	req.URL.RawQuery = reqQP.Encode()
166	req.Header.Set("If-Match", ifMatch)
167	req.Header.Set("Accept", "application/json")
168	return req, nil
169}
170
171// deleteHandleError handles the Delete error response.
172func (client *UserClient) deleteHandleError(resp *azcore.Response) error {
173	body, err := resp.Payload()
174	if err != nil {
175		return azcore.NewResponseError(err, resp.Response)
176	}
177	errType := ErrorResponse{raw: string(body)}
178	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
179		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
180	}
181	return azcore.NewResponseError(&errType, resp.Response)
182}
183
184// GenerateSsoURL - Retrieves a redirection URL containing an authentication token for signing a given user into the developer portal.
185// If the operation fails it returns the *ErrorResponse error type.
186func (client *UserClient) GenerateSsoURL(ctx context.Context, resourceGroupName string, serviceName string, userID string, options *UserGenerateSsoURLOptions) (UserGenerateSsoURLResponse, error) {
187	req, err := client.generateSsoURLCreateRequest(ctx, resourceGroupName, serviceName, userID, options)
188	if err != nil {
189		return UserGenerateSsoURLResponse{}, err
190	}
191	resp, err := client.con.Pipeline().Do(req)
192	if err != nil {
193		return UserGenerateSsoURLResponse{}, err
194	}
195	if !resp.HasStatusCode(http.StatusOK) {
196		return UserGenerateSsoURLResponse{}, client.generateSsoURLHandleError(resp)
197	}
198	return client.generateSsoURLHandleResponse(resp)
199}
200
201// generateSsoURLCreateRequest creates the GenerateSsoURL request.
202func (client *UserClient) generateSsoURLCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, userID string, options *UserGenerateSsoURLOptions) (*azcore.Request, error) {
203	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/users/{userId}/generateSsoUrl"
204	if resourceGroupName == "" {
205		return nil, errors.New("parameter resourceGroupName cannot be empty")
206	}
207	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
208	if serviceName == "" {
209		return nil, errors.New("parameter serviceName cannot be empty")
210	}
211	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
212	if userID == "" {
213		return nil, errors.New("parameter userID cannot be empty")
214	}
215	urlPath = strings.ReplaceAll(urlPath, "{userId}", url.PathEscape(userID))
216	if client.subscriptionID == "" {
217		return nil, errors.New("parameter client.subscriptionID cannot be empty")
218	}
219	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
220	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
221	if err != nil {
222		return nil, err
223	}
224	req.Telemetry(telemetryInfo)
225	reqQP := req.URL.Query()
226	reqQP.Set("api-version", "2020-12-01")
227	req.URL.RawQuery = reqQP.Encode()
228	req.Header.Set("Accept", "application/json")
229	return req, nil
230}
231
232// generateSsoURLHandleResponse handles the GenerateSsoURL response.
233func (client *UserClient) generateSsoURLHandleResponse(resp *azcore.Response) (UserGenerateSsoURLResponse, error) {
234	result := UserGenerateSsoURLResponse{RawResponse: resp.Response}
235	if err := resp.UnmarshalAsJSON(&result.GenerateSsoURLResult); err != nil {
236		return UserGenerateSsoURLResponse{}, err
237	}
238	return result, nil
239}
240
241// generateSsoURLHandleError handles the GenerateSsoURL error response.
242func (client *UserClient) generateSsoURLHandleError(resp *azcore.Response) error {
243	body, err := resp.Payload()
244	if err != nil {
245		return azcore.NewResponseError(err, resp.Response)
246	}
247	errType := ErrorResponse{raw: string(body)}
248	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
249		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
250	}
251	return azcore.NewResponseError(&errType, resp.Response)
252}
253
254// Get - Gets the details of the user specified by its identifier.
255// If the operation fails it returns the *ErrorResponse error type.
256func (client *UserClient) Get(ctx context.Context, resourceGroupName string, serviceName string, userID string, options *UserGetOptions) (UserGetResponse, error) {
257	req, err := client.getCreateRequest(ctx, resourceGroupName, serviceName, userID, options)
258	if err != nil {
259		return UserGetResponse{}, err
260	}
261	resp, err := client.con.Pipeline().Do(req)
262	if err != nil {
263		return UserGetResponse{}, err
264	}
265	if !resp.HasStatusCode(http.StatusOK) {
266		return UserGetResponse{}, client.getHandleError(resp)
267	}
268	return client.getHandleResponse(resp)
269}
270
271// getCreateRequest creates the Get request.
272func (client *UserClient) getCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, userID string, options *UserGetOptions) (*azcore.Request, error) {
273	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/users/{userId}"
274	if resourceGroupName == "" {
275		return nil, errors.New("parameter resourceGroupName cannot be empty")
276	}
277	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
278	if serviceName == "" {
279		return nil, errors.New("parameter serviceName cannot be empty")
280	}
281	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
282	if userID == "" {
283		return nil, errors.New("parameter userID cannot be empty")
284	}
285	urlPath = strings.ReplaceAll(urlPath, "{userId}", url.PathEscape(userID))
286	if client.subscriptionID == "" {
287		return nil, errors.New("parameter client.subscriptionID cannot be empty")
288	}
289	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
290	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
291	if err != nil {
292		return nil, err
293	}
294	req.Telemetry(telemetryInfo)
295	reqQP := req.URL.Query()
296	reqQP.Set("api-version", "2020-12-01")
297	req.URL.RawQuery = reqQP.Encode()
298	req.Header.Set("Accept", "application/json")
299	return req, nil
300}
301
302// getHandleResponse handles the Get response.
303func (client *UserClient) getHandleResponse(resp *azcore.Response) (UserGetResponse, error) {
304	result := UserGetResponse{RawResponse: resp.Response}
305	if val := resp.Header.Get("ETag"); val != "" {
306		result.ETag = &val
307	}
308	if err := resp.UnmarshalAsJSON(&result.UserContract); err != nil {
309		return UserGetResponse{}, err
310	}
311	return result, nil
312}
313
314// getHandleError handles the Get error response.
315func (client *UserClient) getHandleError(resp *azcore.Response) error {
316	body, err := resp.Payload()
317	if err != nil {
318		return azcore.NewResponseError(err, resp.Response)
319	}
320	errType := ErrorResponse{raw: string(body)}
321	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
322		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
323	}
324	return azcore.NewResponseError(&errType, resp.Response)
325}
326
327// GetEntityTag - Gets the entity state (Etag) version of the user specified by its identifier.
328// If the operation fails it returns the *ErrorResponse error type.
329func (client *UserClient) GetEntityTag(ctx context.Context, resourceGroupName string, serviceName string, userID string, options *UserGetEntityTagOptions) (UserGetEntityTagResponse, error) {
330	req, err := client.getEntityTagCreateRequest(ctx, resourceGroupName, serviceName, userID, options)
331	if err != nil {
332		return UserGetEntityTagResponse{}, err
333	}
334	resp, err := client.con.Pipeline().Do(req)
335	if err != nil {
336		return UserGetEntityTagResponse{}, err
337	}
338	return client.getEntityTagHandleResponse(resp)
339}
340
341// getEntityTagCreateRequest creates the GetEntityTag request.
342func (client *UserClient) getEntityTagCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, userID string, options *UserGetEntityTagOptions) (*azcore.Request, error) {
343	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/users/{userId}"
344	if resourceGroupName == "" {
345		return nil, errors.New("parameter resourceGroupName cannot be empty")
346	}
347	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
348	if serviceName == "" {
349		return nil, errors.New("parameter serviceName cannot be empty")
350	}
351	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
352	if userID == "" {
353		return nil, errors.New("parameter userID cannot be empty")
354	}
355	urlPath = strings.ReplaceAll(urlPath, "{userId}", url.PathEscape(userID))
356	if client.subscriptionID == "" {
357		return nil, errors.New("parameter client.subscriptionID cannot be empty")
358	}
359	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
360	req, err := azcore.NewRequest(ctx, http.MethodHead, azcore.JoinPaths(client.con.Endpoint(), urlPath))
361	if err != nil {
362		return nil, err
363	}
364	req.Telemetry(telemetryInfo)
365	reqQP := req.URL.Query()
366	reqQP.Set("api-version", "2020-12-01")
367	req.URL.RawQuery = reqQP.Encode()
368	req.Header.Set("Accept", "application/json")
369	return req, nil
370}
371
372// getEntityTagHandleResponse handles the GetEntityTag response.
373func (client *UserClient) getEntityTagHandleResponse(resp *azcore.Response) (UserGetEntityTagResponse, error) {
374	result := UserGetEntityTagResponse{RawResponse: resp.Response}
375	if val := resp.Header.Get("ETag"); val != "" {
376		result.ETag = &val
377	}
378	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
379		result.Success = true
380	}
381	return result, nil
382}
383
384// GetSharedAccessToken - Gets the Shared Access Authorization Token for the User.
385// If the operation fails it returns the *ErrorResponse error type.
386func (client *UserClient) GetSharedAccessToken(ctx context.Context, resourceGroupName string, serviceName string, userID string, parameters UserTokenParameters, options *UserGetSharedAccessTokenOptions) (UserGetSharedAccessTokenResponse, error) {
387	req, err := client.getSharedAccessTokenCreateRequest(ctx, resourceGroupName, serviceName, userID, parameters, options)
388	if err != nil {
389		return UserGetSharedAccessTokenResponse{}, err
390	}
391	resp, err := client.con.Pipeline().Do(req)
392	if err != nil {
393		return UserGetSharedAccessTokenResponse{}, err
394	}
395	if !resp.HasStatusCode(http.StatusOK) {
396		return UserGetSharedAccessTokenResponse{}, client.getSharedAccessTokenHandleError(resp)
397	}
398	return client.getSharedAccessTokenHandleResponse(resp)
399}
400
401// getSharedAccessTokenCreateRequest creates the GetSharedAccessToken request.
402func (client *UserClient) getSharedAccessTokenCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, userID string, parameters UserTokenParameters, options *UserGetSharedAccessTokenOptions) (*azcore.Request, error) {
403	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/users/{userId}/token"
404	if resourceGroupName == "" {
405		return nil, errors.New("parameter resourceGroupName cannot be empty")
406	}
407	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
408	if serviceName == "" {
409		return nil, errors.New("parameter serviceName cannot be empty")
410	}
411	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
412	if userID == "" {
413		return nil, errors.New("parameter userID cannot be empty")
414	}
415	urlPath = strings.ReplaceAll(urlPath, "{userId}", url.PathEscape(userID))
416	if client.subscriptionID == "" {
417		return nil, errors.New("parameter client.subscriptionID cannot be empty")
418	}
419	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
420	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
421	if err != nil {
422		return nil, err
423	}
424	req.Telemetry(telemetryInfo)
425	reqQP := req.URL.Query()
426	reqQP.Set("api-version", "2020-12-01")
427	req.URL.RawQuery = reqQP.Encode()
428	req.Header.Set("Accept", "application/json")
429	return req, req.MarshalAsJSON(parameters)
430}
431
432// getSharedAccessTokenHandleResponse handles the GetSharedAccessToken response.
433func (client *UserClient) getSharedAccessTokenHandleResponse(resp *azcore.Response) (UserGetSharedAccessTokenResponse, error) {
434	result := UserGetSharedAccessTokenResponse{RawResponse: resp.Response}
435	if err := resp.UnmarshalAsJSON(&result.UserTokenResult); err != nil {
436		return UserGetSharedAccessTokenResponse{}, err
437	}
438	return result, nil
439}
440
441// getSharedAccessTokenHandleError handles the GetSharedAccessToken error response.
442func (client *UserClient) getSharedAccessTokenHandleError(resp *azcore.Response) error {
443	body, err := resp.Payload()
444	if err != nil {
445		return azcore.NewResponseError(err, resp.Response)
446	}
447	errType := ErrorResponse{raw: string(body)}
448	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
449		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
450	}
451	return azcore.NewResponseError(&errType, resp.Response)
452}
453
454// ListByService - Lists a collection of registered users in the specified service instance.
455// If the operation fails it returns the *ErrorResponse error type.
456func (client *UserClient) ListByService(resourceGroupName string, serviceName string, options *UserListByServiceOptions) UserListByServicePager {
457	return &userListByServicePager{
458		client: client,
459		requester: func(ctx context.Context) (*azcore.Request, error) {
460			return client.listByServiceCreateRequest(ctx, resourceGroupName, serviceName, options)
461		},
462		advancer: func(ctx context.Context, resp UserListByServiceResponse) (*azcore.Request, error) {
463			return azcore.NewRequest(ctx, http.MethodGet, *resp.UserCollection.NextLink)
464		},
465	}
466}
467
468// listByServiceCreateRequest creates the ListByService request.
469func (client *UserClient) listByServiceCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, options *UserListByServiceOptions) (*azcore.Request, error) {
470	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/users"
471	if resourceGroupName == "" {
472		return nil, errors.New("parameter resourceGroupName cannot be empty")
473	}
474	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
475	if serviceName == "" {
476		return nil, errors.New("parameter serviceName cannot be empty")
477	}
478	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
479	if client.subscriptionID == "" {
480		return nil, errors.New("parameter client.subscriptionID cannot be empty")
481	}
482	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
483	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
484	if err != nil {
485		return nil, err
486	}
487	req.Telemetry(telemetryInfo)
488	reqQP := req.URL.Query()
489	if options != nil && options.Filter != nil {
490		reqQP.Set("$filter", *options.Filter)
491	}
492	if options != nil && options.Top != nil {
493		reqQP.Set("$top", strconv.FormatInt(int64(*options.Top), 10))
494	}
495	if options != nil && options.Skip != nil {
496		reqQP.Set("$skip", strconv.FormatInt(int64(*options.Skip), 10))
497	}
498	if options != nil && options.ExpandGroups != nil {
499		reqQP.Set("expandGroups", strconv.FormatBool(*options.ExpandGroups))
500	}
501	reqQP.Set("api-version", "2020-12-01")
502	req.URL.RawQuery = reqQP.Encode()
503	req.Header.Set("Accept", "application/json")
504	return req, nil
505}
506
507// listByServiceHandleResponse handles the ListByService response.
508func (client *UserClient) listByServiceHandleResponse(resp *azcore.Response) (UserListByServiceResponse, error) {
509	result := UserListByServiceResponse{RawResponse: resp.Response}
510	if err := resp.UnmarshalAsJSON(&result.UserCollection); err != nil {
511		return UserListByServiceResponse{}, err
512	}
513	return result, nil
514}
515
516// listByServiceHandleError handles the ListByService error response.
517func (client *UserClient) listByServiceHandleError(resp *azcore.Response) error {
518	body, err := resp.Payload()
519	if err != nil {
520		return azcore.NewResponseError(err, resp.Response)
521	}
522	errType := ErrorResponse{raw: string(body)}
523	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
524		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
525	}
526	return azcore.NewResponseError(&errType, resp.Response)
527}
528
529// Update - Updates the details of the user specified by its identifier.
530// If the operation fails it returns the *ErrorResponse error type.
531func (client *UserClient) Update(ctx context.Context, resourceGroupName string, serviceName string, userID string, ifMatch string, parameters UserUpdateParameters, options *UserUpdateOptions) (UserUpdateResponse, error) {
532	req, err := client.updateCreateRequest(ctx, resourceGroupName, serviceName, userID, ifMatch, parameters, options)
533	if err != nil {
534		return UserUpdateResponse{}, err
535	}
536	resp, err := client.con.Pipeline().Do(req)
537	if err != nil {
538		return UserUpdateResponse{}, err
539	}
540	if !resp.HasStatusCode(http.StatusOK) {
541		return UserUpdateResponse{}, client.updateHandleError(resp)
542	}
543	return client.updateHandleResponse(resp)
544}
545
546// updateCreateRequest creates the Update request.
547func (client *UserClient) updateCreateRequest(ctx context.Context, resourceGroupName string, serviceName string, userID string, ifMatch string, parameters UserUpdateParameters, options *UserUpdateOptions) (*azcore.Request, error) {
548	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ApiManagement/service/{serviceName}/users/{userId}"
549	if resourceGroupName == "" {
550		return nil, errors.New("parameter resourceGroupName cannot be empty")
551	}
552	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
553	if serviceName == "" {
554		return nil, errors.New("parameter serviceName cannot be empty")
555	}
556	urlPath = strings.ReplaceAll(urlPath, "{serviceName}", url.PathEscape(serviceName))
557	if userID == "" {
558		return nil, errors.New("parameter userID cannot be empty")
559	}
560	urlPath = strings.ReplaceAll(urlPath, "{userId}", url.PathEscape(userID))
561	if client.subscriptionID == "" {
562		return nil, errors.New("parameter client.subscriptionID cannot be empty")
563	}
564	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
565	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
566	if err != nil {
567		return nil, err
568	}
569	req.Telemetry(telemetryInfo)
570	reqQP := req.URL.Query()
571	reqQP.Set("api-version", "2020-12-01")
572	req.URL.RawQuery = reqQP.Encode()
573	req.Header.Set("If-Match", ifMatch)
574	req.Header.Set("Accept", "application/json")
575	return req, req.MarshalAsJSON(parameters)
576}
577
578// updateHandleResponse handles the Update response.
579func (client *UserClient) updateHandleResponse(resp *azcore.Response) (UserUpdateResponse, error) {
580	result := UserUpdateResponse{RawResponse: resp.Response}
581	if val := resp.Header.Get("ETag"); val != "" {
582		result.ETag = &val
583	}
584	if err := resp.UnmarshalAsJSON(&result.UserContract); err != nil {
585		return UserUpdateResponse{}, err
586	}
587	return result, nil
588}
589
590// updateHandleError handles the Update error response.
591func (client *UserClient) updateHandleError(resp *azcore.Response) error {
592	body, err := resp.Payload()
593	if err != nil {
594		return azcore.NewResponseError(err, resp.Response)
595	}
596	errType := ErrorResponse{raw: string(body)}
597	if err := resp.UnmarshalAsJSON(&errType.InnerError); err != nil {
598		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
599	}
600	return azcore.NewResponseError(&errType, resp.Response)
601}
602