1package graphrbac 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/autorest/to" 14 "github.com/Azure/go-autorest/autorest/validation" 15 "github.com/Azure/go-autorest/tracing" 16 "net/http" 17) 18 19// GroupsClient is the the Graph RBAC Management Client 20type GroupsClient struct { 21 BaseClient 22} 23 24// NewGroupsClient creates an instance of the GroupsClient client. 25func NewGroupsClient(tenantID string) GroupsClient { 26 return NewGroupsClientWithBaseURI(DefaultBaseURI, tenantID) 27} 28 29// NewGroupsClientWithBaseURI creates an instance of the GroupsClient client using a custom endpoint. Use this when 30// interacting with an Azure cloud that uses a non-standard base URI (sovereign clouds, Azure stack). 31func NewGroupsClientWithBaseURI(baseURI string, tenantID string) GroupsClient { 32 return GroupsClient{NewWithBaseURI(baseURI, tenantID)} 33} 34 35// AddMember add a member to a group. 36// Parameters: 37// groupObjectID - the object ID of the group to which to add the member. 38// parameters - the URL of the member object, such as 39// https://graph.windows.net/0b1f9851-1bf0-433f-aec3-cb9272f093dc/directoryObjects/f260bbc4-c254-447b-94cf-293b5ec434dd. 40func (client GroupsClient) AddMember(ctx context.Context, groupObjectID string, parameters GroupAddMemberParameters) (result autorest.Response, err error) { 41 if tracing.IsEnabled() { 42 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.AddMember") 43 defer func() { 44 sc := -1 45 if result.Response != nil { 46 sc = result.Response.StatusCode 47 } 48 tracing.EndSpan(ctx, sc, err) 49 }() 50 } 51 if err := validation.Validate([]validation.Validation{ 52 {TargetValue: parameters, 53 Constraints: []validation.Constraint{{Target: "parameters.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 54 return result, validation.NewError("graphrbac.GroupsClient", "AddMember", err.Error()) 55 } 56 57 req, err := client.AddMemberPreparer(ctx, groupObjectID, parameters) 58 if err != nil { 59 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "AddMember", nil, "Failure preparing request") 60 return 61 } 62 63 resp, err := client.AddMemberSender(req) 64 if err != nil { 65 result.Response = resp 66 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "AddMember", resp, "Failure sending request") 67 return 68 } 69 70 result, err = client.AddMemberResponder(resp) 71 if err != nil { 72 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "AddMember", resp, "Failure responding to request") 73 return 74 } 75 76 return 77} 78 79// AddMemberPreparer prepares the AddMember request. 80func (client GroupsClient) AddMemberPreparer(ctx context.Context, groupObjectID string, parameters GroupAddMemberParameters) (*http.Request, error) { 81 pathParameters := map[string]interface{}{ 82 "groupObjectId": autorest.Encode("path", groupObjectID), 83 "tenantID": autorest.Encode("path", client.TenantID), 84 } 85 86 const APIVersion = "1.6" 87 queryParameters := map[string]interface{}{ 88 "api-version": APIVersion, 89 } 90 91 preparer := autorest.CreatePreparer( 92 autorest.AsContentType("application/json; charset=utf-8"), 93 autorest.AsPost(), 94 autorest.WithBaseURL(client.BaseURI), 95 autorest.WithPathParameters("/{tenantID}/groups/{groupObjectId}/$links/members", pathParameters), 96 autorest.WithJSON(parameters), 97 autorest.WithQueryParameters(queryParameters)) 98 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 99} 100 101// AddMemberSender sends the AddMember request. The method will close the 102// http.Response Body if it receives an error. 103func (client GroupsClient) AddMemberSender(req *http.Request) (*http.Response, error) { 104 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 105} 106 107// AddMemberResponder handles the response to the AddMember request. The method always 108// closes the http.Response Body. 109func (client GroupsClient) AddMemberResponder(resp *http.Response) (result autorest.Response, err error) { 110 err = autorest.Respond( 111 resp, 112 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 113 autorest.ByClosing()) 114 result.Response = resp 115 return 116} 117 118// AddOwner add an owner to a group. 119// Parameters: 120// objectID - the object ID of the application to which to add the owner. 121// parameters - the URL of the owner object, such as 122// https://graph.windows.net/0b1f9851-1bf0-433f-aec3-cb9272f093dc/directoryObjects/f260bbc4-c254-447b-94cf-293b5ec434dd. 123func (client GroupsClient) AddOwner(ctx context.Context, objectID string, parameters AddOwnerParameters) (result autorest.Response, err error) { 124 if tracing.IsEnabled() { 125 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.AddOwner") 126 defer func() { 127 sc := -1 128 if result.Response != nil { 129 sc = result.Response.StatusCode 130 } 131 tracing.EndSpan(ctx, sc, err) 132 }() 133 } 134 if err := validation.Validate([]validation.Validation{ 135 {TargetValue: parameters, 136 Constraints: []validation.Constraint{{Target: "parameters.URL", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 137 return result, validation.NewError("graphrbac.GroupsClient", "AddOwner", err.Error()) 138 } 139 140 req, err := client.AddOwnerPreparer(ctx, objectID, parameters) 141 if err != nil { 142 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "AddOwner", nil, "Failure preparing request") 143 return 144 } 145 146 resp, err := client.AddOwnerSender(req) 147 if err != nil { 148 result.Response = resp 149 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "AddOwner", resp, "Failure sending request") 150 return 151 } 152 153 result, err = client.AddOwnerResponder(resp) 154 if err != nil { 155 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "AddOwner", resp, "Failure responding to request") 156 return 157 } 158 159 return 160} 161 162// AddOwnerPreparer prepares the AddOwner request. 163func (client GroupsClient) AddOwnerPreparer(ctx context.Context, objectID string, parameters AddOwnerParameters) (*http.Request, error) { 164 pathParameters := map[string]interface{}{ 165 "objectId": autorest.Encode("path", objectID), 166 "tenantID": autorest.Encode("path", client.TenantID), 167 } 168 169 const APIVersion = "1.6" 170 queryParameters := map[string]interface{}{ 171 "api-version": APIVersion, 172 } 173 174 preparer := autorest.CreatePreparer( 175 autorest.AsContentType("application/json; charset=utf-8"), 176 autorest.AsPost(), 177 autorest.WithBaseURL(client.BaseURI), 178 autorest.WithPathParameters("/{tenantID}/groups/{objectId}/$links/owners", pathParameters), 179 autorest.WithJSON(parameters), 180 autorest.WithQueryParameters(queryParameters)) 181 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 182} 183 184// AddOwnerSender sends the AddOwner request. The method will close the 185// http.Response Body if it receives an error. 186func (client GroupsClient) AddOwnerSender(req *http.Request) (*http.Response, error) { 187 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 188} 189 190// AddOwnerResponder handles the response to the AddOwner request. The method always 191// closes the http.Response Body. 192func (client GroupsClient) AddOwnerResponder(resp *http.Response) (result autorest.Response, err error) { 193 err = autorest.Respond( 194 resp, 195 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 196 autorest.ByClosing()) 197 result.Response = resp 198 return 199} 200 201// Create create a group in the directory. 202// Parameters: 203// parameters - the parameters for the group to create. 204func (client GroupsClient) Create(ctx context.Context, parameters GroupCreateParameters) (result ADGroup, err error) { 205 if tracing.IsEnabled() { 206 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.Create") 207 defer func() { 208 sc := -1 209 if result.Response.Response != nil { 210 sc = result.Response.Response.StatusCode 211 } 212 tracing.EndSpan(ctx, sc, err) 213 }() 214 } 215 if err := validation.Validate([]validation.Validation{ 216 {TargetValue: parameters, 217 Constraints: []validation.Constraint{{Target: "parameters.DisplayName", Name: validation.Null, Rule: true, Chain: nil}, 218 {Target: "parameters.MailEnabled", Name: validation.Null, Rule: true, Chain: nil}, 219 {Target: "parameters.MailNickname", Name: validation.Null, Rule: true, Chain: nil}, 220 {Target: "parameters.SecurityEnabled", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 221 return result, validation.NewError("graphrbac.GroupsClient", "Create", err.Error()) 222 } 223 224 req, err := client.CreatePreparer(ctx, parameters) 225 if err != nil { 226 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "Create", nil, "Failure preparing request") 227 return 228 } 229 230 resp, err := client.CreateSender(req) 231 if err != nil { 232 result.Response = autorest.Response{Response: resp} 233 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "Create", resp, "Failure sending request") 234 return 235 } 236 237 result, err = client.CreateResponder(resp) 238 if err != nil { 239 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "Create", resp, "Failure responding to request") 240 return 241 } 242 243 return 244} 245 246// CreatePreparer prepares the Create request. 247func (client GroupsClient) CreatePreparer(ctx context.Context, parameters GroupCreateParameters) (*http.Request, error) { 248 pathParameters := map[string]interface{}{ 249 "tenantID": autorest.Encode("path", client.TenantID), 250 } 251 252 const APIVersion = "1.6" 253 queryParameters := map[string]interface{}{ 254 "api-version": APIVersion, 255 } 256 257 preparer := autorest.CreatePreparer( 258 autorest.AsContentType("application/json; charset=utf-8"), 259 autorest.AsPost(), 260 autorest.WithBaseURL(client.BaseURI), 261 autorest.WithPathParameters("/{tenantID}/groups", pathParameters), 262 autorest.WithJSON(parameters), 263 autorest.WithQueryParameters(queryParameters)) 264 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 265} 266 267// CreateSender sends the Create request. The method will close the 268// http.Response Body if it receives an error. 269func (client GroupsClient) CreateSender(req *http.Request) (*http.Response, error) { 270 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 271} 272 273// CreateResponder handles the response to the Create request. The method always 274// closes the http.Response Body. 275func (client GroupsClient) CreateResponder(resp *http.Response) (result ADGroup, err error) { 276 err = autorest.Respond( 277 resp, 278 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusCreated), 279 autorest.ByUnmarshallingJSON(&result), 280 autorest.ByClosing()) 281 result.Response = autorest.Response{Response: resp} 282 return 283} 284 285// Delete delete a group from the directory. 286// Parameters: 287// objectID - the object ID of the group to delete. 288func (client GroupsClient) Delete(ctx context.Context, objectID string) (result autorest.Response, err error) { 289 if tracing.IsEnabled() { 290 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.Delete") 291 defer func() { 292 sc := -1 293 if result.Response != nil { 294 sc = result.Response.StatusCode 295 } 296 tracing.EndSpan(ctx, sc, err) 297 }() 298 } 299 req, err := client.DeletePreparer(ctx, objectID) 300 if err != nil { 301 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "Delete", nil, "Failure preparing request") 302 return 303 } 304 305 resp, err := client.DeleteSender(req) 306 if err != nil { 307 result.Response = resp 308 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "Delete", resp, "Failure sending request") 309 return 310 } 311 312 result, err = client.DeleteResponder(resp) 313 if err != nil { 314 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "Delete", resp, "Failure responding to request") 315 return 316 } 317 318 return 319} 320 321// DeletePreparer prepares the Delete request. 322func (client GroupsClient) DeletePreparer(ctx context.Context, objectID string) (*http.Request, error) { 323 pathParameters := map[string]interface{}{ 324 "objectId": autorest.Encode("path", objectID), 325 "tenantID": autorest.Encode("path", client.TenantID), 326 } 327 328 const APIVersion = "1.6" 329 queryParameters := map[string]interface{}{ 330 "api-version": APIVersion, 331 } 332 333 preparer := autorest.CreatePreparer( 334 autorest.AsDelete(), 335 autorest.WithBaseURL(client.BaseURI), 336 autorest.WithPathParameters("/{tenantID}/groups/{objectId}", pathParameters), 337 autorest.WithQueryParameters(queryParameters)) 338 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 339} 340 341// DeleteSender sends the Delete request. The method will close the 342// http.Response Body if it receives an error. 343func (client GroupsClient) DeleteSender(req *http.Request) (*http.Response, error) { 344 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 345} 346 347// DeleteResponder handles the response to the Delete request. The method always 348// closes the http.Response Body. 349func (client GroupsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 350 err = autorest.Respond( 351 resp, 352 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 353 autorest.ByClosing()) 354 result.Response = resp 355 return 356} 357 358// Get gets group information from the directory. 359// Parameters: 360// objectID - the object ID of the user for which to get group information. 361func (client GroupsClient) Get(ctx context.Context, objectID string) (result ADGroup, err error) { 362 if tracing.IsEnabled() { 363 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.Get") 364 defer func() { 365 sc := -1 366 if result.Response.Response != nil { 367 sc = result.Response.Response.StatusCode 368 } 369 tracing.EndSpan(ctx, sc, err) 370 }() 371 } 372 req, err := client.GetPreparer(ctx, objectID) 373 if err != nil { 374 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "Get", nil, "Failure preparing request") 375 return 376 } 377 378 resp, err := client.GetSender(req) 379 if err != nil { 380 result.Response = autorest.Response{Response: resp} 381 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "Get", resp, "Failure sending request") 382 return 383 } 384 385 result, err = client.GetResponder(resp) 386 if err != nil { 387 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "Get", resp, "Failure responding to request") 388 return 389 } 390 391 return 392} 393 394// GetPreparer prepares the Get request. 395func (client GroupsClient) GetPreparer(ctx context.Context, objectID string) (*http.Request, error) { 396 pathParameters := map[string]interface{}{ 397 "objectId": autorest.Encode("path", objectID), 398 "tenantID": autorest.Encode("path", client.TenantID), 399 } 400 401 const APIVersion = "1.6" 402 queryParameters := map[string]interface{}{ 403 "api-version": APIVersion, 404 } 405 406 preparer := autorest.CreatePreparer( 407 autorest.AsGet(), 408 autorest.WithBaseURL(client.BaseURI), 409 autorest.WithPathParameters("/{tenantID}/groups/{objectId}", pathParameters), 410 autorest.WithQueryParameters(queryParameters)) 411 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 412} 413 414// GetSender sends the Get request. The method will close the 415// http.Response Body if it receives an error. 416func (client GroupsClient) GetSender(req *http.Request) (*http.Response, error) { 417 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 418} 419 420// GetResponder handles the response to the Get request. The method always 421// closes the http.Response Body. 422func (client GroupsClient) GetResponder(resp *http.Response) (result ADGroup, err error) { 423 err = autorest.Respond( 424 resp, 425 azure.WithErrorUnlessStatusCode(http.StatusOK), 426 autorest.ByUnmarshallingJSON(&result), 427 autorest.ByClosing()) 428 result.Response = autorest.Response{Response: resp} 429 return 430} 431 432// GetGroupMembers gets the members of a group. 433// Parameters: 434// objectID - the object ID of the group whose members should be retrieved. 435func (client GroupsClient) GetGroupMembers(ctx context.Context, objectID string) (result DirectoryObjectListResultPage, err error) { 436 if tracing.IsEnabled() { 437 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.GetGroupMembers") 438 defer func() { 439 sc := -1 440 if result.dolr.Response.Response != nil { 441 sc = result.dolr.Response.Response.StatusCode 442 } 443 tracing.EndSpan(ctx, sc, err) 444 }() 445 } 446 result.fn = func(ctx context.Context, lastResult DirectoryObjectListResult) (DirectoryObjectListResult, error) { 447 if lastResult.OdataNextLink == nil || len(to.String(lastResult.OdataNextLink)) < 1 { 448 return DirectoryObjectListResult{}, nil 449 } 450 return client.GetGroupMembersNext(ctx, *lastResult.OdataNextLink) 451 } 452 req, err := client.GetGroupMembersPreparer(ctx, objectID) 453 if err != nil { 454 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "GetGroupMembers", nil, "Failure preparing request") 455 return 456 } 457 458 resp, err := client.GetGroupMembersSender(req) 459 if err != nil { 460 result.dolr.Response = autorest.Response{Response: resp} 461 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "GetGroupMembers", resp, "Failure sending request") 462 return 463 } 464 465 result.dolr, err = client.GetGroupMembersResponder(resp) 466 if err != nil { 467 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "GetGroupMembers", resp, "Failure responding to request") 468 return 469 } 470 if result.dolr.hasNextLink() && result.dolr.IsEmpty() { 471 err = result.NextWithContext(ctx) 472 return 473 } 474 475 return 476} 477 478// GetGroupMembersPreparer prepares the GetGroupMembers request. 479func (client GroupsClient) GetGroupMembersPreparer(ctx context.Context, objectID string) (*http.Request, error) { 480 pathParameters := map[string]interface{}{ 481 "objectId": autorest.Encode("path", objectID), 482 "tenantID": autorest.Encode("path", client.TenantID), 483 } 484 485 const APIVersion = "1.6" 486 queryParameters := map[string]interface{}{ 487 "api-version": APIVersion, 488 } 489 490 preparer := autorest.CreatePreparer( 491 autorest.AsGet(), 492 autorest.WithBaseURL(client.BaseURI), 493 autorest.WithPathParameters("/{tenantID}/groups/{objectId}/members", pathParameters), 494 autorest.WithQueryParameters(queryParameters)) 495 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 496} 497 498// GetGroupMembersSender sends the GetGroupMembers request. The method will close the 499// http.Response Body if it receives an error. 500func (client GroupsClient) GetGroupMembersSender(req *http.Request) (*http.Response, error) { 501 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 502} 503 504// GetGroupMembersResponder handles the response to the GetGroupMembers request. The method always 505// closes the http.Response Body. 506func (client GroupsClient) GetGroupMembersResponder(resp *http.Response) (result DirectoryObjectListResult, err error) { 507 err = autorest.Respond( 508 resp, 509 azure.WithErrorUnlessStatusCode(http.StatusOK), 510 autorest.ByUnmarshallingJSON(&result), 511 autorest.ByClosing()) 512 result.Response = autorest.Response{Response: resp} 513 return 514} 515 516// GetGroupMembersComplete enumerates all values, automatically crossing page boundaries as required. 517func (client GroupsClient) GetGroupMembersComplete(ctx context.Context, objectID string) (result DirectoryObjectListResultIterator, err error) { 518 if tracing.IsEnabled() { 519 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.GetGroupMembers") 520 defer func() { 521 sc := -1 522 if result.Response().Response.Response != nil { 523 sc = result.page.Response().Response.Response.StatusCode 524 } 525 tracing.EndSpan(ctx, sc, err) 526 }() 527 } 528 result.page, err = client.GetGroupMembers(ctx, objectID) 529 return 530} 531 532// GetGroupMembersNext gets the members of a group. 533// Parameters: 534// nextLink - next link for the list operation. 535func (client GroupsClient) GetGroupMembersNext(ctx context.Context, nextLink string) (result DirectoryObjectListResult, err error) { 536 if tracing.IsEnabled() { 537 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.GetGroupMembersNext") 538 defer func() { 539 sc := -1 540 if result.Response.Response != nil { 541 sc = result.Response.Response.StatusCode 542 } 543 tracing.EndSpan(ctx, sc, err) 544 }() 545 } 546 req, err := client.GetGroupMembersNextPreparer(ctx, nextLink) 547 if err != nil { 548 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "GetGroupMembersNext", nil, "Failure preparing request") 549 return 550 } 551 552 resp, err := client.GetGroupMembersNextSender(req) 553 if err != nil { 554 result.Response = autorest.Response{Response: resp} 555 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "GetGroupMembersNext", resp, "Failure sending request") 556 return 557 } 558 559 result, err = client.GetGroupMembersNextResponder(resp) 560 if err != nil { 561 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "GetGroupMembersNext", resp, "Failure responding to request") 562 return 563 } 564 565 return 566} 567 568// GetGroupMembersNextPreparer prepares the GetGroupMembersNext request. 569func (client GroupsClient) GetGroupMembersNextPreparer(ctx context.Context, nextLink string) (*http.Request, error) { 570 pathParameters := map[string]interface{}{ 571 "nextLink": nextLink, 572 "tenantID": autorest.Encode("path", client.TenantID), 573 } 574 575 const APIVersion = "1.6" 576 queryParameters := map[string]interface{}{ 577 "api-version": APIVersion, 578 } 579 580 preparer := autorest.CreatePreparer( 581 autorest.AsGet(), 582 autorest.WithBaseURL(client.BaseURI), 583 autorest.WithPathParameters("/{tenantID}/{nextLink}", pathParameters), 584 autorest.WithQueryParameters(queryParameters)) 585 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 586} 587 588// GetGroupMembersNextSender sends the GetGroupMembersNext request. The method will close the 589// http.Response Body if it receives an error. 590func (client GroupsClient) GetGroupMembersNextSender(req *http.Request) (*http.Response, error) { 591 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 592} 593 594// GetGroupMembersNextResponder handles the response to the GetGroupMembersNext request. The method always 595// closes the http.Response Body. 596func (client GroupsClient) GetGroupMembersNextResponder(resp *http.Response) (result DirectoryObjectListResult, err error) { 597 err = autorest.Respond( 598 resp, 599 azure.WithErrorUnlessStatusCode(http.StatusOK), 600 autorest.ByUnmarshallingJSON(&result), 601 autorest.ByClosing()) 602 result.Response = autorest.Response{Response: resp} 603 return 604} 605 606// GetMemberGroups gets a collection of object IDs of groups of which the specified group is a member. 607// Parameters: 608// objectID - the object ID of the group for which to get group membership. 609// parameters - group filtering parameters. 610func (client GroupsClient) GetMemberGroups(ctx context.Context, objectID string, parameters GroupGetMemberGroupsParameters) (result GroupGetMemberGroupsResult, err error) { 611 if tracing.IsEnabled() { 612 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.GetMemberGroups") 613 defer func() { 614 sc := -1 615 if result.Response.Response != nil { 616 sc = result.Response.Response.StatusCode 617 } 618 tracing.EndSpan(ctx, sc, err) 619 }() 620 } 621 if err := validation.Validate([]validation.Validation{ 622 {TargetValue: parameters, 623 Constraints: []validation.Constraint{{Target: "parameters.SecurityEnabledOnly", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 624 return result, validation.NewError("graphrbac.GroupsClient", "GetMemberGroups", err.Error()) 625 } 626 627 req, err := client.GetMemberGroupsPreparer(ctx, objectID, parameters) 628 if err != nil { 629 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "GetMemberGroups", nil, "Failure preparing request") 630 return 631 } 632 633 resp, err := client.GetMemberGroupsSender(req) 634 if err != nil { 635 result.Response = autorest.Response{Response: resp} 636 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "GetMemberGroups", resp, "Failure sending request") 637 return 638 } 639 640 result, err = client.GetMemberGroupsResponder(resp) 641 if err != nil { 642 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "GetMemberGroups", resp, "Failure responding to request") 643 return 644 } 645 646 return 647} 648 649// GetMemberGroupsPreparer prepares the GetMemberGroups request. 650func (client GroupsClient) GetMemberGroupsPreparer(ctx context.Context, objectID string, parameters GroupGetMemberGroupsParameters) (*http.Request, error) { 651 pathParameters := map[string]interface{}{ 652 "objectId": autorest.Encode("path", objectID), 653 "tenantID": autorest.Encode("path", client.TenantID), 654 } 655 656 const APIVersion = "1.6" 657 queryParameters := map[string]interface{}{ 658 "api-version": APIVersion, 659 } 660 661 preparer := autorest.CreatePreparer( 662 autorest.AsContentType("application/json; charset=utf-8"), 663 autorest.AsPost(), 664 autorest.WithBaseURL(client.BaseURI), 665 autorest.WithPathParameters("/{tenantID}/groups/{objectId}/getMemberGroups", pathParameters), 666 autorest.WithJSON(parameters), 667 autorest.WithQueryParameters(queryParameters)) 668 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 669} 670 671// GetMemberGroupsSender sends the GetMemberGroups request. The method will close the 672// http.Response Body if it receives an error. 673func (client GroupsClient) GetMemberGroupsSender(req *http.Request) (*http.Response, error) { 674 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 675} 676 677// GetMemberGroupsResponder handles the response to the GetMemberGroups request. The method always 678// closes the http.Response Body. 679func (client GroupsClient) GetMemberGroupsResponder(resp *http.Response) (result GroupGetMemberGroupsResult, err error) { 680 err = autorest.Respond( 681 resp, 682 azure.WithErrorUnlessStatusCode(http.StatusOK), 683 autorest.ByUnmarshallingJSON(&result), 684 autorest.ByClosing()) 685 result.Response = autorest.Response{Response: resp} 686 return 687} 688 689// IsMemberOf checks whether the specified user, group, contact, or service principal is a direct or transitive member 690// of the specified group. 691// Parameters: 692// parameters - the check group membership parameters. 693func (client GroupsClient) IsMemberOf(ctx context.Context, parameters CheckGroupMembershipParameters) (result CheckGroupMembershipResult, err error) { 694 if tracing.IsEnabled() { 695 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.IsMemberOf") 696 defer func() { 697 sc := -1 698 if result.Response.Response != nil { 699 sc = result.Response.Response.StatusCode 700 } 701 tracing.EndSpan(ctx, sc, err) 702 }() 703 } 704 if err := validation.Validate([]validation.Validation{ 705 {TargetValue: parameters, 706 Constraints: []validation.Constraint{{Target: "parameters.GroupID", Name: validation.Null, Rule: true, Chain: nil}, 707 {Target: "parameters.MemberID", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 708 return result, validation.NewError("graphrbac.GroupsClient", "IsMemberOf", err.Error()) 709 } 710 711 req, err := client.IsMemberOfPreparer(ctx, parameters) 712 if err != nil { 713 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "IsMemberOf", nil, "Failure preparing request") 714 return 715 } 716 717 resp, err := client.IsMemberOfSender(req) 718 if err != nil { 719 result.Response = autorest.Response{Response: resp} 720 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "IsMemberOf", resp, "Failure sending request") 721 return 722 } 723 724 result, err = client.IsMemberOfResponder(resp) 725 if err != nil { 726 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "IsMemberOf", resp, "Failure responding to request") 727 return 728 } 729 730 return 731} 732 733// IsMemberOfPreparer prepares the IsMemberOf request. 734func (client GroupsClient) IsMemberOfPreparer(ctx context.Context, parameters CheckGroupMembershipParameters) (*http.Request, error) { 735 pathParameters := map[string]interface{}{ 736 "tenantID": autorest.Encode("path", client.TenantID), 737 } 738 739 const APIVersion = "1.6" 740 queryParameters := map[string]interface{}{ 741 "api-version": APIVersion, 742 } 743 744 preparer := autorest.CreatePreparer( 745 autorest.AsContentType("application/json; charset=utf-8"), 746 autorest.AsPost(), 747 autorest.WithBaseURL(client.BaseURI), 748 autorest.WithPathParameters("/{tenantID}/isMemberOf", pathParameters), 749 autorest.WithJSON(parameters), 750 autorest.WithQueryParameters(queryParameters)) 751 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 752} 753 754// IsMemberOfSender sends the IsMemberOf request. The method will close the 755// http.Response Body if it receives an error. 756func (client GroupsClient) IsMemberOfSender(req *http.Request) (*http.Response, error) { 757 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 758} 759 760// IsMemberOfResponder handles the response to the IsMemberOf request. The method always 761// closes the http.Response Body. 762func (client GroupsClient) IsMemberOfResponder(resp *http.Response) (result CheckGroupMembershipResult, err error) { 763 err = autorest.Respond( 764 resp, 765 azure.WithErrorUnlessStatusCode(http.StatusOK), 766 autorest.ByUnmarshallingJSON(&result), 767 autorest.ByClosing()) 768 result.Response = autorest.Response{Response: resp} 769 return 770} 771 772// List gets list of groups for the current tenant. 773// Parameters: 774// filter - the filter to apply to the operation. 775func (client GroupsClient) List(ctx context.Context, filter string) (result GroupListResultPage, err error) { 776 if tracing.IsEnabled() { 777 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.List") 778 defer func() { 779 sc := -1 780 if result.glr.Response.Response != nil { 781 sc = result.glr.Response.Response.StatusCode 782 } 783 tracing.EndSpan(ctx, sc, err) 784 }() 785 } 786 result.fn = func(ctx context.Context, lastResult GroupListResult) (GroupListResult, error) { 787 if lastResult.OdataNextLink == nil || len(to.String(lastResult.OdataNextLink)) < 1 { 788 return GroupListResult{}, nil 789 } 790 return client.ListNext(ctx, *lastResult.OdataNextLink) 791 } 792 req, err := client.ListPreparer(ctx, filter) 793 if err != nil { 794 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "List", nil, "Failure preparing request") 795 return 796 } 797 798 resp, err := client.ListSender(req) 799 if err != nil { 800 result.glr.Response = autorest.Response{Response: resp} 801 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "List", resp, "Failure sending request") 802 return 803 } 804 805 result.glr, err = client.ListResponder(resp) 806 if err != nil { 807 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "List", resp, "Failure responding to request") 808 return 809 } 810 if result.glr.hasNextLink() && result.glr.IsEmpty() { 811 err = result.NextWithContext(ctx) 812 return 813 } 814 815 return 816} 817 818// ListPreparer prepares the List request. 819func (client GroupsClient) ListPreparer(ctx context.Context, filter string) (*http.Request, error) { 820 pathParameters := map[string]interface{}{ 821 "tenantID": autorest.Encode("path", client.TenantID), 822 } 823 824 const APIVersion = "1.6" 825 queryParameters := map[string]interface{}{ 826 "api-version": APIVersion, 827 } 828 if len(filter) > 0 { 829 queryParameters["$filter"] = autorest.Encode("query", filter) 830 } 831 832 preparer := autorest.CreatePreparer( 833 autorest.AsGet(), 834 autorest.WithBaseURL(client.BaseURI), 835 autorest.WithPathParameters("/{tenantID}/groups", pathParameters), 836 autorest.WithQueryParameters(queryParameters)) 837 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 838} 839 840// ListSender sends the List request. The method will close the 841// http.Response Body if it receives an error. 842func (client GroupsClient) ListSender(req *http.Request) (*http.Response, error) { 843 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 844} 845 846// ListResponder handles the response to the List request. The method always 847// closes the http.Response Body. 848func (client GroupsClient) ListResponder(resp *http.Response) (result GroupListResult, err error) { 849 err = autorest.Respond( 850 resp, 851 azure.WithErrorUnlessStatusCode(http.StatusOK), 852 autorest.ByUnmarshallingJSON(&result), 853 autorest.ByClosing()) 854 result.Response = autorest.Response{Response: resp} 855 return 856} 857 858// ListComplete enumerates all values, automatically crossing page boundaries as required. 859func (client GroupsClient) ListComplete(ctx context.Context, filter string) (result GroupListResultIterator, err error) { 860 if tracing.IsEnabled() { 861 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.List") 862 defer func() { 863 sc := -1 864 if result.Response().Response.Response != nil { 865 sc = result.page.Response().Response.Response.StatusCode 866 } 867 tracing.EndSpan(ctx, sc, err) 868 }() 869 } 870 result.page, err = client.List(ctx, filter) 871 return 872} 873 874// ListNext gets a list of groups for the current tenant. 875// Parameters: 876// nextLink - next link for the list operation. 877func (client GroupsClient) ListNext(ctx context.Context, nextLink string) (result GroupListResult, err error) { 878 if tracing.IsEnabled() { 879 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.ListNext") 880 defer func() { 881 sc := -1 882 if result.Response.Response != nil { 883 sc = result.Response.Response.StatusCode 884 } 885 tracing.EndSpan(ctx, sc, err) 886 }() 887 } 888 req, err := client.ListNextPreparer(ctx, nextLink) 889 if err != nil { 890 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "ListNext", nil, "Failure preparing request") 891 return 892 } 893 894 resp, err := client.ListNextSender(req) 895 if err != nil { 896 result.Response = autorest.Response{Response: resp} 897 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "ListNext", resp, "Failure sending request") 898 return 899 } 900 901 result, err = client.ListNextResponder(resp) 902 if err != nil { 903 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "ListNext", resp, "Failure responding to request") 904 return 905 } 906 907 return 908} 909 910// ListNextPreparer prepares the ListNext request. 911func (client GroupsClient) ListNextPreparer(ctx context.Context, nextLink string) (*http.Request, error) { 912 pathParameters := map[string]interface{}{ 913 "nextLink": nextLink, 914 "tenantID": autorest.Encode("path", client.TenantID), 915 } 916 917 const APIVersion = "1.6" 918 queryParameters := map[string]interface{}{ 919 "api-version": APIVersion, 920 } 921 922 preparer := autorest.CreatePreparer( 923 autorest.AsGet(), 924 autorest.WithBaseURL(client.BaseURI), 925 autorest.WithPathParameters("/{tenantID}/{nextLink}", pathParameters), 926 autorest.WithQueryParameters(queryParameters)) 927 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 928} 929 930// ListNextSender sends the ListNext request. The method will close the 931// http.Response Body if it receives an error. 932func (client GroupsClient) ListNextSender(req *http.Request) (*http.Response, error) { 933 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 934} 935 936// ListNextResponder handles the response to the ListNext request. The method always 937// closes the http.Response Body. 938func (client GroupsClient) ListNextResponder(resp *http.Response) (result GroupListResult, err error) { 939 err = autorest.Respond( 940 resp, 941 azure.WithErrorUnlessStatusCode(http.StatusOK), 942 autorest.ByUnmarshallingJSON(&result), 943 autorest.ByClosing()) 944 result.Response = autorest.Response{Response: resp} 945 return 946} 947 948// ListOwners the owners are a set of non-admin users who are allowed to modify this object. 949// Parameters: 950// objectID - the object ID of the group for which to get owners. 951func (client GroupsClient) ListOwners(ctx context.Context, objectID string) (result DirectoryObjectListResultPage, err error) { 952 if tracing.IsEnabled() { 953 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.ListOwners") 954 defer func() { 955 sc := -1 956 if result.dolr.Response.Response != nil { 957 sc = result.dolr.Response.Response.StatusCode 958 } 959 tracing.EndSpan(ctx, sc, err) 960 }() 961 } 962 result.fn = client.listOwnersNextResults 963 req, err := client.ListOwnersPreparer(ctx, objectID) 964 if err != nil { 965 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "ListOwners", nil, "Failure preparing request") 966 return 967 } 968 969 resp, err := client.ListOwnersSender(req) 970 if err != nil { 971 result.dolr.Response = autorest.Response{Response: resp} 972 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "ListOwners", resp, "Failure sending request") 973 return 974 } 975 976 result.dolr, err = client.ListOwnersResponder(resp) 977 if err != nil { 978 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "ListOwners", resp, "Failure responding to request") 979 return 980 } 981 if result.dolr.hasNextLink() && result.dolr.IsEmpty() { 982 err = result.NextWithContext(ctx) 983 return 984 } 985 986 return 987} 988 989// ListOwnersPreparer prepares the ListOwners request. 990func (client GroupsClient) ListOwnersPreparer(ctx context.Context, objectID string) (*http.Request, error) { 991 pathParameters := map[string]interface{}{ 992 "objectId": autorest.Encode("path", objectID), 993 "tenantID": autorest.Encode("path", client.TenantID), 994 } 995 996 const APIVersion = "1.6" 997 queryParameters := map[string]interface{}{ 998 "api-version": APIVersion, 999 } 1000 1001 preparer := autorest.CreatePreparer( 1002 autorest.AsGet(), 1003 autorest.WithBaseURL(client.BaseURI), 1004 autorest.WithPathParameters("/{tenantID}/groups/{objectId}/owners", pathParameters), 1005 autorest.WithQueryParameters(queryParameters)) 1006 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1007} 1008 1009// ListOwnersSender sends the ListOwners request. The method will close the 1010// http.Response Body if it receives an error. 1011func (client GroupsClient) ListOwnersSender(req *http.Request) (*http.Response, error) { 1012 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1013} 1014 1015// ListOwnersResponder handles the response to the ListOwners request. The method always 1016// closes the http.Response Body. 1017func (client GroupsClient) ListOwnersResponder(resp *http.Response) (result DirectoryObjectListResult, err error) { 1018 err = autorest.Respond( 1019 resp, 1020 azure.WithErrorUnlessStatusCode(http.StatusOK), 1021 autorest.ByUnmarshallingJSON(&result), 1022 autorest.ByClosing()) 1023 result.Response = autorest.Response{Response: resp} 1024 return 1025} 1026 1027// listOwnersNextResults retrieves the next set of results, if any. 1028func (client GroupsClient) listOwnersNextResults(ctx context.Context, lastResults DirectoryObjectListResult) (result DirectoryObjectListResult, err error) { 1029 req, err := lastResults.directoryObjectListResultPreparer(ctx) 1030 if err != nil { 1031 return result, autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "listOwnersNextResults", nil, "Failure preparing next results request") 1032 } 1033 if req == nil { 1034 return 1035 } 1036 resp, err := client.ListOwnersSender(req) 1037 if err != nil { 1038 result.Response = autorest.Response{Response: resp} 1039 return result, autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "listOwnersNextResults", resp, "Failure sending next results request") 1040 } 1041 result, err = client.ListOwnersResponder(resp) 1042 if err != nil { 1043 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "listOwnersNextResults", resp, "Failure responding to next results request") 1044 } 1045 return 1046} 1047 1048// ListOwnersComplete enumerates all values, automatically crossing page boundaries as required. 1049func (client GroupsClient) ListOwnersComplete(ctx context.Context, objectID string) (result DirectoryObjectListResultIterator, err error) { 1050 if tracing.IsEnabled() { 1051 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.ListOwners") 1052 defer func() { 1053 sc := -1 1054 if result.Response().Response.Response != nil { 1055 sc = result.page.Response().Response.Response.StatusCode 1056 } 1057 tracing.EndSpan(ctx, sc, err) 1058 }() 1059 } 1060 result.page, err = client.ListOwners(ctx, objectID) 1061 return 1062} 1063 1064// RemoveMember remove a member from a group. 1065// Parameters: 1066// groupObjectID - the object ID of the group from which to remove the member. 1067// memberObjectID - member object id 1068func (client GroupsClient) RemoveMember(ctx context.Context, groupObjectID string, memberObjectID string) (result autorest.Response, err error) { 1069 if tracing.IsEnabled() { 1070 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.RemoveMember") 1071 defer func() { 1072 sc := -1 1073 if result.Response != nil { 1074 sc = result.Response.StatusCode 1075 } 1076 tracing.EndSpan(ctx, sc, err) 1077 }() 1078 } 1079 req, err := client.RemoveMemberPreparer(ctx, groupObjectID, memberObjectID) 1080 if err != nil { 1081 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "RemoveMember", nil, "Failure preparing request") 1082 return 1083 } 1084 1085 resp, err := client.RemoveMemberSender(req) 1086 if err != nil { 1087 result.Response = resp 1088 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "RemoveMember", resp, "Failure sending request") 1089 return 1090 } 1091 1092 result, err = client.RemoveMemberResponder(resp) 1093 if err != nil { 1094 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "RemoveMember", resp, "Failure responding to request") 1095 return 1096 } 1097 1098 return 1099} 1100 1101// RemoveMemberPreparer prepares the RemoveMember request. 1102func (client GroupsClient) RemoveMemberPreparer(ctx context.Context, groupObjectID string, memberObjectID string) (*http.Request, error) { 1103 pathParameters := map[string]interface{}{ 1104 "groupObjectId": autorest.Encode("path", groupObjectID), 1105 "memberObjectId": autorest.Encode("path", memberObjectID), 1106 "tenantID": autorest.Encode("path", client.TenantID), 1107 } 1108 1109 const APIVersion = "1.6" 1110 queryParameters := map[string]interface{}{ 1111 "api-version": APIVersion, 1112 } 1113 1114 preparer := autorest.CreatePreparer( 1115 autorest.AsDelete(), 1116 autorest.WithBaseURL(client.BaseURI), 1117 autorest.WithPathParameters("/{tenantID}/groups/{groupObjectId}/$links/members/{memberObjectId}", pathParameters), 1118 autorest.WithQueryParameters(queryParameters)) 1119 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1120} 1121 1122// RemoveMemberSender sends the RemoveMember request. The method will close the 1123// http.Response Body if it receives an error. 1124func (client GroupsClient) RemoveMemberSender(req *http.Request) (*http.Response, error) { 1125 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1126} 1127 1128// RemoveMemberResponder handles the response to the RemoveMember request. The method always 1129// closes the http.Response Body. 1130func (client GroupsClient) RemoveMemberResponder(resp *http.Response) (result autorest.Response, err error) { 1131 err = autorest.Respond( 1132 resp, 1133 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 1134 autorest.ByClosing()) 1135 result.Response = resp 1136 return 1137} 1138 1139// RemoveOwner remove a member from owners. 1140// Parameters: 1141// objectID - the object ID of the group from which to remove the owner. 1142// ownerObjectID - owner object id 1143func (client GroupsClient) RemoveOwner(ctx context.Context, objectID string, ownerObjectID string) (result autorest.Response, err error) { 1144 if tracing.IsEnabled() { 1145 ctx = tracing.StartSpan(ctx, fqdn+"/GroupsClient.RemoveOwner") 1146 defer func() { 1147 sc := -1 1148 if result.Response != nil { 1149 sc = result.Response.StatusCode 1150 } 1151 tracing.EndSpan(ctx, sc, err) 1152 }() 1153 } 1154 req, err := client.RemoveOwnerPreparer(ctx, objectID, ownerObjectID) 1155 if err != nil { 1156 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "RemoveOwner", nil, "Failure preparing request") 1157 return 1158 } 1159 1160 resp, err := client.RemoveOwnerSender(req) 1161 if err != nil { 1162 result.Response = resp 1163 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "RemoveOwner", resp, "Failure sending request") 1164 return 1165 } 1166 1167 result, err = client.RemoveOwnerResponder(resp) 1168 if err != nil { 1169 err = autorest.NewErrorWithError(err, "graphrbac.GroupsClient", "RemoveOwner", resp, "Failure responding to request") 1170 return 1171 } 1172 1173 return 1174} 1175 1176// RemoveOwnerPreparer prepares the RemoveOwner request. 1177func (client GroupsClient) RemoveOwnerPreparer(ctx context.Context, objectID string, ownerObjectID string) (*http.Request, error) { 1178 pathParameters := map[string]interface{}{ 1179 "objectId": autorest.Encode("path", objectID), 1180 "ownerObjectId": autorest.Encode("path", ownerObjectID), 1181 "tenantID": autorest.Encode("path", client.TenantID), 1182 } 1183 1184 const APIVersion = "1.6" 1185 queryParameters := map[string]interface{}{ 1186 "api-version": APIVersion, 1187 } 1188 1189 preparer := autorest.CreatePreparer( 1190 autorest.AsDelete(), 1191 autorest.WithBaseURL(client.BaseURI), 1192 autorest.WithPathParameters("/{tenantID}/groups/{objectId}/$links/owners/{ownerObjectId}", pathParameters), 1193 autorest.WithQueryParameters(queryParameters)) 1194 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 1195} 1196 1197// RemoveOwnerSender sends the RemoveOwner request. The method will close the 1198// http.Response Body if it receives an error. 1199func (client GroupsClient) RemoveOwnerSender(req *http.Request) (*http.Response, error) { 1200 return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) 1201} 1202 1203// RemoveOwnerResponder handles the response to the RemoveOwner request. The method always 1204// closes the http.Response Body. 1205func (client GroupsClient) RemoveOwnerResponder(resp *http.Response) (result autorest.Response, err error) { 1206 err = autorest.Respond( 1207 resp, 1208 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 1209 autorest.ByClosing()) 1210 result.Response = resp 1211 return 1212} 1213