1package confluent
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//
6// Code generated by Microsoft (R) AutoRest Code Generator.
7// Changes may cause incorrect behavior and will be lost if the code is regenerated.
8
9import (
10	"context"
11	"github.com/Azure/go-autorest/autorest"
12	"github.com/Azure/go-autorest/autorest/azure"
13	"github.com/Azure/go-autorest/tracing"
14	"net/http"
15)
16
17// OrganizationClient is the client for the Organization methods of the Confluent service.
18type OrganizationClient struct {
19	BaseClient
20}
21
22// NewOrganizationClient creates an instance of the OrganizationClient client.
23func NewOrganizationClient(subscriptionID string) OrganizationClient {
24	return NewOrganizationClientWithBaseURI(DefaultBaseURI, subscriptionID)
25}
26
27// NewOrganizationClientWithBaseURI creates an instance of the OrganizationClient client using a custom endpoint.  Use
28// this when interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack).
29func NewOrganizationClientWithBaseURI(baseURI string, subscriptionID string) OrganizationClient {
30	return OrganizationClient{NewWithBaseURI(baseURI, subscriptionID)}
31}
32
33// Create sends the create request.
34// Parameters:
35// resourceGroupName - resource group name
36// organizationName - organization resource name
37// body - organization resource model
38func (client OrganizationClient) Create(ctx context.Context, resourceGroupName string, organizationName string, body *OrganizationResource) (result OrganizationCreateFuture, err error) {
39	if tracing.IsEnabled() {
40		ctx = tracing.StartSpan(ctx, fqdn+"/OrganizationClient.Create")
41		defer func() {
42			sc := -1
43			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
44				sc = result.FutureAPI.Response().StatusCode
45			}
46			tracing.EndSpan(ctx, sc, err)
47		}()
48	}
49	req, err := client.CreatePreparer(ctx, resourceGroupName, organizationName, body)
50	if err != nil {
51		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Create", nil, "Failure preparing request")
52		return
53	}
54
55	result, err = client.CreateSender(req)
56	if err != nil {
57		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Create", nil, "Failure sending request")
58		return
59	}
60
61	return
62}
63
64// CreatePreparer prepares the Create request.
65func (client OrganizationClient) CreatePreparer(ctx context.Context, resourceGroupName string, organizationName string, body *OrganizationResource) (*http.Request, error) {
66	pathParameters := map[string]interface{}{
67		"organizationName":  autorest.Encode("path", organizationName),
68		"resourceGroupName": autorest.Encode("path", resourceGroupName),
69		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
70	}
71
72	const APIVersion = "2020-03-01"
73	queryParameters := map[string]interface{}{
74		"api-version": APIVersion,
75	}
76
77	body.ID = nil
78	body.Name = nil
79	body.Type = nil
80	preparer := autorest.CreatePreparer(
81		autorest.AsContentType("application/json; charset=utf-8"),
82		autorest.AsPut(),
83		autorest.WithBaseURL(client.BaseURI),
84		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Confluent/organizations/{organizationName}", pathParameters),
85		autorest.WithQueryParameters(queryParameters))
86	if body != nil {
87		preparer = autorest.DecoratePreparer(preparer,
88			autorest.WithJSON(body))
89	}
90	return preparer.Prepare((&http.Request{}).WithContext(ctx))
91}
92
93// CreateSender sends the Create request. The method will close the
94// http.Response Body if it receives an error.
95func (client OrganizationClient) CreateSender(req *http.Request) (future OrganizationCreateFuture, err error) {
96	var resp *http.Response
97	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
98	if err != nil {
99		return
100	}
101	var azf azure.Future
102	azf, err = azure.NewFutureFromResponse(resp)
103	future.FutureAPI = &azf
104	future.Result = future.result
105	return
106}
107
108// CreateResponder handles the response to the Create request. The method always
109// closes the http.Response Body.
110func (client OrganizationClient) CreateResponder(resp *http.Response) (result OrganizationResource, err error) {
111	err = autorest.Respond(
112		resp,
113		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated),
114		autorest.ByUnmarshallingJSON(&result),
115		autorest.ByClosing())
116	result.Response = autorest.Response{Response: resp}
117	return
118}
119
120// Delete sends the delete request.
121// Parameters:
122// resourceGroupName - resource group name
123// organizationName - organization resource name
124func (client OrganizationClient) Delete(ctx context.Context, resourceGroupName string, organizationName string) (result OrganizationDeleteFuture, err error) {
125	if tracing.IsEnabled() {
126		ctx = tracing.StartSpan(ctx, fqdn+"/OrganizationClient.Delete")
127		defer func() {
128			sc := -1
129			if result.FutureAPI != nil && result.FutureAPI.Response() != nil {
130				sc = result.FutureAPI.Response().StatusCode
131			}
132			tracing.EndSpan(ctx, sc, err)
133		}()
134	}
135	req, err := client.DeletePreparer(ctx, resourceGroupName, organizationName)
136	if err != nil {
137		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Delete", nil, "Failure preparing request")
138		return
139	}
140
141	result, err = client.DeleteSender(req)
142	if err != nil {
143		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Delete", nil, "Failure sending request")
144		return
145	}
146
147	return
148}
149
150// DeletePreparer prepares the Delete request.
151func (client OrganizationClient) DeletePreparer(ctx context.Context, resourceGroupName string, organizationName string) (*http.Request, error) {
152	pathParameters := map[string]interface{}{
153		"organizationName":  autorest.Encode("path", organizationName),
154		"resourceGroupName": autorest.Encode("path", resourceGroupName),
155		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
156	}
157
158	const APIVersion = "2020-03-01"
159	queryParameters := map[string]interface{}{
160		"api-version": APIVersion,
161	}
162
163	preparer := autorest.CreatePreparer(
164		autorest.AsDelete(),
165		autorest.WithBaseURL(client.BaseURI),
166		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Confluent/organizations/{organizationName}", pathParameters),
167		autorest.WithQueryParameters(queryParameters))
168	return preparer.Prepare((&http.Request{}).WithContext(ctx))
169}
170
171// DeleteSender sends the Delete request. The method will close the
172// http.Response Body if it receives an error.
173func (client OrganizationClient) DeleteSender(req *http.Request) (future OrganizationDeleteFuture, err error) {
174	var resp *http.Response
175	resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client))
176	if err != nil {
177		return
178	}
179	var azf azure.Future
180	azf, err = azure.NewFutureFromResponse(resp)
181	future.FutureAPI = &azf
182	future.Result = future.result
183	return
184}
185
186// DeleteResponder handles the response to the Delete request. The method always
187// closes the http.Response Body.
188func (client OrganizationClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) {
189	err = autorest.Respond(
190		resp,
191		azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent),
192		autorest.ByClosing())
193	result.Response = resp
194	return
195}
196
197// Get sends the get request.
198// Parameters:
199// resourceGroupName - resource group name
200// organizationName - organization resource name
201func (client OrganizationClient) Get(ctx context.Context, resourceGroupName string, organizationName string) (result OrganizationResource, err error) {
202	if tracing.IsEnabled() {
203		ctx = tracing.StartSpan(ctx, fqdn+"/OrganizationClient.Get")
204		defer func() {
205			sc := -1
206			if result.Response.Response != nil {
207				sc = result.Response.Response.StatusCode
208			}
209			tracing.EndSpan(ctx, sc, err)
210		}()
211	}
212	req, err := client.GetPreparer(ctx, resourceGroupName, organizationName)
213	if err != nil {
214		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Get", nil, "Failure preparing request")
215		return
216	}
217
218	resp, err := client.GetSender(req)
219	if err != nil {
220		result.Response = autorest.Response{Response: resp}
221		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Get", resp, "Failure sending request")
222		return
223	}
224
225	result, err = client.GetResponder(resp)
226	if err != nil {
227		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Get", resp, "Failure responding to request")
228		return
229	}
230
231	return
232}
233
234// GetPreparer prepares the Get request.
235func (client OrganizationClient) GetPreparer(ctx context.Context, resourceGroupName string, organizationName string) (*http.Request, error) {
236	pathParameters := map[string]interface{}{
237		"organizationName":  autorest.Encode("path", organizationName),
238		"resourceGroupName": autorest.Encode("path", resourceGroupName),
239		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
240	}
241
242	const APIVersion = "2020-03-01"
243	queryParameters := map[string]interface{}{
244		"api-version": APIVersion,
245	}
246
247	preparer := autorest.CreatePreparer(
248		autorest.AsGet(),
249		autorest.WithBaseURL(client.BaseURI),
250		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Confluent/organizations/{organizationName}", pathParameters),
251		autorest.WithQueryParameters(queryParameters))
252	return preparer.Prepare((&http.Request{}).WithContext(ctx))
253}
254
255// GetSender sends the Get request. The method will close the
256// http.Response Body if it receives an error.
257func (client OrganizationClient) GetSender(req *http.Request) (*http.Response, error) {
258	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
259}
260
261// GetResponder handles the response to the Get request. The method always
262// closes the http.Response Body.
263func (client OrganizationClient) GetResponder(resp *http.Response) (result OrganizationResource, err error) {
264	err = autorest.Respond(
265		resp,
266		azure.WithErrorUnlessStatusCode(http.StatusOK),
267		autorest.ByUnmarshallingJSON(&result),
268		autorest.ByClosing())
269	result.Response = autorest.Response{Response: resp}
270	return
271}
272
273// ListByResourceGroup sends the list by resource group request.
274// Parameters:
275// resourceGroupName - resource group name
276func (client OrganizationClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result OrganizationResourceListResultPage, err error) {
277	if tracing.IsEnabled() {
278		ctx = tracing.StartSpan(ctx, fqdn+"/OrganizationClient.ListByResourceGroup")
279		defer func() {
280			sc := -1
281			if result.orlr.Response.Response != nil {
282				sc = result.orlr.Response.Response.StatusCode
283			}
284			tracing.EndSpan(ctx, sc, err)
285		}()
286	}
287	result.fn = client.listByResourceGroupNextResults
288	req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName)
289	if err != nil {
290		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "ListByResourceGroup", nil, "Failure preparing request")
291		return
292	}
293
294	resp, err := client.ListByResourceGroupSender(req)
295	if err != nil {
296		result.orlr.Response = autorest.Response{Response: resp}
297		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "ListByResourceGroup", resp, "Failure sending request")
298		return
299	}
300
301	result.orlr, err = client.ListByResourceGroupResponder(resp)
302	if err != nil {
303		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "ListByResourceGroup", resp, "Failure responding to request")
304		return
305	}
306	if result.orlr.hasNextLink() && result.orlr.IsEmpty() {
307		err = result.NextWithContext(ctx)
308		return
309	}
310
311	return
312}
313
314// ListByResourceGroupPreparer prepares the ListByResourceGroup request.
315func (client OrganizationClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) {
316	pathParameters := map[string]interface{}{
317		"resourceGroupName": autorest.Encode("path", resourceGroupName),
318		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
319	}
320
321	const APIVersion = "2020-03-01"
322	queryParameters := map[string]interface{}{
323		"api-version": APIVersion,
324	}
325
326	preparer := autorest.CreatePreparer(
327		autorest.AsGet(),
328		autorest.WithBaseURL(client.BaseURI),
329		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Confluent/organizations", pathParameters),
330		autorest.WithQueryParameters(queryParameters))
331	return preparer.Prepare((&http.Request{}).WithContext(ctx))
332}
333
334// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the
335// http.Response Body if it receives an error.
336func (client OrganizationClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) {
337	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
338}
339
340// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always
341// closes the http.Response Body.
342func (client OrganizationClient) ListByResourceGroupResponder(resp *http.Response) (result OrganizationResourceListResult, err error) {
343	err = autorest.Respond(
344		resp,
345		azure.WithErrorUnlessStatusCode(http.StatusOK),
346		autorest.ByUnmarshallingJSON(&result),
347		autorest.ByClosing())
348	result.Response = autorest.Response{Response: resp}
349	return
350}
351
352// listByResourceGroupNextResults retrieves the next set of results, if any.
353func (client OrganizationClient) listByResourceGroupNextResults(ctx context.Context, lastResults OrganizationResourceListResult) (result OrganizationResourceListResult, err error) {
354	req, err := lastResults.organizationResourceListResultPreparer(ctx)
355	if err != nil {
356		return result, autorest.NewErrorWithError(err, "confluent.OrganizationClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request")
357	}
358	if req == nil {
359		return
360	}
361	resp, err := client.ListByResourceGroupSender(req)
362	if err != nil {
363		result.Response = autorest.Response{Response: resp}
364		return result, autorest.NewErrorWithError(err, "confluent.OrganizationClient", "listByResourceGroupNextResults", resp, "Failure sending next results request")
365	}
366	result, err = client.ListByResourceGroupResponder(resp)
367	if err != nil {
368		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request")
369	}
370	return
371}
372
373// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required.
374func (client OrganizationClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result OrganizationResourceListResultIterator, err error) {
375	if tracing.IsEnabled() {
376		ctx = tracing.StartSpan(ctx, fqdn+"/OrganizationClient.ListByResourceGroup")
377		defer func() {
378			sc := -1
379			if result.Response().Response.Response != nil {
380				sc = result.page.Response().Response.Response.StatusCode
381			}
382			tracing.EndSpan(ctx, sc, err)
383		}()
384	}
385	result.page, err = client.ListByResourceGroup(ctx, resourceGroupName)
386	return
387}
388
389// ListBySubscription sends the list by subscription request.
390func (client OrganizationClient) ListBySubscription(ctx context.Context) (result OrganizationResourceListResultPage, err error) {
391	if tracing.IsEnabled() {
392		ctx = tracing.StartSpan(ctx, fqdn+"/OrganizationClient.ListBySubscription")
393		defer func() {
394			sc := -1
395			if result.orlr.Response.Response != nil {
396				sc = result.orlr.Response.Response.StatusCode
397			}
398			tracing.EndSpan(ctx, sc, err)
399		}()
400	}
401	result.fn = client.listBySubscriptionNextResults
402	req, err := client.ListBySubscriptionPreparer(ctx)
403	if err != nil {
404		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "ListBySubscription", nil, "Failure preparing request")
405		return
406	}
407
408	resp, err := client.ListBySubscriptionSender(req)
409	if err != nil {
410		result.orlr.Response = autorest.Response{Response: resp}
411		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "ListBySubscription", resp, "Failure sending request")
412		return
413	}
414
415	result.orlr, err = client.ListBySubscriptionResponder(resp)
416	if err != nil {
417		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "ListBySubscription", resp, "Failure responding to request")
418		return
419	}
420	if result.orlr.hasNextLink() && result.orlr.IsEmpty() {
421		err = result.NextWithContext(ctx)
422		return
423	}
424
425	return
426}
427
428// ListBySubscriptionPreparer prepares the ListBySubscription request.
429func (client OrganizationClient) ListBySubscriptionPreparer(ctx context.Context) (*http.Request, error) {
430	pathParameters := map[string]interface{}{
431		"subscriptionId": autorest.Encode("path", client.SubscriptionID),
432	}
433
434	const APIVersion = "2020-03-01"
435	queryParameters := map[string]interface{}{
436		"api-version": APIVersion,
437	}
438
439	preparer := autorest.CreatePreparer(
440		autorest.AsGet(),
441		autorest.WithBaseURL(client.BaseURI),
442		autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Confluent/organizations", pathParameters),
443		autorest.WithQueryParameters(queryParameters))
444	return preparer.Prepare((&http.Request{}).WithContext(ctx))
445}
446
447// ListBySubscriptionSender sends the ListBySubscription request. The method will close the
448// http.Response Body if it receives an error.
449func (client OrganizationClient) ListBySubscriptionSender(req *http.Request) (*http.Response, error) {
450	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
451}
452
453// ListBySubscriptionResponder handles the response to the ListBySubscription request. The method always
454// closes the http.Response Body.
455func (client OrganizationClient) ListBySubscriptionResponder(resp *http.Response) (result OrganizationResourceListResult, err error) {
456	err = autorest.Respond(
457		resp,
458		azure.WithErrorUnlessStatusCode(http.StatusOK),
459		autorest.ByUnmarshallingJSON(&result),
460		autorest.ByClosing())
461	result.Response = autorest.Response{Response: resp}
462	return
463}
464
465// listBySubscriptionNextResults retrieves the next set of results, if any.
466func (client OrganizationClient) listBySubscriptionNextResults(ctx context.Context, lastResults OrganizationResourceListResult) (result OrganizationResourceListResult, err error) {
467	req, err := lastResults.organizationResourceListResultPreparer(ctx)
468	if err != nil {
469		return result, autorest.NewErrorWithError(err, "confluent.OrganizationClient", "listBySubscriptionNextResults", nil, "Failure preparing next results request")
470	}
471	if req == nil {
472		return
473	}
474	resp, err := client.ListBySubscriptionSender(req)
475	if err != nil {
476		result.Response = autorest.Response{Response: resp}
477		return result, autorest.NewErrorWithError(err, "confluent.OrganizationClient", "listBySubscriptionNextResults", resp, "Failure sending next results request")
478	}
479	result, err = client.ListBySubscriptionResponder(resp)
480	if err != nil {
481		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "listBySubscriptionNextResults", resp, "Failure responding to next results request")
482	}
483	return
484}
485
486// ListBySubscriptionComplete enumerates all values, automatically crossing page boundaries as required.
487func (client OrganizationClient) ListBySubscriptionComplete(ctx context.Context) (result OrganizationResourceListResultIterator, err error) {
488	if tracing.IsEnabled() {
489		ctx = tracing.StartSpan(ctx, fqdn+"/OrganizationClient.ListBySubscription")
490		defer func() {
491			sc := -1
492			if result.Response().Response.Response != nil {
493				sc = result.page.Response().Response.Response.StatusCode
494			}
495			tracing.EndSpan(ctx, sc, err)
496		}()
497	}
498	result.page, err = client.ListBySubscription(ctx)
499	return
500}
501
502// Update sends the update request.
503// Parameters:
504// resourceGroupName - resource group name
505// organizationName - organization resource name
506// body - updated Organization resource
507func (client OrganizationClient) Update(ctx context.Context, resourceGroupName string, organizationName string, body *OrganizationResourceUpdate) (result OrganizationResource, err error) {
508	if tracing.IsEnabled() {
509		ctx = tracing.StartSpan(ctx, fqdn+"/OrganizationClient.Update")
510		defer func() {
511			sc := -1
512			if result.Response.Response != nil {
513				sc = result.Response.Response.StatusCode
514			}
515			tracing.EndSpan(ctx, sc, err)
516		}()
517	}
518	req, err := client.UpdatePreparer(ctx, resourceGroupName, organizationName, body)
519	if err != nil {
520		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Update", nil, "Failure preparing request")
521		return
522	}
523
524	resp, err := client.UpdateSender(req)
525	if err != nil {
526		result.Response = autorest.Response{Response: resp}
527		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Update", resp, "Failure sending request")
528		return
529	}
530
531	result, err = client.UpdateResponder(resp)
532	if err != nil {
533		err = autorest.NewErrorWithError(err, "confluent.OrganizationClient", "Update", resp, "Failure responding to request")
534		return
535	}
536
537	return
538}
539
540// UpdatePreparer prepares the Update request.
541func (client OrganizationClient) UpdatePreparer(ctx context.Context, resourceGroupName string, organizationName string, body *OrganizationResourceUpdate) (*http.Request, error) {
542	pathParameters := map[string]interface{}{
543		"organizationName":  autorest.Encode("path", organizationName),
544		"resourceGroupName": autorest.Encode("path", resourceGroupName),
545		"subscriptionId":    autorest.Encode("path", client.SubscriptionID),
546	}
547
548	const APIVersion = "2020-03-01"
549	queryParameters := map[string]interface{}{
550		"api-version": APIVersion,
551	}
552
553	preparer := autorest.CreatePreparer(
554		autorest.AsContentType("application/json; charset=utf-8"),
555		autorest.AsPatch(),
556		autorest.WithBaseURL(client.BaseURI),
557		autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Confluent/organizations/{organizationName}", pathParameters),
558		autorest.WithQueryParameters(queryParameters))
559	if body != nil {
560		preparer = autorest.DecoratePreparer(preparer,
561			autorest.WithJSON(body))
562	}
563	return preparer.Prepare((&http.Request{}).WithContext(ctx))
564}
565
566// UpdateSender sends the Update request. The method will close the
567// http.Response Body if it receives an error.
568func (client OrganizationClient) UpdateSender(req *http.Request) (*http.Response, error) {
569	return client.Send(req, azure.DoRetryWithRegistration(client.Client))
570}
571
572// UpdateResponder handles the response to the Update request. The method always
573// closes the http.Response Body.
574func (client OrganizationClient) UpdateResponder(resp *http.Response) (result OrganizationResource, err error) {
575	err = autorest.Respond(
576		resp,
577		azure.WithErrorUnlessStatusCode(http.StatusOK),
578		autorest.ByUnmarshallingJSON(&result),
579		autorest.ByClosing())
580	result.Response = autorest.Response{Response: resp}
581	return
582}
583