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 armcontainerregistry
9
10import (
11	"context"
12	"errors"
13	"fmt"
14	"github.com/Azure/azure-sdk-for-go/sdk/armcore"
15	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
16	"net/http"
17	"net/url"
18	"strings"
19	"time"
20)
21
22// TaskRunsClient contains the methods for the TaskRuns group.
23// Don't use this type directly, use NewTaskRunsClient() instead.
24type TaskRunsClient struct {
25	con            *armcore.Connection
26	subscriptionID string
27}
28
29// NewTaskRunsClient creates a new instance of TaskRunsClient with the specified values.
30func NewTaskRunsClient(con *armcore.Connection, subscriptionID string) *TaskRunsClient {
31	return &TaskRunsClient{con: con, subscriptionID: subscriptionID}
32}
33
34// BeginCreate - Creates a task run for a container registry with the specified parameters.
35// If the operation fails it returns the *ErrorResponse error type.
36func (client *TaskRunsClient) BeginCreate(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, taskRun TaskRun, options *TaskRunsBeginCreateOptions) (TaskRunPollerResponse, error) {
37	resp, err := client.create(ctx, resourceGroupName, registryName, taskRunName, taskRun, options)
38	if err != nil {
39		return TaskRunPollerResponse{}, err
40	}
41	result := TaskRunPollerResponse{
42		RawResponse: resp.Response,
43	}
44	pt, err := armcore.NewLROPoller("TaskRunsClient.Create", "", resp, client.con.Pipeline(), client.createHandleError)
45	if err != nil {
46		return TaskRunPollerResponse{}, err
47	}
48	poller := &taskRunPoller{
49		pt: pt,
50	}
51	result.Poller = poller
52	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (TaskRunResponse, error) {
53		return poller.pollUntilDone(ctx, frequency)
54	}
55	return result, nil
56}
57
58// ResumeCreate creates a new TaskRunPoller from the specified resume token.
59// token - The value must come from a previous call to TaskRunPoller.ResumeToken().
60func (client *TaskRunsClient) ResumeCreate(ctx context.Context, token string) (TaskRunPollerResponse, error) {
61	pt, err := armcore.NewLROPollerFromResumeToken("TaskRunsClient.Create", token, client.con.Pipeline(), client.createHandleError)
62	if err != nil {
63		return TaskRunPollerResponse{}, err
64	}
65	poller := &taskRunPoller{
66		pt: pt,
67	}
68	resp, err := poller.Poll(ctx)
69	if err != nil {
70		return TaskRunPollerResponse{}, err
71	}
72	result := TaskRunPollerResponse{
73		RawResponse: resp,
74	}
75	result.Poller = poller
76	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (TaskRunResponse, error) {
77		return poller.pollUntilDone(ctx, frequency)
78	}
79	return result, nil
80}
81
82// Create - Creates a task run for a container registry with the specified parameters.
83// If the operation fails it returns the *ErrorResponse error type.
84func (client *TaskRunsClient) create(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, taskRun TaskRun, options *TaskRunsBeginCreateOptions) (*azcore.Response, error) {
85	req, err := client.createCreateRequest(ctx, resourceGroupName, registryName, taskRunName, taskRun, options)
86	if err != nil {
87		return nil, err
88	}
89	resp, err := client.con.Pipeline().Do(req)
90	if err != nil {
91		return nil, err
92	}
93	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
94		return nil, client.createHandleError(resp)
95	}
96	return resp, nil
97}
98
99// createCreateRequest creates the Create request.
100func (client *TaskRunsClient) createCreateRequest(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, taskRun TaskRun, options *TaskRunsBeginCreateOptions) (*azcore.Request, error) {
101	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/taskRuns/{taskRunName}"
102	if client.subscriptionID == "" {
103		return nil, errors.New("parameter client.subscriptionID cannot be empty")
104	}
105	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
106	if resourceGroupName == "" {
107		return nil, errors.New("parameter resourceGroupName cannot be empty")
108	}
109	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
110	if registryName == "" {
111		return nil, errors.New("parameter registryName cannot be empty")
112	}
113	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
114	if taskRunName == "" {
115		return nil, errors.New("parameter taskRunName cannot be empty")
116	}
117	urlPath = strings.ReplaceAll(urlPath, "{taskRunName}", url.PathEscape(taskRunName))
118	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
119	if err != nil {
120		return nil, err
121	}
122	req.Telemetry(telemetryInfo)
123	reqQP := req.URL.Query()
124	reqQP.Set("api-version", "2019-06-01-preview")
125	req.URL.RawQuery = reqQP.Encode()
126	req.Header.Set("Accept", "application/json")
127	return req, req.MarshalAsJSON(taskRun)
128}
129
130// createHandleError handles the Create error response.
131func (client *TaskRunsClient) createHandleError(resp *azcore.Response) error {
132	body, err := resp.Payload()
133	if err != nil {
134		return azcore.NewResponseError(err, resp.Response)
135	}
136	errType := ErrorResponse{raw: string(body)}
137	if err := resp.UnmarshalAsJSON(&errType); err != nil {
138		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
139	}
140	return azcore.NewResponseError(&errType, resp.Response)
141}
142
143// BeginDelete - Deletes a specified task run resource.
144// If the operation fails it returns the *ErrorResponse error type.
145func (client *TaskRunsClient) BeginDelete(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *TaskRunsBeginDeleteOptions) (HTTPPollerResponse, error) {
146	resp, err := client.deleteOperation(ctx, resourceGroupName, registryName, taskRunName, options)
147	if err != nil {
148		return HTTPPollerResponse{}, err
149	}
150	result := HTTPPollerResponse{
151		RawResponse: resp.Response,
152	}
153	pt, err := armcore.NewLROPoller("TaskRunsClient.Delete", "", resp, client.con.Pipeline(), client.deleteHandleError)
154	if err != nil {
155		return HTTPPollerResponse{}, err
156	}
157	poller := &httpPoller{
158		pt: pt,
159	}
160	result.Poller = poller
161	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
162		return poller.pollUntilDone(ctx, frequency)
163	}
164	return result, nil
165}
166
167// ResumeDelete creates a new HTTPPoller from the specified resume token.
168// token - The value must come from a previous call to HTTPPoller.ResumeToken().
169func (client *TaskRunsClient) ResumeDelete(ctx context.Context, token string) (HTTPPollerResponse, error) {
170	pt, err := armcore.NewLROPollerFromResumeToken("TaskRunsClient.Delete", token, client.con.Pipeline(), client.deleteHandleError)
171	if err != nil {
172		return HTTPPollerResponse{}, err
173	}
174	poller := &httpPoller{
175		pt: pt,
176	}
177	resp, err := poller.Poll(ctx)
178	if err != nil {
179		return HTTPPollerResponse{}, err
180	}
181	result := HTTPPollerResponse{
182		RawResponse: resp,
183	}
184	result.Poller = poller
185	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
186		return poller.pollUntilDone(ctx, frequency)
187	}
188	return result, nil
189}
190
191// Delete - Deletes a specified task run resource.
192// If the operation fails it returns the *ErrorResponse error type.
193func (client *TaskRunsClient) deleteOperation(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *TaskRunsBeginDeleteOptions) (*azcore.Response, error) {
194	req, err := client.deleteCreateRequest(ctx, resourceGroupName, registryName, taskRunName, options)
195	if err != nil {
196		return nil, err
197	}
198	resp, err := client.con.Pipeline().Do(req)
199	if err != nil {
200		return nil, err
201	}
202	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent) {
203		return nil, client.deleteHandleError(resp)
204	}
205	return resp, nil
206}
207
208// deleteCreateRequest creates the Delete request.
209func (client *TaskRunsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *TaskRunsBeginDeleteOptions) (*azcore.Request, error) {
210	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/taskRuns/{taskRunName}"
211	if client.subscriptionID == "" {
212		return nil, errors.New("parameter client.subscriptionID cannot be empty")
213	}
214	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
215	if resourceGroupName == "" {
216		return nil, errors.New("parameter resourceGroupName cannot be empty")
217	}
218	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
219	if registryName == "" {
220		return nil, errors.New("parameter registryName cannot be empty")
221	}
222	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
223	if taskRunName == "" {
224		return nil, errors.New("parameter taskRunName cannot be empty")
225	}
226	urlPath = strings.ReplaceAll(urlPath, "{taskRunName}", url.PathEscape(taskRunName))
227	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
228	if err != nil {
229		return nil, err
230	}
231	req.Telemetry(telemetryInfo)
232	reqQP := req.URL.Query()
233	reqQP.Set("api-version", "2019-06-01-preview")
234	req.URL.RawQuery = reqQP.Encode()
235	req.Header.Set("Accept", "application/json")
236	return req, nil
237}
238
239// deleteHandleError handles the Delete error response.
240func (client *TaskRunsClient) deleteHandleError(resp *azcore.Response) error {
241	body, err := resp.Payload()
242	if err != nil {
243		return azcore.NewResponseError(err, resp.Response)
244	}
245	errType := ErrorResponse{raw: string(body)}
246	if err := resp.UnmarshalAsJSON(&errType); err != nil {
247		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
248	}
249	return azcore.NewResponseError(&errType, resp.Response)
250}
251
252// Get - Gets the detailed information for a given task run.
253// If the operation fails it returns the *ErrorResponse error type.
254func (client *TaskRunsClient) Get(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *TaskRunsGetOptions) (TaskRunResponse, error) {
255	req, err := client.getCreateRequest(ctx, resourceGroupName, registryName, taskRunName, options)
256	if err != nil {
257		return TaskRunResponse{}, err
258	}
259	resp, err := client.con.Pipeline().Do(req)
260	if err != nil {
261		return TaskRunResponse{}, err
262	}
263	if !resp.HasStatusCode(http.StatusOK) {
264		return TaskRunResponse{}, client.getHandleError(resp)
265	}
266	return client.getHandleResponse(resp)
267}
268
269// getCreateRequest creates the Get request.
270func (client *TaskRunsClient) getCreateRequest(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *TaskRunsGetOptions) (*azcore.Request, error) {
271	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/taskRuns/{taskRunName}"
272	if client.subscriptionID == "" {
273		return nil, errors.New("parameter client.subscriptionID cannot be empty")
274	}
275	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
276	if resourceGroupName == "" {
277		return nil, errors.New("parameter resourceGroupName cannot be empty")
278	}
279	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
280	if registryName == "" {
281		return nil, errors.New("parameter registryName cannot be empty")
282	}
283	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
284	if taskRunName == "" {
285		return nil, errors.New("parameter taskRunName cannot be empty")
286	}
287	urlPath = strings.ReplaceAll(urlPath, "{taskRunName}", url.PathEscape(taskRunName))
288	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
289	if err != nil {
290		return nil, err
291	}
292	req.Telemetry(telemetryInfo)
293	reqQP := req.URL.Query()
294	reqQP.Set("api-version", "2019-06-01-preview")
295	req.URL.RawQuery = reqQP.Encode()
296	req.Header.Set("Accept", "application/json")
297	return req, nil
298}
299
300// getHandleResponse handles the Get response.
301func (client *TaskRunsClient) getHandleResponse(resp *azcore.Response) (TaskRunResponse, error) {
302	var val *TaskRun
303	if err := resp.UnmarshalAsJSON(&val); err != nil {
304		return TaskRunResponse{}, err
305	}
306	return TaskRunResponse{RawResponse: resp.Response, TaskRun: val}, nil
307}
308
309// getHandleError handles the Get error response.
310func (client *TaskRunsClient) getHandleError(resp *azcore.Response) error {
311	body, err := resp.Payload()
312	if err != nil {
313		return azcore.NewResponseError(err, resp.Response)
314	}
315	errType := ErrorResponse{raw: string(body)}
316	if err := resp.UnmarshalAsJSON(&errType); err != nil {
317		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
318	}
319	return azcore.NewResponseError(&errType, resp.Response)
320}
321
322// GetDetails - Gets the detailed information for a given task run that includes all secrets.
323// If the operation fails it returns the *ErrorResponse error type.
324func (client *TaskRunsClient) GetDetails(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *TaskRunsGetDetailsOptions) (TaskRunResponse, error) {
325	req, err := client.getDetailsCreateRequest(ctx, resourceGroupName, registryName, taskRunName, options)
326	if err != nil {
327		return TaskRunResponse{}, err
328	}
329	resp, err := client.con.Pipeline().Do(req)
330	if err != nil {
331		return TaskRunResponse{}, err
332	}
333	if !resp.HasStatusCode(http.StatusOK) {
334		return TaskRunResponse{}, client.getDetailsHandleError(resp)
335	}
336	return client.getDetailsHandleResponse(resp)
337}
338
339// getDetailsCreateRequest creates the GetDetails request.
340func (client *TaskRunsClient) getDetailsCreateRequest(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, options *TaskRunsGetDetailsOptions) (*azcore.Request, error) {
341	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/taskRuns/{taskRunName}/listDetails"
342	if client.subscriptionID == "" {
343		return nil, errors.New("parameter client.subscriptionID cannot be empty")
344	}
345	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
346	if resourceGroupName == "" {
347		return nil, errors.New("parameter resourceGroupName cannot be empty")
348	}
349	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
350	if registryName == "" {
351		return nil, errors.New("parameter registryName cannot be empty")
352	}
353	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
354	if taskRunName == "" {
355		return nil, errors.New("parameter taskRunName cannot be empty")
356	}
357	urlPath = strings.ReplaceAll(urlPath, "{taskRunName}", url.PathEscape(taskRunName))
358	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
359	if err != nil {
360		return nil, err
361	}
362	req.Telemetry(telemetryInfo)
363	reqQP := req.URL.Query()
364	reqQP.Set("api-version", "2019-06-01-preview")
365	req.URL.RawQuery = reqQP.Encode()
366	req.Header.Set("Accept", "application/json")
367	return req, nil
368}
369
370// getDetailsHandleResponse handles the GetDetails response.
371func (client *TaskRunsClient) getDetailsHandleResponse(resp *azcore.Response) (TaskRunResponse, error) {
372	var val *TaskRun
373	if err := resp.UnmarshalAsJSON(&val); err != nil {
374		return TaskRunResponse{}, err
375	}
376	return TaskRunResponse{RawResponse: resp.Response, TaskRun: val}, nil
377}
378
379// getDetailsHandleError handles the GetDetails error response.
380func (client *TaskRunsClient) getDetailsHandleError(resp *azcore.Response) error {
381	body, err := resp.Payload()
382	if err != nil {
383		return azcore.NewResponseError(err, resp.Response)
384	}
385	errType := ErrorResponse{raw: string(body)}
386	if err := resp.UnmarshalAsJSON(&errType); err != nil {
387		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
388	}
389	return azcore.NewResponseError(&errType, resp.Response)
390}
391
392// List - Lists all the task runs for a specified container registry.
393// If the operation fails it returns the *ErrorResponse error type.
394func (client *TaskRunsClient) List(resourceGroupName string, registryName string, options *TaskRunsListOptions) TaskRunListResultPager {
395	return &taskRunListResultPager{
396		pipeline: client.con.Pipeline(),
397		requester: func(ctx context.Context) (*azcore.Request, error) {
398			return client.listCreateRequest(ctx, resourceGroupName, registryName, options)
399		},
400		responder: client.listHandleResponse,
401		errorer:   client.listHandleError,
402		advancer: func(ctx context.Context, resp TaskRunListResultResponse) (*azcore.Request, error) {
403			return azcore.NewRequest(ctx, http.MethodGet, *resp.TaskRunListResult.NextLink)
404		},
405		statusCodes: []int{http.StatusOK},
406	}
407}
408
409// listCreateRequest creates the List request.
410func (client *TaskRunsClient) listCreateRequest(ctx context.Context, resourceGroupName string, registryName string, options *TaskRunsListOptions) (*azcore.Request, error) {
411	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/taskRuns"
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	if resourceGroupName == "" {
417		return nil, errors.New("parameter resourceGroupName cannot be empty")
418	}
419	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
420	if registryName == "" {
421		return nil, errors.New("parameter registryName cannot be empty")
422	}
423	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
424	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
425	if err != nil {
426		return nil, err
427	}
428	req.Telemetry(telemetryInfo)
429	reqQP := req.URL.Query()
430	reqQP.Set("api-version", "2019-06-01-preview")
431	req.URL.RawQuery = reqQP.Encode()
432	req.Header.Set("Accept", "application/json")
433	return req, nil
434}
435
436// listHandleResponse handles the List response.
437func (client *TaskRunsClient) listHandleResponse(resp *azcore.Response) (TaskRunListResultResponse, error) {
438	var val *TaskRunListResult
439	if err := resp.UnmarshalAsJSON(&val); err != nil {
440		return TaskRunListResultResponse{}, err
441	}
442	return TaskRunListResultResponse{RawResponse: resp.Response, TaskRunListResult: val}, nil
443}
444
445// listHandleError handles the List error response.
446func (client *TaskRunsClient) listHandleError(resp *azcore.Response) error {
447	body, err := resp.Payload()
448	if err != nil {
449		return azcore.NewResponseError(err, resp.Response)
450	}
451	errType := ErrorResponse{raw: string(body)}
452	if err := resp.UnmarshalAsJSON(&errType); err != nil {
453		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
454	}
455	return azcore.NewResponseError(&errType, resp.Response)
456}
457
458// BeginUpdate - Updates a task run with the specified parameters.
459// If the operation fails it returns the *ErrorResponse error type.
460func (client *TaskRunsClient) BeginUpdate(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, updateParameters TaskRunUpdateParameters, options *TaskRunsBeginUpdateOptions) (TaskRunPollerResponse, error) {
461	resp, err := client.update(ctx, resourceGroupName, registryName, taskRunName, updateParameters, options)
462	if err != nil {
463		return TaskRunPollerResponse{}, err
464	}
465	result := TaskRunPollerResponse{
466		RawResponse: resp.Response,
467	}
468	pt, err := armcore.NewLROPoller("TaskRunsClient.Update", "", resp, client.con.Pipeline(), client.updateHandleError)
469	if err != nil {
470		return TaskRunPollerResponse{}, err
471	}
472	poller := &taskRunPoller{
473		pt: pt,
474	}
475	result.Poller = poller
476	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (TaskRunResponse, error) {
477		return poller.pollUntilDone(ctx, frequency)
478	}
479	return result, nil
480}
481
482// ResumeUpdate creates a new TaskRunPoller from the specified resume token.
483// token - The value must come from a previous call to TaskRunPoller.ResumeToken().
484func (client *TaskRunsClient) ResumeUpdate(ctx context.Context, token string) (TaskRunPollerResponse, error) {
485	pt, err := armcore.NewLROPollerFromResumeToken("TaskRunsClient.Update", token, client.con.Pipeline(), client.updateHandleError)
486	if err != nil {
487		return TaskRunPollerResponse{}, err
488	}
489	poller := &taskRunPoller{
490		pt: pt,
491	}
492	resp, err := poller.Poll(ctx)
493	if err != nil {
494		return TaskRunPollerResponse{}, err
495	}
496	result := TaskRunPollerResponse{
497		RawResponse: resp,
498	}
499	result.Poller = poller
500	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (TaskRunResponse, error) {
501		return poller.pollUntilDone(ctx, frequency)
502	}
503	return result, nil
504}
505
506// Update - Updates a task run with the specified parameters.
507// If the operation fails it returns the *ErrorResponse error type.
508func (client *TaskRunsClient) update(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, updateParameters TaskRunUpdateParameters, options *TaskRunsBeginUpdateOptions) (*azcore.Response, error) {
509	req, err := client.updateCreateRequest(ctx, resourceGroupName, registryName, taskRunName, updateParameters, options)
510	if err != nil {
511		return nil, err
512	}
513	resp, err := client.con.Pipeline().Do(req)
514	if err != nil {
515		return nil, err
516	}
517	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
518		return nil, client.updateHandleError(resp)
519	}
520	return resp, nil
521}
522
523// updateCreateRequest creates the Update request.
524func (client *TaskRunsClient) updateCreateRequest(ctx context.Context, resourceGroupName string, registryName string, taskRunName string, updateParameters TaskRunUpdateParameters, options *TaskRunsBeginUpdateOptions) (*azcore.Request, error) {
525	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/taskRuns/{taskRunName}"
526	if client.subscriptionID == "" {
527		return nil, errors.New("parameter client.subscriptionID cannot be empty")
528	}
529	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
530	if resourceGroupName == "" {
531		return nil, errors.New("parameter resourceGroupName cannot be empty")
532	}
533	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
534	if registryName == "" {
535		return nil, errors.New("parameter registryName cannot be empty")
536	}
537	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
538	if taskRunName == "" {
539		return nil, errors.New("parameter taskRunName cannot be empty")
540	}
541	urlPath = strings.ReplaceAll(urlPath, "{taskRunName}", url.PathEscape(taskRunName))
542	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
543	if err != nil {
544		return nil, err
545	}
546	req.Telemetry(telemetryInfo)
547	reqQP := req.URL.Query()
548	reqQP.Set("api-version", "2019-06-01-preview")
549	req.URL.RawQuery = reqQP.Encode()
550	req.Header.Set("Accept", "application/json")
551	return req, req.MarshalAsJSON(updateParameters)
552}
553
554// updateHandleError handles the Update error response.
555func (client *TaskRunsClient) updateHandleError(resp *azcore.Response) error {
556	body, err := resp.Payload()
557	if err != nil {
558		return azcore.NewResponseError(err, resp.Response)
559	}
560	errType := ErrorResponse{raw: string(body)}
561	if err := resp.UnmarshalAsJSON(&errType); err != nil {
562		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
563	}
564	return azcore.NewResponseError(&errType, resp.Response)
565}
566