1// Copyright (c) 2016, 2018, 2020, Oracle and/or its affiliates. All rights reserved. 2// This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license. 3// Code generated. DO NOT EDIT. 4 5// Identity and Access Management Service API 6// 7// APIs for managing users, groups, compartments, and policies. 8// 9 10package identity 11 12import ( 13 "context" 14 "fmt" 15 "github.com/oracle/oci-go-sdk/common" 16 "net/http" 17) 18 19//IdentityClient a client for Identity 20type IdentityClient struct { 21 common.BaseClient 22 config *common.ConfigurationProvider 23} 24 25// NewIdentityClientWithConfigurationProvider Creates a new default Identity client with the given configuration provider. 26// the configuration provider will be used for the default signer as well as reading the region 27func NewIdentityClientWithConfigurationProvider(configProvider common.ConfigurationProvider) (client IdentityClient, err error) { 28 baseClient, err := common.NewClientWithConfig(configProvider) 29 if err != nil { 30 return 31 } 32 33 return newIdentityClientFromBaseClient(baseClient, configProvider) 34} 35 36// NewIdentityClientWithOboToken Creates a new default Identity client with the given configuration provider. 37// The obotoken will be added to default headers and signed; the configuration provider will be used for the signer 38// as well as reading the region 39func NewIdentityClientWithOboToken(configProvider common.ConfigurationProvider, oboToken string) (client IdentityClient, err error) { 40 baseClient, err := common.NewClientWithOboToken(configProvider, oboToken) 41 if err != nil { 42 return 43 } 44 45 return newIdentityClientFromBaseClient(baseClient, configProvider) 46} 47 48func newIdentityClientFromBaseClient(baseClient common.BaseClient, configProvider common.ConfigurationProvider) (client IdentityClient, err error) { 49 client = IdentityClient{BaseClient: baseClient} 50 client.BasePath = "20160918" 51 err = client.setConfigurationProvider(configProvider) 52 return 53} 54 55// SetRegion overrides the region of this client. 56func (client *IdentityClient) SetRegion(region string) { 57 client.Host = common.StringToRegion(region).Endpoint("identity") 58} 59 60// SetConfigurationProvider sets the configuration provider including the region, returns an error if is not valid 61func (client *IdentityClient) setConfigurationProvider(configProvider common.ConfigurationProvider) error { 62 if ok, err := common.IsConfigurationProviderValid(configProvider); !ok { 63 return err 64 } 65 66 // Error has been checked already 67 region, _ := configProvider.Region() 68 client.SetRegion(region) 69 client.config = &configProvider 70 return nil 71} 72 73// ConfigurationProvider the ConfigurationProvider used in this client, or null if none set 74func (client *IdentityClient) ConfigurationProvider() *common.ConfigurationProvider { 75 return client.config 76} 77 78// ActivateMfaTotpDevice Activates the specified MFA TOTP device for the user. Activation requires manual interaction with the Console. 79func (client IdentityClient) ActivateMfaTotpDevice(ctx context.Context, request ActivateMfaTotpDeviceRequest) (response ActivateMfaTotpDeviceResponse, err error) { 80 var ociResponse common.OCIResponse 81 policy := common.NoRetryPolicy() 82 if request.RetryPolicy() != nil { 83 policy = *request.RetryPolicy() 84 } 85 86 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 87 request.OpcRetryToken = common.String(common.RetryToken()) 88 } 89 90 ociResponse, err = common.Retry(ctx, request, client.activateMfaTotpDevice, policy) 91 if err != nil { 92 if ociResponse != nil { 93 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 94 opcRequestId := httpResponse.Header.Get("opc-request-id") 95 response = ActivateMfaTotpDeviceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 96 } else { 97 response = ActivateMfaTotpDeviceResponse{} 98 } 99 } 100 return 101 } 102 if convertedResponse, ok := ociResponse.(ActivateMfaTotpDeviceResponse); ok { 103 response = convertedResponse 104 } else { 105 err = fmt.Errorf("failed to convert OCIResponse into ActivateMfaTotpDeviceResponse") 106 } 107 return 108} 109 110// activateMfaTotpDevice implements the OCIOperation interface (enables retrying operations) 111func (client IdentityClient) activateMfaTotpDevice(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 112 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/mfaTotpDevices/{mfaTotpDeviceId}/actions/activate") 113 if err != nil { 114 return nil, err 115 } 116 117 var response ActivateMfaTotpDeviceResponse 118 var httpResponse *http.Response 119 httpResponse, err = client.Call(ctx, &httpRequest) 120 defer common.CloseBodyIfValid(httpResponse) 121 response.RawResponse = httpResponse 122 if err != nil { 123 return response, err 124 } 125 126 err = common.UnmarshalResponse(httpResponse, &response) 127 return response, err 128} 129 130// AddUserToGroup Adds the specified user to the specified group and returns a `UserGroupMembership` object with its own OCID. 131// After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the 132// object, first make sure its `lifecycleState` has changed to ACTIVE. 133func (client IdentityClient) AddUserToGroup(ctx context.Context, request AddUserToGroupRequest) (response AddUserToGroupResponse, err error) { 134 var ociResponse common.OCIResponse 135 policy := common.NoRetryPolicy() 136 if request.RetryPolicy() != nil { 137 policy = *request.RetryPolicy() 138 } 139 140 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 141 request.OpcRetryToken = common.String(common.RetryToken()) 142 } 143 144 ociResponse, err = common.Retry(ctx, request, client.addUserToGroup, policy) 145 if err != nil { 146 if ociResponse != nil { 147 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 148 opcRequestId := httpResponse.Header.Get("opc-request-id") 149 response = AddUserToGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 150 } else { 151 response = AddUserToGroupResponse{} 152 } 153 } 154 return 155 } 156 if convertedResponse, ok := ociResponse.(AddUserToGroupResponse); ok { 157 response = convertedResponse 158 } else { 159 err = fmt.Errorf("failed to convert OCIResponse into AddUserToGroupResponse") 160 } 161 return 162} 163 164// addUserToGroup implements the OCIOperation interface (enables retrying operations) 165func (client IdentityClient) addUserToGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 166 httpRequest, err := request.HTTPRequest(http.MethodPost, "/userGroupMemberships") 167 if err != nil { 168 return nil, err 169 } 170 171 var response AddUserToGroupResponse 172 var httpResponse *http.Response 173 httpResponse, err = client.Call(ctx, &httpRequest) 174 defer common.CloseBodyIfValid(httpResponse) 175 response.RawResponse = httpResponse 176 if err != nil { 177 return response, err 178 } 179 180 err = common.UnmarshalResponse(httpResponse, &response) 181 return response, err 182} 183 184// AssembleEffectiveTagSet Assembles tag defaults in the specified compartment and any parent compartments to determine 185// the tags to apply. Tag defaults from parent compartments do not override tag defaults 186// referencing the same tag in a compartment lower down the hierarchy. This set of tag defaults 187// includes all tag defaults from the current compartment back to the root compartment. 188func (client IdentityClient) AssembleEffectiveTagSet(ctx context.Context, request AssembleEffectiveTagSetRequest) (response AssembleEffectiveTagSetResponse, err error) { 189 var ociResponse common.OCIResponse 190 policy := common.NoRetryPolicy() 191 if request.RetryPolicy() != nil { 192 policy = *request.RetryPolicy() 193 } 194 ociResponse, err = common.Retry(ctx, request, client.assembleEffectiveTagSet, policy) 195 if err != nil { 196 if ociResponse != nil { 197 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 198 opcRequestId := httpResponse.Header.Get("opc-request-id") 199 response = AssembleEffectiveTagSetResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 200 } else { 201 response = AssembleEffectiveTagSetResponse{} 202 } 203 } 204 return 205 } 206 if convertedResponse, ok := ociResponse.(AssembleEffectiveTagSetResponse); ok { 207 response = convertedResponse 208 } else { 209 err = fmt.Errorf("failed to convert OCIResponse into AssembleEffectiveTagSetResponse") 210 } 211 return 212} 213 214// assembleEffectiveTagSet implements the OCIOperation interface (enables retrying operations) 215func (client IdentityClient) assembleEffectiveTagSet(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 216 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tagDefaults/actions/assembleEffectiveTagSet") 217 if err != nil { 218 return nil, err 219 } 220 221 var response AssembleEffectiveTagSetResponse 222 var httpResponse *http.Response 223 httpResponse, err = client.Call(ctx, &httpRequest) 224 defer common.CloseBodyIfValid(httpResponse) 225 response.RawResponse = httpResponse 226 if err != nil { 227 return response, err 228 } 229 230 err = common.UnmarshalResponse(httpResponse, &response) 231 return response, err 232} 233 234// BulkDeleteResources Deletes multiple resources in the compartment. All resources must be in the same compartment. You must have the appropriate 235// permissions to delete the resources in the request. This API can only be invoked from the tenancy's 236// home region (https://docs.cloud.oracle.com/Content/Identity/Tasks/managingregions.htm#Home). This operation creates a 237// WorkRequest. Use the GetWorkRequest 238// API to monitor the status of the bulk action. 239func (client IdentityClient) BulkDeleteResources(ctx context.Context, request BulkDeleteResourcesRequest) (response BulkDeleteResourcesResponse, err error) { 240 var ociResponse common.OCIResponse 241 policy := common.NoRetryPolicy() 242 if request.RetryPolicy() != nil { 243 policy = *request.RetryPolicy() 244 } 245 246 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 247 request.OpcRetryToken = common.String(common.RetryToken()) 248 } 249 250 ociResponse, err = common.Retry(ctx, request, client.bulkDeleteResources, policy) 251 if err != nil { 252 if ociResponse != nil { 253 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 254 opcRequestId := httpResponse.Header.Get("opc-request-id") 255 response = BulkDeleteResourcesResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 256 } else { 257 response = BulkDeleteResourcesResponse{} 258 } 259 } 260 return 261 } 262 if convertedResponse, ok := ociResponse.(BulkDeleteResourcesResponse); ok { 263 response = convertedResponse 264 } else { 265 err = fmt.Errorf("failed to convert OCIResponse into BulkDeleteResourcesResponse") 266 } 267 return 268} 269 270// bulkDeleteResources implements the OCIOperation interface (enables retrying operations) 271func (client IdentityClient) bulkDeleteResources(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 272 httpRequest, err := request.HTTPRequest(http.MethodPost, "/compartments/{compartmentId}/actions/bulkDeleteResources") 273 if err != nil { 274 return nil, err 275 } 276 277 var response BulkDeleteResourcesResponse 278 var httpResponse *http.Response 279 httpResponse, err = client.Call(ctx, &httpRequest) 280 defer common.CloseBodyIfValid(httpResponse) 281 response.RawResponse = httpResponse 282 if err != nil { 283 return response, err 284 } 285 286 err = common.UnmarshalResponse(httpResponse, &response) 287 return response, err 288} 289 290// BulkDeleteTags Deletes the specified tag key definitions. This operation triggers a process that removes the 291// tags from all resources in your tenancy. 292// The following actions happen immediately: 293// 294// * If the tag is a cost-tracking tag, the tag no longer counts against your 295// 10 cost-tracking tags limit, even if you do not disable the tag before running this operation. 296// * If the tag is used with dynamic groups, the rules that contain the tag are no longer 297// evaluated against the tag. 298// After you start this operation, the state of the tag changes to DELETING, and tag removal 299// from resources begins. This process can take up to 48 hours depending on the number of resources that 300// are tagged and the regions in which those resources reside. 301// When all tags have been removed, the state changes to DELETED. You cannot restore a deleted tag. After the tag state 302// changes to DELETED, you can use the same tag name again. 303// After you start this operation, you cannot start either the DeleteTag or the CascadeDeleteTagNamespace operation until this process completes. 304// In order to delete tags, you must first retire the tags. Use UpdateTag 305// to retire a tag. 306func (client IdentityClient) BulkDeleteTags(ctx context.Context, request BulkDeleteTagsRequest) (response BulkDeleteTagsResponse, err error) { 307 var ociResponse common.OCIResponse 308 policy := common.NoRetryPolicy() 309 if request.RetryPolicy() != nil { 310 policy = *request.RetryPolicy() 311 } 312 313 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 314 request.OpcRetryToken = common.String(common.RetryToken()) 315 } 316 317 ociResponse, err = common.Retry(ctx, request, client.bulkDeleteTags, policy) 318 if err != nil { 319 if ociResponse != nil { 320 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 321 opcRequestId := httpResponse.Header.Get("opc-request-id") 322 response = BulkDeleteTagsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 323 } else { 324 response = BulkDeleteTagsResponse{} 325 } 326 } 327 return 328 } 329 if convertedResponse, ok := ociResponse.(BulkDeleteTagsResponse); ok { 330 response = convertedResponse 331 } else { 332 err = fmt.Errorf("failed to convert OCIResponse into BulkDeleteTagsResponse") 333 } 334 return 335} 336 337// bulkDeleteTags implements the OCIOperation interface (enables retrying operations) 338func (client IdentityClient) bulkDeleteTags(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 339 httpRequest, err := request.HTTPRequest(http.MethodPost, "/tags/actions/bulkDelete") 340 if err != nil { 341 return nil, err 342 } 343 344 var response BulkDeleteTagsResponse 345 var httpResponse *http.Response 346 httpResponse, err = client.Call(ctx, &httpRequest) 347 defer common.CloseBodyIfValid(httpResponse) 348 response.RawResponse = httpResponse 349 if err != nil { 350 return response, err 351 } 352 353 err = common.UnmarshalResponse(httpResponse, &response) 354 return response, err 355} 356 357// BulkMoveResources Moves multiple resources from one compartment to another. All resources must be in the same compartment. 358// This API can only be invoked from the tenancy's home region (https://docs.cloud.oracle.com/Content/Identity/Tasks/managingregions.htm#Home). 359// To move resources, you must have the appropriate permissions to move the resource in both the source and target 360// compartments. This operation creates a WorkRequest. 361// Use the GetWorkRequest API to monitor the status of the bulk action. 362func (client IdentityClient) BulkMoveResources(ctx context.Context, request BulkMoveResourcesRequest) (response BulkMoveResourcesResponse, err error) { 363 var ociResponse common.OCIResponse 364 policy := common.NoRetryPolicy() 365 if request.RetryPolicy() != nil { 366 policy = *request.RetryPolicy() 367 } 368 369 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 370 request.OpcRetryToken = common.String(common.RetryToken()) 371 } 372 373 ociResponse, err = common.Retry(ctx, request, client.bulkMoveResources, policy) 374 if err != nil { 375 if ociResponse != nil { 376 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 377 opcRequestId := httpResponse.Header.Get("opc-request-id") 378 response = BulkMoveResourcesResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 379 } else { 380 response = BulkMoveResourcesResponse{} 381 } 382 } 383 return 384 } 385 if convertedResponse, ok := ociResponse.(BulkMoveResourcesResponse); ok { 386 response = convertedResponse 387 } else { 388 err = fmt.Errorf("failed to convert OCIResponse into BulkMoveResourcesResponse") 389 } 390 return 391} 392 393// bulkMoveResources implements the OCIOperation interface (enables retrying operations) 394func (client IdentityClient) bulkMoveResources(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 395 httpRequest, err := request.HTTPRequest(http.MethodPost, "/compartments/{compartmentId}/actions/bulkMoveResources") 396 if err != nil { 397 return nil, err 398 } 399 400 var response BulkMoveResourcesResponse 401 var httpResponse *http.Response 402 httpResponse, err = client.Call(ctx, &httpRequest) 403 defer common.CloseBodyIfValid(httpResponse) 404 response.RawResponse = httpResponse 405 if err != nil { 406 return response, err 407 } 408 409 err = common.UnmarshalResponse(httpResponse, &response) 410 return response, err 411} 412 413// CascadeDeleteTagNamespace Deletes the specified tag namespace. This operation triggers a process that removes all of the tags 414// defined in the specified tag namespace from all resources in your tenancy and then deletes the tag namespace. 415// After you start the delete operation: 416// * New tag key definitions cannot be created under the namespace. 417// * The state of the tag namespace changes to DELETING. 418// * Tag removal from the resources begins. 419// This process can take up to 48 hours depending on the number of tag definitions in the namespace, the number of resources 420// that are tagged, and the locations of the regions in which those resources reside. 421// After all tags are removed, the state changes to DELETED. You cannot restore a deleted tag namespace. After the deleted tag namespace 422// changes its state to DELETED, you can use the name of the deleted tag namespace again. 423// After you start this operation, you cannot start either the DeleteTag or the BulkDeleteTags operation until this process completes. 424// To delete a tag namespace, you must first retire it. Use UpdateTagNamespace 425// to retire a tag namespace. 426func (client IdentityClient) CascadeDeleteTagNamespace(ctx context.Context, request CascadeDeleteTagNamespaceRequest) (response CascadeDeleteTagNamespaceResponse, err error) { 427 var ociResponse common.OCIResponse 428 policy := common.NoRetryPolicy() 429 if request.RetryPolicy() != nil { 430 policy = *request.RetryPolicy() 431 } 432 433 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 434 request.OpcRetryToken = common.String(common.RetryToken()) 435 } 436 437 ociResponse, err = common.Retry(ctx, request, client.cascadeDeleteTagNamespace, policy) 438 if err != nil { 439 if ociResponse != nil { 440 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 441 opcRequestId := httpResponse.Header.Get("opc-request-id") 442 response = CascadeDeleteTagNamespaceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 443 } else { 444 response = CascadeDeleteTagNamespaceResponse{} 445 } 446 } 447 return 448 } 449 if convertedResponse, ok := ociResponse.(CascadeDeleteTagNamespaceResponse); ok { 450 response = convertedResponse 451 } else { 452 err = fmt.Errorf("failed to convert OCIResponse into CascadeDeleteTagNamespaceResponse") 453 } 454 return 455} 456 457// cascadeDeleteTagNamespace implements the OCIOperation interface (enables retrying operations) 458func (client IdentityClient) cascadeDeleteTagNamespace(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 459 httpRequest, err := request.HTTPRequest(http.MethodPost, "/tagNamespaces/{tagNamespaceId}/actions/cascadeDelete") 460 if err != nil { 461 return nil, err 462 } 463 464 var response CascadeDeleteTagNamespaceResponse 465 var httpResponse *http.Response 466 httpResponse, err = client.Call(ctx, &httpRequest) 467 defer common.CloseBodyIfValid(httpResponse) 468 response.RawResponse = httpResponse 469 if err != nil { 470 return response, err 471 } 472 473 err = common.UnmarshalResponse(httpResponse, &response) 474 return response, err 475} 476 477// ChangeTagNamespaceCompartment Moves the specified tag namespace to the specified compartment within the same tenancy. 478// To move the tag namespace, you must have the manage tag-namespaces permission on both compartments. 479// For more information about IAM policies, see Details for IAM (https://docs.cloud.oracle.com/Content/Identity/Reference/iampolicyreference.htm). 480// Moving a tag namespace moves all the tag key definitions contained in the tag namespace. 481func (client IdentityClient) ChangeTagNamespaceCompartment(ctx context.Context, request ChangeTagNamespaceCompartmentRequest) (response ChangeTagNamespaceCompartmentResponse, err error) { 482 var ociResponse common.OCIResponse 483 policy := common.NoRetryPolicy() 484 if request.RetryPolicy() != nil { 485 policy = *request.RetryPolicy() 486 } 487 488 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 489 request.OpcRetryToken = common.String(common.RetryToken()) 490 } 491 492 ociResponse, err = common.Retry(ctx, request, client.changeTagNamespaceCompartment, policy) 493 if err != nil { 494 if ociResponse != nil { 495 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 496 opcRequestId := httpResponse.Header.Get("opc-request-id") 497 response = ChangeTagNamespaceCompartmentResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 498 } else { 499 response = ChangeTagNamespaceCompartmentResponse{} 500 } 501 } 502 return 503 } 504 if convertedResponse, ok := ociResponse.(ChangeTagNamespaceCompartmentResponse); ok { 505 response = convertedResponse 506 } else { 507 err = fmt.Errorf("failed to convert OCIResponse into ChangeTagNamespaceCompartmentResponse") 508 } 509 return 510} 511 512// changeTagNamespaceCompartment implements the OCIOperation interface (enables retrying operations) 513func (client IdentityClient) changeTagNamespaceCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 514 httpRequest, err := request.HTTPRequest(http.MethodPost, "/tagNamespaces/{tagNamespaceId}/actions/changeCompartment") 515 if err != nil { 516 return nil, err 517 } 518 519 var response ChangeTagNamespaceCompartmentResponse 520 var httpResponse *http.Response 521 httpResponse, err = client.Call(ctx, &httpRequest) 522 defer common.CloseBodyIfValid(httpResponse) 523 response.RawResponse = httpResponse 524 if err != nil { 525 return response, err 526 } 527 528 err = common.UnmarshalResponse(httpResponse, &response) 529 return response, err 530} 531 532// CreateAuthToken Creates a new auth token for the specified user. For information about what auth tokens are for, see 533// Managing User Credentials (https://docs.cloud.oracle.com/Content/Identity/Tasks/managingcredentials.htm). 534// You must specify a *description* for the auth token (although it can be an empty string). It does not 535// have to be unique, and you can change it anytime with 536// UpdateAuthToken. 537// Every user has permission to create an auth token for *their own user ID*. An administrator in your organization 538// does not need to write a policy to give users this ability. To compare, administrators who have permission to the 539// tenancy can use this operation to create an auth token for any user, including themselves. 540func (client IdentityClient) CreateAuthToken(ctx context.Context, request CreateAuthTokenRequest) (response CreateAuthTokenResponse, err error) { 541 var ociResponse common.OCIResponse 542 policy := common.NoRetryPolicy() 543 if request.RetryPolicy() != nil { 544 policy = *request.RetryPolicy() 545 } 546 547 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 548 request.OpcRetryToken = common.String(common.RetryToken()) 549 } 550 551 ociResponse, err = common.Retry(ctx, request, client.createAuthToken, policy) 552 if err != nil { 553 if ociResponse != nil { 554 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 555 opcRequestId := httpResponse.Header.Get("opc-request-id") 556 response = CreateAuthTokenResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 557 } else { 558 response = CreateAuthTokenResponse{} 559 } 560 } 561 return 562 } 563 if convertedResponse, ok := ociResponse.(CreateAuthTokenResponse); ok { 564 response = convertedResponse 565 } else { 566 err = fmt.Errorf("failed to convert OCIResponse into CreateAuthTokenResponse") 567 } 568 return 569} 570 571// createAuthToken implements the OCIOperation interface (enables retrying operations) 572func (client IdentityClient) createAuthToken(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 573 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/authTokens") 574 if err != nil { 575 return nil, err 576 } 577 578 var response CreateAuthTokenResponse 579 var httpResponse *http.Response 580 httpResponse, err = client.Call(ctx, &httpRequest) 581 defer common.CloseBodyIfValid(httpResponse) 582 response.RawResponse = httpResponse 583 if err != nil { 584 return response, err 585 } 586 587 err = common.UnmarshalResponse(httpResponse, &response) 588 return response, err 589} 590 591// CreateCompartment Creates a new compartment in the specified compartment. 592// **Important:** Compartments cannot be deleted. 593// Specify the parent compartment's OCID as the compartment ID in the request object. Remember that the tenancy 594// is simply the root compartment. For information about OCIDs, see 595// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 596// You must also specify a *name* for the compartment, which must be unique across all compartments in 597// your tenancy. You can use this name or the OCID when writing policies that apply 598// to the compartment. For more information about policies, see 599// How Policies Work (https://docs.cloud.oracle.com/Content/Identity/Concepts/policies.htm). 600// You must also specify a *description* for the compartment (although it can be an empty string). It does 601// not have to be unique, and you can change it anytime with 602// UpdateCompartment. 603// After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the 604// object, first make sure its `lifecycleState` has changed to ACTIVE. 605func (client IdentityClient) CreateCompartment(ctx context.Context, request CreateCompartmentRequest) (response CreateCompartmentResponse, err error) { 606 var ociResponse common.OCIResponse 607 policy := common.NoRetryPolicy() 608 if request.RetryPolicy() != nil { 609 policy = *request.RetryPolicy() 610 } 611 612 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 613 request.OpcRetryToken = common.String(common.RetryToken()) 614 } 615 616 ociResponse, err = common.Retry(ctx, request, client.createCompartment, policy) 617 if err != nil { 618 if ociResponse != nil { 619 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 620 opcRequestId := httpResponse.Header.Get("opc-request-id") 621 response = CreateCompartmentResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 622 } else { 623 response = CreateCompartmentResponse{} 624 } 625 } 626 return 627 } 628 if convertedResponse, ok := ociResponse.(CreateCompartmentResponse); ok { 629 response = convertedResponse 630 } else { 631 err = fmt.Errorf("failed to convert OCIResponse into CreateCompartmentResponse") 632 } 633 return 634} 635 636// createCompartment implements the OCIOperation interface (enables retrying operations) 637func (client IdentityClient) createCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 638 httpRequest, err := request.HTTPRequest(http.MethodPost, "/compartments") 639 if err != nil { 640 return nil, err 641 } 642 643 var response CreateCompartmentResponse 644 var httpResponse *http.Response 645 httpResponse, err = client.Call(ctx, &httpRequest) 646 defer common.CloseBodyIfValid(httpResponse) 647 response.RawResponse = httpResponse 648 if err != nil { 649 return response, err 650 } 651 652 err = common.UnmarshalResponse(httpResponse, &response) 653 return response, err 654} 655 656// CreateCustomerSecretKey Creates a new secret key for the specified user. Secret keys are used for authentication with the Object Storage Service's Amazon S3 657// compatible API. For information, see 658// Managing User Credentials (https://docs.cloud.oracle.com/Content/Identity/Tasks/managingcredentials.htm). 659// You must specify a *description* for the secret key (although it can be an empty string). It does not 660// have to be unique, and you can change it anytime with 661// UpdateCustomerSecretKey. 662// Every user has permission to create a secret key for *their own user ID*. An administrator in your organization 663// does not need to write a policy to give users this ability. To compare, administrators who have permission to the 664// tenancy can use this operation to create a secret key for any user, including themselves. 665func (client IdentityClient) CreateCustomerSecretKey(ctx context.Context, request CreateCustomerSecretKeyRequest) (response CreateCustomerSecretKeyResponse, err error) { 666 var ociResponse common.OCIResponse 667 policy := common.NoRetryPolicy() 668 if request.RetryPolicy() != nil { 669 policy = *request.RetryPolicy() 670 } 671 672 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 673 request.OpcRetryToken = common.String(common.RetryToken()) 674 } 675 676 ociResponse, err = common.Retry(ctx, request, client.createCustomerSecretKey, policy) 677 if err != nil { 678 if ociResponse != nil { 679 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 680 opcRequestId := httpResponse.Header.Get("opc-request-id") 681 response = CreateCustomerSecretKeyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 682 } else { 683 response = CreateCustomerSecretKeyResponse{} 684 } 685 } 686 return 687 } 688 if convertedResponse, ok := ociResponse.(CreateCustomerSecretKeyResponse); ok { 689 response = convertedResponse 690 } else { 691 err = fmt.Errorf("failed to convert OCIResponse into CreateCustomerSecretKeyResponse") 692 } 693 return 694} 695 696// createCustomerSecretKey implements the OCIOperation interface (enables retrying operations) 697func (client IdentityClient) createCustomerSecretKey(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 698 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/customerSecretKeys") 699 if err != nil { 700 return nil, err 701 } 702 703 var response CreateCustomerSecretKeyResponse 704 var httpResponse *http.Response 705 httpResponse, err = client.Call(ctx, &httpRequest) 706 defer common.CloseBodyIfValid(httpResponse) 707 response.RawResponse = httpResponse 708 if err != nil { 709 return response, err 710 } 711 712 err = common.UnmarshalResponse(httpResponse, &response) 713 return response, err 714} 715 716// CreateDynamicGroup Creates a new dynamic group in your tenancy. 717// You must specify your tenancy's OCID as the compartment ID in the request object (remember that the tenancy 718// is simply the root compartment). Notice that IAM resources (users, groups, compartments, and some policies) 719// reside within the tenancy itself, unlike cloud resources such as compute instances, which typically 720// reside within compartments inside the tenancy. For information about OCIDs, see 721// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 722// You must also specify a *name* for the dynamic group, which must be unique across all dynamic groups in your 723// tenancy, and cannot be changed. Note that this name has to be also unique across all groups in your tenancy. 724// You can use this name or the OCID when writing policies that apply to the dynamic group. For more information 725// about policies, see How Policies Work (https://docs.cloud.oracle.com/Content/Identity/Concepts/policies.htm). 726// You must also specify a *description* for the dynamic group (although it can be an empty string). It does not 727// have to be unique, and you can change it anytime with UpdateDynamicGroup. 728// After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the 729// object, first make sure its `lifecycleState` has changed to ACTIVE. 730func (client IdentityClient) CreateDynamicGroup(ctx context.Context, request CreateDynamicGroupRequest) (response CreateDynamicGroupResponse, err error) { 731 var ociResponse common.OCIResponse 732 policy := common.NoRetryPolicy() 733 if request.RetryPolicy() != nil { 734 policy = *request.RetryPolicy() 735 } 736 737 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 738 request.OpcRetryToken = common.String(common.RetryToken()) 739 } 740 741 ociResponse, err = common.Retry(ctx, request, client.createDynamicGroup, policy) 742 if err != nil { 743 if ociResponse != nil { 744 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 745 opcRequestId := httpResponse.Header.Get("opc-request-id") 746 response = CreateDynamicGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 747 } else { 748 response = CreateDynamicGroupResponse{} 749 } 750 } 751 return 752 } 753 if convertedResponse, ok := ociResponse.(CreateDynamicGroupResponse); ok { 754 response = convertedResponse 755 } else { 756 err = fmt.Errorf("failed to convert OCIResponse into CreateDynamicGroupResponse") 757 } 758 return 759} 760 761// createDynamicGroup implements the OCIOperation interface (enables retrying operations) 762func (client IdentityClient) createDynamicGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 763 httpRequest, err := request.HTTPRequest(http.MethodPost, "/dynamicGroups") 764 if err != nil { 765 return nil, err 766 } 767 768 var response CreateDynamicGroupResponse 769 var httpResponse *http.Response 770 httpResponse, err = client.Call(ctx, &httpRequest) 771 defer common.CloseBodyIfValid(httpResponse) 772 response.RawResponse = httpResponse 773 if err != nil { 774 return response, err 775 } 776 777 err = common.UnmarshalResponse(httpResponse, &response) 778 return response, err 779} 780 781// CreateGroup Creates a new group in your tenancy. 782// You must specify your tenancy's OCID as the compartment ID in the request object (remember that the tenancy 783// is simply the root compartment). Notice that IAM resources (users, groups, compartments, and some policies) 784// reside within the tenancy itself, unlike cloud resources such as compute instances, which typically 785// reside within compartments inside the tenancy. For information about OCIDs, see 786// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 787// You must also specify a *name* for the group, which must be unique across all groups in your tenancy and 788// cannot be changed. You can use this name or the OCID when writing policies that apply to the group. For more 789// information about policies, see How Policies Work (https://docs.cloud.oracle.com/Content/Identity/Concepts/policies.htm). 790// You must also specify a *description* for the group (although it can be an empty string). It does not 791// have to be unique, and you can change it anytime with UpdateGroup. 792// After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the 793// object, first make sure its `lifecycleState` has changed to ACTIVE. 794// After creating the group, you need to put users in it and write policies for it. 795// See AddUserToGroup and 796// CreatePolicy. 797func (client IdentityClient) CreateGroup(ctx context.Context, request CreateGroupRequest) (response CreateGroupResponse, err error) { 798 var ociResponse common.OCIResponse 799 policy := common.NoRetryPolicy() 800 if request.RetryPolicy() != nil { 801 policy = *request.RetryPolicy() 802 } 803 804 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 805 request.OpcRetryToken = common.String(common.RetryToken()) 806 } 807 808 ociResponse, err = common.Retry(ctx, request, client.createGroup, policy) 809 if err != nil { 810 if ociResponse != nil { 811 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 812 opcRequestId := httpResponse.Header.Get("opc-request-id") 813 response = CreateGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 814 } else { 815 response = CreateGroupResponse{} 816 } 817 } 818 return 819 } 820 if convertedResponse, ok := ociResponse.(CreateGroupResponse); ok { 821 response = convertedResponse 822 } else { 823 err = fmt.Errorf("failed to convert OCIResponse into CreateGroupResponse") 824 } 825 return 826} 827 828// createGroup implements the OCIOperation interface (enables retrying operations) 829func (client IdentityClient) createGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 830 httpRequest, err := request.HTTPRequest(http.MethodPost, "/groups") 831 if err != nil { 832 return nil, err 833 } 834 835 var response CreateGroupResponse 836 var httpResponse *http.Response 837 httpResponse, err = client.Call(ctx, &httpRequest) 838 defer common.CloseBodyIfValid(httpResponse) 839 response.RawResponse = httpResponse 840 if err != nil { 841 return response, err 842 } 843 844 err = common.UnmarshalResponse(httpResponse, &response) 845 return response, err 846} 847 848// CreateIdentityProvider Creates a new identity provider in your tenancy. For more information, see 849// Identity Providers and Federation (https://docs.cloud.oracle.com/Content/Identity/Concepts/federation.htm). 850// You must specify your tenancy's OCID as the compartment ID in the request object. 851// Remember that the tenancy is simply the root compartment. For information about 852// OCIDs, see Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 853// You must also specify a *name* for the `IdentityProvider`, which must be unique 854// across all `IdentityProvider` objects in your tenancy and cannot be changed. 855// You must also specify a *description* for the `IdentityProvider` (although 856// it can be an empty string). It does not have to be unique, and you can change 857// it anytime with 858// UpdateIdentityProvider. 859// After you send your request, the new object's `lifecycleState` will temporarily 860// be CREATING. Before using the object, first make sure its `lifecycleState` has 861// changed to ACTIVE. 862func (client IdentityClient) CreateIdentityProvider(ctx context.Context, request CreateIdentityProviderRequest) (response CreateIdentityProviderResponse, err error) { 863 var ociResponse common.OCIResponse 864 policy := common.NoRetryPolicy() 865 if request.RetryPolicy() != nil { 866 policy = *request.RetryPolicy() 867 } 868 869 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 870 request.OpcRetryToken = common.String(common.RetryToken()) 871 } 872 873 ociResponse, err = common.Retry(ctx, request, client.createIdentityProvider, policy) 874 if err != nil { 875 if ociResponse != nil { 876 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 877 opcRequestId := httpResponse.Header.Get("opc-request-id") 878 response = CreateIdentityProviderResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 879 } else { 880 response = CreateIdentityProviderResponse{} 881 } 882 } 883 return 884 } 885 if convertedResponse, ok := ociResponse.(CreateIdentityProviderResponse); ok { 886 response = convertedResponse 887 } else { 888 err = fmt.Errorf("failed to convert OCIResponse into CreateIdentityProviderResponse") 889 } 890 return 891} 892 893// createIdentityProvider implements the OCIOperation interface (enables retrying operations) 894func (client IdentityClient) createIdentityProvider(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 895 httpRequest, err := request.HTTPRequest(http.MethodPost, "/identityProviders") 896 if err != nil { 897 return nil, err 898 } 899 900 var response CreateIdentityProviderResponse 901 var httpResponse *http.Response 902 httpResponse, err = client.Call(ctx, &httpRequest) 903 defer common.CloseBodyIfValid(httpResponse) 904 response.RawResponse = httpResponse 905 if err != nil { 906 return response, err 907 } 908 909 err = common.UnmarshalResponseWithPolymorphicBody(httpResponse, &response, &identityprovider{}) 910 return response, err 911} 912 913// CreateIdpGroupMapping Creates a single mapping between an IdP group and an IAM Service 914// Group. 915func (client IdentityClient) CreateIdpGroupMapping(ctx context.Context, request CreateIdpGroupMappingRequest) (response CreateIdpGroupMappingResponse, err error) { 916 var ociResponse common.OCIResponse 917 policy := common.NoRetryPolicy() 918 if request.RetryPolicy() != nil { 919 policy = *request.RetryPolicy() 920 } 921 922 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 923 request.OpcRetryToken = common.String(common.RetryToken()) 924 } 925 926 ociResponse, err = common.Retry(ctx, request, client.createIdpGroupMapping, policy) 927 if err != nil { 928 if ociResponse != nil { 929 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 930 opcRequestId := httpResponse.Header.Get("opc-request-id") 931 response = CreateIdpGroupMappingResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 932 } else { 933 response = CreateIdpGroupMappingResponse{} 934 } 935 } 936 return 937 } 938 if convertedResponse, ok := ociResponse.(CreateIdpGroupMappingResponse); ok { 939 response = convertedResponse 940 } else { 941 err = fmt.Errorf("failed to convert OCIResponse into CreateIdpGroupMappingResponse") 942 } 943 return 944} 945 946// createIdpGroupMapping implements the OCIOperation interface (enables retrying operations) 947func (client IdentityClient) createIdpGroupMapping(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 948 httpRequest, err := request.HTTPRequest(http.MethodPost, "/identityProviders/{identityProviderId}/groupMappings") 949 if err != nil { 950 return nil, err 951 } 952 953 var response CreateIdpGroupMappingResponse 954 var httpResponse *http.Response 955 httpResponse, err = client.Call(ctx, &httpRequest) 956 defer common.CloseBodyIfValid(httpResponse) 957 response.RawResponse = httpResponse 958 if err != nil { 959 return response, err 960 } 961 962 err = common.UnmarshalResponse(httpResponse, &response) 963 return response, err 964} 965 966// CreateMfaTotpDevice Creates a new MFA TOTP device for the user. A user can have one MFA TOTP device. 967func (client IdentityClient) CreateMfaTotpDevice(ctx context.Context, request CreateMfaTotpDeviceRequest) (response CreateMfaTotpDeviceResponse, err error) { 968 var ociResponse common.OCIResponse 969 policy := common.NoRetryPolicy() 970 if request.RetryPolicy() != nil { 971 policy = *request.RetryPolicy() 972 } 973 974 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 975 request.OpcRetryToken = common.String(common.RetryToken()) 976 } 977 978 ociResponse, err = common.Retry(ctx, request, client.createMfaTotpDevice, policy) 979 if err != nil { 980 if ociResponse != nil { 981 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 982 opcRequestId := httpResponse.Header.Get("opc-request-id") 983 response = CreateMfaTotpDeviceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 984 } else { 985 response = CreateMfaTotpDeviceResponse{} 986 } 987 } 988 return 989 } 990 if convertedResponse, ok := ociResponse.(CreateMfaTotpDeviceResponse); ok { 991 response = convertedResponse 992 } else { 993 err = fmt.Errorf("failed to convert OCIResponse into CreateMfaTotpDeviceResponse") 994 } 995 return 996} 997 998// createMfaTotpDevice implements the OCIOperation interface (enables retrying operations) 999func (client IdentityClient) createMfaTotpDevice(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1000 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/mfaTotpDevices") 1001 if err != nil { 1002 return nil, err 1003 } 1004 1005 var response CreateMfaTotpDeviceResponse 1006 var httpResponse *http.Response 1007 httpResponse, err = client.Call(ctx, &httpRequest) 1008 defer common.CloseBodyIfValid(httpResponse) 1009 response.RawResponse = httpResponse 1010 if err != nil { 1011 return response, err 1012 } 1013 1014 err = common.UnmarshalResponse(httpResponse, &response) 1015 return response, err 1016} 1017 1018// CreateNetworkSource Creates a new network source in your tenancy. 1019// You must specify your tenancy's OCID as the compartment ID in the request object (remember that the tenancy 1020// is simply the root compartment). Notice that IAM resources (users, groups, compartments, and some policies) 1021// reside within the tenancy itself, unlike cloud resources such as compute instances, which typically 1022// reside within compartments inside the tenancy. For information about OCIDs, see 1023// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 1024// You must also specify a *name* for the network source, which must be unique across all network sources in your 1025// tenancy, and cannot be changed. 1026// You can use this name or the OCID when writing policies that apply to the network source. For more information 1027// about policies, see How Policies Work (https://docs.cloud.oracle.com/Content/Identity/Concepts/policies.htm). 1028// You must also specify a *description* for the network source (although it can be an empty string). It does not 1029// have to be unique, and you can change it anytime with UpdateNetworkSource. 1030// After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the 1031// object, first make sure its `lifecycleState` has changed to ACTIVE. 1032// After your network resource is created, you can use it in policy to restrict access to only requests made from an allowed 1033// IP address specified in your network source. For more information, see Managing Network Sources (https://docs.cloud.oracle.com/Content/Identity/Tasks/managingnetworksources.htm). 1034func (client IdentityClient) CreateNetworkSource(ctx context.Context, request CreateNetworkSourceRequest) (response CreateNetworkSourceResponse, err error) { 1035 var ociResponse common.OCIResponse 1036 policy := common.NoRetryPolicy() 1037 if request.RetryPolicy() != nil { 1038 policy = *request.RetryPolicy() 1039 } 1040 1041 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1042 request.OpcRetryToken = common.String(common.RetryToken()) 1043 } 1044 1045 ociResponse, err = common.Retry(ctx, request, client.createNetworkSource, policy) 1046 if err != nil { 1047 if ociResponse != nil { 1048 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1049 opcRequestId := httpResponse.Header.Get("opc-request-id") 1050 response = CreateNetworkSourceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1051 } else { 1052 response = CreateNetworkSourceResponse{} 1053 } 1054 } 1055 return 1056 } 1057 if convertedResponse, ok := ociResponse.(CreateNetworkSourceResponse); ok { 1058 response = convertedResponse 1059 } else { 1060 err = fmt.Errorf("failed to convert OCIResponse into CreateNetworkSourceResponse") 1061 } 1062 return 1063} 1064 1065// createNetworkSource implements the OCIOperation interface (enables retrying operations) 1066func (client IdentityClient) createNetworkSource(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1067 httpRequest, err := request.HTTPRequest(http.MethodPost, "/networkSources") 1068 if err != nil { 1069 return nil, err 1070 } 1071 1072 var response CreateNetworkSourceResponse 1073 var httpResponse *http.Response 1074 httpResponse, err = client.Call(ctx, &httpRequest) 1075 defer common.CloseBodyIfValid(httpResponse) 1076 response.RawResponse = httpResponse 1077 if err != nil { 1078 return response, err 1079 } 1080 1081 err = common.UnmarshalResponse(httpResponse, &response) 1082 return response, err 1083} 1084 1085// CreateOAuthClientCredential Creates Oauth token for the user 1086func (client IdentityClient) CreateOAuthClientCredential(ctx context.Context, request CreateOAuthClientCredentialRequest) (response CreateOAuthClientCredentialResponse, err error) { 1087 var ociResponse common.OCIResponse 1088 policy := common.NoRetryPolicy() 1089 if request.RetryPolicy() != nil { 1090 policy = *request.RetryPolicy() 1091 } 1092 1093 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1094 request.OpcRetryToken = common.String(common.RetryToken()) 1095 } 1096 1097 ociResponse, err = common.Retry(ctx, request, client.createOAuthClientCredential, policy) 1098 if err != nil { 1099 if ociResponse != nil { 1100 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1101 opcRequestId := httpResponse.Header.Get("opc-request-id") 1102 response = CreateOAuthClientCredentialResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1103 } else { 1104 response = CreateOAuthClientCredentialResponse{} 1105 } 1106 } 1107 return 1108 } 1109 if convertedResponse, ok := ociResponse.(CreateOAuthClientCredentialResponse); ok { 1110 response = convertedResponse 1111 } else { 1112 err = fmt.Errorf("failed to convert OCIResponse into CreateOAuthClientCredentialResponse") 1113 } 1114 return 1115} 1116 1117// createOAuthClientCredential implements the OCIOperation interface (enables retrying operations) 1118func (client IdentityClient) createOAuthClientCredential(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1119 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/oauth2ClientCredentials") 1120 if err != nil { 1121 return nil, err 1122 } 1123 1124 var response CreateOAuthClientCredentialResponse 1125 var httpResponse *http.Response 1126 httpResponse, err = client.Call(ctx, &httpRequest) 1127 defer common.CloseBodyIfValid(httpResponse) 1128 response.RawResponse = httpResponse 1129 if err != nil { 1130 return response, err 1131 } 1132 1133 err = common.UnmarshalResponse(httpResponse, &response) 1134 return response, err 1135} 1136 1137// CreateOrResetUIPassword Creates a new Console one-time password for the specified user. For more information about user 1138// credentials, see User Credentials (https://docs.cloud.oracle.com/Content/Identity/Concepts/usercredentials.htm). 1139// Use this operation after creating a new user, or if a user forgets their password. The new one-time 1140// password is returned to you in the response, and you must securely deliver it to the user. They'll 1141// be prompted to change this password the next time they sign in to the Console. If they don't change 1142// it within 7 days, the password will expire and you'll need to create a new one-time password for the 1143// user. 1144// **Note:** The user's Console login is the unique name you specified when you created the user 1145// (see CreateUser). 1146func (client IdentityClient) CreateOrResetUIPassword(ctx context.Context, request CreateOrResetUIPasswordRequest) (response CreateOrResetUIPasswordResponse, err error) { 1147 var ociResponse common.OCIResponse 1148 policy := common.NoRetryPolicy() 1149 if request.RetryPolicy() != nil { 1150 policy = *request.RetryPolicy() 1151 } 1152 1153 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1154 request.OpcRetryToken = common.String(common.RetryToken()) 1155 } 1156 1157 ociResponse, err = common.Retry(ctx, request, client.createOrResetUIPassword, policy) 1158 if err != nil { 1159 if ociResponse != nil { 1160 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1161 opcRequestId := httpResponse.Header.Get("opc-request-id") 1162 response = CreateOrResetUIPasswordResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1163 } else { 1164 response = CreateOrResetUIPasswordResponse{} 1165 } 1166 } 1167 return 1168 } 1169 if convertedResponse, ok := ociResponse.(CreateOrResetUIPasswordResponse); ok { 1170 response = convertedResponse 1171 } else { 1172 err = fmt.Errorf("failed to convert OCIResponse into CreateOrResetUIPasswordResponse") 1173 } 1174 return 1175} 1176 1177// createOrResetUIPassword implements the OCIOperation interface (enables retrying operations) 1178func (client IdentityClient) createOrResetUIPassword(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1179 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/uiPassword") 1180 if err != nil { 1181 return nil, err 1182 } 1183 1184 var response CreateOrResetUIPasswordResponse 1185 var httpResponse *http.Response 1186 httpResponse, err = client.Call(ctx, &httpRequest) 1187 defer common.CloseBodyIfValid(httpResponse) 1188 response.RawResponse = httpResponse 1189 if err != nil { 1190 return response, err 1191 } 1192 1193 err = common.UnmarshalResponse(httpResponse, &response) 1194 return response, err 1195} 1196 1197// CreatePolicy Creates a new policy in the specified compartment (either the tenancy or another of your compartments). 1198// If you're new to policies, see Getting Started with Policies (https://docs.cloud.oracle.com/Content/Identity/Concepts/policygetstarted.htm). 1199// You must specify a *name* for the policy, which must be unique across all policies in your tenancy 1200// and cannot be changed. 1201// You must also specify a *description* for the policy (although it can be an empty string). It does not 1202// have to be unique, and you can change it anytime with UpdatePolicy. 1203// You must specify one or more policy statements in the statements array. For information about writing 1204// policies, see How Policies Work (https://docs.cloud.oracle.com/Content/Identity/Concepts/policies.htm) and 1205// Common Policies (https://docs.cloud.oracle.com/Content/Identity/Concepts/commonpolicies.htm). 1206// After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using the 1207// object, first make sure its `lifecycleState` has changed to ACTIVE. 1208// New policies take effect typically within 10 seconds. 1209func (client IdentityClient) CreatePolicy(ctx context.Context, request CreatePolicyRequest) (response CreatePolicyResponse, err error) { 1210 var ociResponse common.OCIResponse 1211 policy := common.NoRetryPolicy() 1212 if request.RetryPolicy() != nil { 1213 policy = *request.RetryPolicy() 1214 } 1215 1216 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1217 request.OpcRetryToken = common.String(common.RetryToken()) 1218 } 1219 1220 ociResponse, err = common.Retry(ctx, request, client.createPolicy, policy) 1221 if err != nil { 1222 if ociResponse != nil { 1223 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1224 opcRequestId := httpResponse.Header.Get("opc-request-id") 1225 response = CreatePolicyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1226 } else { 1227 response = CreatePolicyResponse{} 1228 } 1229 } 1230 return 1231 } 1232 if convertedResponse, ok := ociResponse.(CreatePolicyResponse); ok { 1233 response = convertedResponse 1234 } else { 1235 err = fmt.Errorf("failed to convert OCIResponse into CreatePolicyResponse") 1236 } 1237 return 1238} 1239 1240// createPolicy implements the OCIOperation interface (enables retrying operations) 1241func (client IdentityClient) createPolicy(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1242 httpRequest, err := request.HTTPRequest(http.MethodPost, "/policies") 1243 if err != nil { 1244 return nil, err 1245 } 1246 1247 var response CreatePolicyResponse 1248 var httpResponse *http.Response 1249 httpResponse, err = client.Call(ctx, &httpRequest) 1250 defer common.CloseBodyIfValid(httpResponse) 1251 response.RawResponse = httpResponse 1252 if err != nil { 1253 return response, err 1254 } 1255 1256 err = common.UnmarshalResponse(httpResponse, &response) 1257 return response, err 1258} 1259 1260// CreateRegionSubscription Creates a subscription to a region for a tenancy. 1261func (client IdentityClient) CreateRegionSubscription(ctx context.Context, request CreateRegionSubscriptionRequest) (response CreateRegionSubscriptionResponse, err error) { 1262 var ociResponse common.OCIResponse 1263 policy := common.NoRetryPolicy() 1264 if request.RetryPolicy() != nil { 1265 policy = *request.RetryPolicy() 1266 } 1267 1268 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1269 request.OpcRetryToken = common.String(common.RetryToken()) 1270 } 1271 1272 ociResponse, err = common.Retry(ctx, request, client.createRegionSubscription, policy) 1273 if err != nil { 1274 if ociResponse != nil { 1275 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1276 opcRequestId := httpResponse.Header.Get("opc-request-id") 1277 response = CreateRegionSubscriptionResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1278 } else { 1279 response = CreateRegionSubscriptionResponse{} 1280 } 1281 } 1282 return 1283 } 1284 if convertedResponse, ok := ociResponse.(CreateRegionSubscriptionResponse); ok { 1285 response = convertedResponse 1286 } else { 1287 err = fmt.Errorf("failed to convert OCIResponse into CreateRegionSubscriptionResponse") 1288 } 1289 return 1290} 1291 1292// createRegionSubscription implements the OCIOperation interface (enables retrying operations) 1293func (client IdentityClient) createRegionSubscription(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1294 httpRequest, err := request.HTTPRequest(http.MethodPost, "/tenancies/{tenancyId}/regionSubscriptions") 1295 if err != nil { 1296 return nil, err 1297 } 1298 1299 var response CreateRegionSubscriptionResponse 1300 var httpResponse *http.Response 1301 httpResponse, err = client.Call(ctx, &httpRequest) 1302 defer common.CloseBodyIfValid(httpResponse) 1303 response.RawResponse = httpResponse 1304 if err != nil { 1305 return response, err 1306 } 1307 1308 err = common.UnmarshalResponse(httpResponse, &response) 1309 return response, err 1310} 1311 1312// CreateSmtpCredential Creates a new SMTP credential for the specified user. An SMTP credential has an SMTP user name and an SMTP password. 1313// You must specify a *description* for the SMTP credential (although it can be an empty string). It does not 1314// have to be unique, and you can change it anytime with 1315// UpdateSmtpCredential. 1316func (client IdentityClient) CreateSmtpCredential(ctx context.Context, request CreateSmtpCredentialRequest) (response CreateSmtpCredentialResponse, err error) { 1317 var ociResponse common.OCIResponse 1318 policy := common.NoRetryPolicy() 1319 if request.RetryPolicy() != nil { 1320 policy = *request.RetryPolicy() 1321 } 1322 1323 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1324 request.OpcRetryToken = common.String(common.RetryToken()) 1325 } 1326 1327 ociResponse, err = common.Retry(ctx, request, client.createSmtpCredential, policy) 1328 if err != nil { 1329 if ociResponse != nil { 1330 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1331 opcRequestId := httpResponse.Header.Get("opc-request-id") 1332 response = CreateSmtpCredentialResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1333 } else { 1334 response = CreateSmtpCredentialResponse{} 1335 } 1336 } 1337 return 1338 } 1339 if convertedResponse, ok := ociResponse.(CreateSmtpCredentialResponse); ok { 1340 response = convertedResponse 1341 } else { 1342 err = fmt.Errorf("failed to convert OCIResponse into CreateSmtpCredentialResponse") 1343 } 1344 return 1345} 1346 1347// createSmtpCredential implements the OCIOperation interface (enables retrying operations) 1348func (client IdentityClient) createSmtpCredential(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1349 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/smtpCredentials") 1350 if err != nil { 1351 return nil, err 1352 } 1353 1354 var response CreateSmtpCredentialResponse 1355 var httpResponse *http.Response 1356 httpResponse, err = client.Call(ctx, &httpRequest) 1357 defer common.CloseBodyIfValid(httpResponse) 1358 response.RawResponse = httpResponse 1359 if err != nil { 1360 return response, err 1361 } 1362 1363 err = common.UnmarshalResponse(httpResponse, &response) 1364 return response, err 1365} 1366 1367// CreateSwiftPassword **Deprecated. Use CreateAuthToken instead.** 1368// Creates a new Swift password for the specified user. For information about what Swift passwords are for, see 1369// Managing User Credentials (https://docs.cloud.oracle.com/Content/Identity/Tasks/managingcredentials.htm). 1370// You must specify a *description* for the Swift password (although it can be an empty string). It does not 1371// have to be unique, and you can change it anytime with 1372// UpdateSwiftPassword. 1373// Every user has permission to create a Swift password for *their own user ID*. An administrator in your organization 1374// does not need to write a policy to give users this ability. To compare, administrators who have permission to the 1375// tenancy can use this operation to create a Swift password for any user, including themselves. 1376func (client IdentityClient) CreateSwiftPassword(ctx context.Context, request CreateSwiftPasswordRequest) (response CreateSwiftPasswordResponse, err error) { 1377 var ociResponse common.OCIResponse 1378 policy := common.NoRetryPolicy() 1379 if request.RetryPolicy() != nil { 1380 policy = *request.RetryPolicy() 1381 } 1382 1383 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1384 request.OpcRetryToken = common.String(common.RetryToken()) 1385 } 1386 1387 ociResponse, err = common.Retry(ctx, request, client.createSwiftPassword, policy) 1388 if err != nil { 1389 if ociResponse != nil { 1390 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1391 opcRequestId := httpResponse.Header.Get("opc-request-id") 1392 response = CreateSwiftPasswordResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1393 } else { 1394 response = CreateSwiftPasswordResponse{} 1395 } 1396 } 1397 return 1398 } 1399 if convertedResponse, ok := ociResponse.(CreateSwiftPasswordResponse); ok { 1400 response = convertedResponse 1401 } else { 1402 err = fmt.Errorf("failed to convert OCIResponse into CreateSwiftPasswordResponse") 1403 } 1404 return 1405} 1406 1407// createSwiftPassword implements the OCIOperation interface (enables retrying operations) 1408func (client IdentityClient) createSwiftPassword(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1409 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/swiftPasswords") 1410 if err != nil { 1411 return nil, err 1412 } 1413 1414 var response CreateSwiftPasswordResponse 1415 var httpResponse *http.Response 1416 httpResponse, err = client.Call(ctx, &httpRequest) 1417 defer common.CloseBodyIfValid(httpResponse) 1418 response.RawResponse = httpResponse 1419 if err != nil { 1420 return response, err 1421 } 1422 1423 err = common.UnmarshalResponse(httpResponse, &response) 1424 return response, err 1425} 1426 1427// CreateTag Creates a new tag in the specified tag namespace. 1428// The tag requires either the OCID or the name of the tag namespace that will contain this 1429// tag definition. 1430// You must specify a *name* for the tag, which must be unique across all tags in the tag namespace 1431// and cannot be changed. The name can contain any ASCII character except the space (_) or period (.) characters. 1432// Names are case insensitive. That means, for example, "myTag" and "mytag" are not allowed in the same namespace. 1433// If you specify a name that's already in use in the tag namespace, a 409 error is returned. 1434// The tag must have a *description*. It does not have to be unique, and you can change it with 1435// UpdateTag. 1436// The tag must have a value type, which is specified with a validator. Tags can use either a 1437// static value or a list of possible values. Static values are entered by a user applying the tag 1438// to a resource. Lists are created by you and the user must apply a value from the list. Lists 1439// are validiated. 1440// * If no `validator` is set, the user applying the tag to a resource can type in a static 1441// value or leave the tag value empty. 1442// * If a `validator` is set, the user applying the tag to a resource must select from a list 1443// of values that you supply with EnumTagDefinitionValidator. 1444func (client IdentityClient) CreateTag(ctx context.Context, request CreateTagRequest) (response CreateTagResponse, err error) { 1445 var ociResponse common.OCIResponse 1446 policy := common.NoRetryPolicy() 1447 if request.RetryPolicy() != nil { 1448 policy = *request.RetryPolicy() 1449 } 1450 1451 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1452 request.OpcRetryToken = common.String(common.RetryToken()) 1453 } 1454 1455 ociResponse, err = common.Retry(ctx, request, client.createTag, policy) 1456 if err != nil { 1457 if ociResponse != nil { 1458 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1459 opcRequestId := httpResponse.Header.Get("opc-request-id") 1460 response = CreateTagResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1461 } else { 1462 response = CreateTagResponse{} 1463 } 1464 } 1465 return 1466 } 1467 if convertedResponse, ok := ociResponse.(CreateTagResponse); ok { 1468 response = convertedResponse 1469 } else { 1470 err = fmt.Errorf("failed to convert OCIResponse into CreateTagResponse") 1471 } 1472 return 1473} 1474 1475// createTag implements the OCIOperation interface (enables retrying operations) 1476func (client IdentityClient) createTag(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1477 httpRequest, err := request.HTTPRequest(http.MethodPost, "/tagNamespaces/{tagNamespaceId}/tags") 1478 if err != nil { 1479 return nil, err 1480 } 1481 1482 var response CreateTagResponse 1483 var httpResponse *http.Response 1484 httpResponse, err = client.Call(ctx, &httpRequest) 1485 defer common.CloseBodyIfValid(httpResponse) 1486 response.RawResponse = httpResponse 1487 if err != nil { 1488 return response, err 1489 } 1490 1491 err = common.UnmarshalResponse(httpResponse, &response) 1492 return response, err 1493} 1494 1495// CreateTagDefault Creates a new tag default in the specified compartment for the specified tag definition. 1496// If you specify that a value is required, a value is set during resource creation (either by 1497// the user creating the resource or another tag defualt). If no value is set, resource creation 1498// is blocked. 1499// * If the `isRequired` flag is set to "true", the value is set during resource creation. 1500// * If the `isRequired` flag is set to "false", the value you enter is set during resource creation. 1501func (client IdentityClient) CreateTagDefault(ctx context.Context, request CreateTagDefaultRequest) (response CreateTagDefaultResponse, err error) { 1502 var ociResponse common.OCIResponse 1503 policy := common.NoRetryPolicy() 1504 if request.RetryPolicy() != nil { 1505 policy = *request.RetryPolicy() 1506 } 1507 1508 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1509 request.OpcRetryToken = common.String(common.RetryToken()) 1510 } 1511 1512 ociResponse, err = common.Retry(ctx, request, client.createTagDefault, policy) 1513 if err != nil { 1514 if ociResponse != nil { 1515 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1516 opcRequestId := httpResponse.Header.Get("opc-request-id") 1517 response = CreateTagDefaultResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1518 } else { 1519 response = CreateTagDefaultResponse{} 1520 } 1521 } 1522 return 1523 } 1524 if convertedResponse, ok := ociResponse.(CreateTagDefaultResponse); ok { 1525 response = convertedResponse 1526 } else { 1527 err = fmt.Errorf("failed to convert OCIResponse into CreateTagDefaultResponse") 1528 } 1529 return 1530} 1531 1532// createTagDefault implements the OCIOperation interface (enables retrying operations) 1533func (client IdentityClient) createTagDefault(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1534 httpRequest, err := request.HTTPRequest(http.MethodPost, "/tagDefaults") 1535 if err != nil { 1536 return nil, err 1537 } 1538 1539 var response CreateTagDefaultResponse 1540 var httpResponse *http.Response 1541 httpResponse, err = client.Call(ctx, &httpRequest) 1542 defer common.CloseBodyIfValid(httpResponse) 1543 response.RawResponse = httpResponse 1544 if err != nil { 1545 return response, err 1546 } 1547 1548 err = common.UnmarshalResponse(httpResponse, &response) 1549 return response, err 1550} 1551 1552// CreateTagNamespace Creates a new tag namespace in the specified compartment. 1553// You must specify the compartment ID in the request object (remember that the tenancy is simply the root 1554// compartment). 1555// You must also specify a *name* for the namespace, which must be unique across all namespaces in your tenancy 1556// and cannot be changed. The name can contain any ASCII character except the space (_) or period (.). 1557// Names are case insensitive. That means, for example, "myNamespace" and "mynamespace" are not allowed 1558// in the same tenancy. Once you created a namespace, you cannot change the name. 1559// If you specify a name that's already in use in the tenancy, a 409 error is returned. 1560// You must also specify a *description* for the namespace. 1561// It does not have to be unique, and you can change it with 1562// UpdateTagNamespace. 1563func (client IdentityClient) CreateTagNamespace(ctx context.Context, request CreateTagNamespaceRequest) (response CreateTagNamespaceResponse, err error) { 1564 var ociResponse common.OCIResponse 1565 policy := common.NoRetryPolicy() 1566 if request.RetryPolicy() != nil { 1567 policy = *request.RetryPolicy() 1568 } 1569 1570 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1571 request.OpcRetryToken = common.String(common.RetryToken()) 1572 } 1573 1574 ociResponse, err = common.Retry(ctx, request, client.createTagNamespace, policy) 1575 if err != nil { 1576 if ociResponse != nil { 1577 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1578 opcRequestId := httpResponse.Header.Get("opc-request-id") 1579 response = CreateTagNamespaceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1580 } else { 1581 response = CreateTagNamespaceResponse{} 1582 } 1583 } 1584 return 1585 } 1586 if convertedResponse, ok := ociResponse.(CreateTagNamespaceResponse); ok { 1587 response = convertedResponse 1588 } else { 1589 err = fmt.Errorf("failed to convert OCIResponse into CreateTagNamespaceResponse") 1590 } 1591 return 1592} 1593 1594// createTagNamespace implements the OCIOperation interface (enables retrying operations) 1595func (client IdentityClient) createTagNamespace(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1596 httpRequest, err := request.HTTPRequest(http.MethodPost, "/tagNamespaces") 1597 if err != nil { 1598 return nil, err 1599 } 1600 1601 var response CreateTagNamespaceResponse 1602 var httpResponse *http.Response 1603 httpResponse, err = client.Call(ctx, &httpRequest) 1604 defer common.CloseBodyIfValid(httpResponse) 1605 response.RawResponse = httpResponse 1606 if err != nil { 1607 return response, err 1608 } 1609 1610 err = common.UnmarshalResponse(httpResponse, &response) 1611 return response, err 1612} 1613 1614// CreateUser Creates a new user in your tenancy. For conceptual information about users, your tenancy, and other 1615// IAM Service components, see Overview of the IAM Service (https://docs.cloud.oracle.com/Content/Identity/Concepts/overview.htm). 1616// You must specify your tenancy's OCID as the compartment ID in the request object (remember that the 1617// tenancy is simply the root compartment). Notice that IAM resources (users, groups, compartments, and 1618// some policies) reside within the tenancy itself, unlike cloud resources such as compute instances, 1619// which typically reside within compartments inside the tenancy. For information about OCIDs, see 1620// Resource Identifiers (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm). 1621// You must also specify a *name* for the user, which must be unique across all users in your tenancy 1622// and cannot be changed. Allowed characters: No spaces. Only letters, numerals, hyphens, periods, 1623// underscores, +, and @. If you specify a name that's already in use, you'll get a 409 error. 1624// This name will be the user's login to the Console. You might want to pick a 1625// name that your company's own identity system (e.g., Active Directory, LDAP, etc.) already uses. 1626// If you delete a user and then create a new user with the same name, they'll be considered different 1627// users because they have different OCIDs. 1628// You must also specify a *description* for the user (although it can be an empty string). 1629// It does not have to be unique, and you can change it anytime with 1630// UpdateUser. You can use the field to provide the user's 1631// full name, a description, a nickname, or other information to generally identify the user. 1632// After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before 1633// using the object, first make sure its `lifecycleState` has changed to ACTIVE. 1634// A new user has no permissions until you place the user in one or more groups (see 1635// AddUserToGroup). If the user needs to 1636// access the Console, you need to provide the user a password (see 1637// CreateOrResetUIPassword). 1638// If the user needs to access the Oracle Cloud Infrastructure REST API, you need to upload a 1639// public API signing key for that user (see 1640// Required Keys and OCIDs (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm) and also 1641// UploadApiKey). 1642// **Important:** Make sure to inform the new user which compartment(s) they have access to. 1643func (client IdentityClient) CreateUser(ctx context.Context, request CreateUserRequest) (response CreateUserResponse, err error) { 1644 var ociResponse common.OCIResponse 1645 policy := common.NoRetryPolicy() 1646 if request.RetryPolicy() != nil { 1647 policy = *request.RetryPolicy() 1648 } 1649 1650 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 1651 request.OpcRetryToken = common.String(common.RetryToken()) 1652 } 1653 1654 ociResponse, err = common.Retry(ctx, request, client.createUser, policy) 1655 if err != nil { 1656 if ociResponse != nil { 1657 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1658 opcRequestId := httpResponse.Header.Get("opc-request-id") 1659 response = CreateUserResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1660 } else { 1661 response = CreateUserResponse{} 1662 } 1663 } 1664 return 1665 } 1666 if convertedResponse, ok := ociResponse.(CreateUserResponse); ok { 1667 response = convertedResponse 1668 } else { 1669 err = fmt.Errorf("failed to convert OCIResponse into CreateUserResponse") 1670 } 1671 return 1672} 1673 1674// createUser implements the OCIOperation interface (enables retrying operations) 1675func (client IdentityClient) createUser(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1676 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users") 1677 if err != nil { 1678 return nil, err 1679 } 1680 1681 var response CreateUserResponse 1682 var httpResponse *http.Response 1683 httpResponse, err = client.Call(ctx, &httpRequest) 1684 defer common.CloseBodyIfValid(httpResponse) 1685 response.RawResponse = httpResponse 1686 if err != nil { 1687 return response, err 1688 } 1689 1690 err = common.UnmarshalResponse(httpResponse, &response) 1691 return response, err 1692} 1693 1694// DeleteApiKey Deletes the specified API signing key for the specified user. 1695// Every user has permission to use this operation to delete a key for *their own user ID*. An 1696// administrator in your organization does not need to write a policy to give users this ability. 1697// To compare, administrators who have permission to the tenancy can use this operation to delete 1698// a key for any user, including themselves. 1699func (client IdentityClient) DeleteApiKey(ctx context.Context, request DeleteApiKeyRequest) (response DeleteApiKeyResponse, err error) { 1700 var ociResponse common.OCIResponse 1701 policy := common.NoRetryPolicy() 1702 if request.RetryPolicy() != nil { 1703 policy = *request.RetryPolicy() 1704 } 1705 ociResponse, err = common.Retry(ctx, request, client.deleteApiKey, policy) 1706 if err != nil { 1707 if ociResponse != nil { 1708 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1709 opcRequestId := httpResponse.Header.Get("opc-request-id") 1710 response = DeleteApiKeyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1711 } else { 1712 response = DeleteApiKeyResponse{} 1713 } 1714 } 1715 return 1716 } 1717 if convertedResponse, ok := ociResponse.(DeleteApiKeyResponse); ok { 1718 response = convertedResponse 1719 } else { 1720 err = fmt.Errorf("failed to convert OCIResponse into DeleteApiKeyResponse") 1721 } 1722 return 1723} 1724 1725// deleteApiKey implements the OCIOperation interface (enables retrying operations) 1726func (client IdentityClient) deleteApiKey(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1727 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/users/{userId}/apiKeys/{fingerprint}") 1728 if err != nil { 1729 return nil, err 1730 } 1731 1732 var response DeleteApiKeyResponse 1733 var httpResponse *http.Response 1734 httpResponse, err = client.Call(ctx, &httpRequest) 1735 defer common.CloseBodyIfValid(httpResponse) 1736 response.RawResponse = httpResponse 1737 if err != nil { 1738 return response, err 1739 } 1740 1741 err = common.UnmarshalResponse(httpResponse, &response) 1742 return response, err 1743} 1744 1745// DeleteAuthToken Deletes the specified auth token for the specified user. 1746func (client IdentityClient) DeleteAuthToken(ctx context.Context, request DeleteAuthTokenRequest) (response DeleteAuthTokenResponse, err error) { 1747 var ociResponse common.OCIResponse 1748 policy := common.NoRetryPolicy() 1749 if request.RetryPolicy() != nil { 1750 policy = *request.RetryPolicy() 1751 } 1752 ociResponse, err = common.Retry(ctx, request, client.deleteAuthToken, policy) 1753 if err != nil { 1754 if ociResponse != nil { 1755 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1756 opcRequestId := httpResponse.Header.Get("opc-request-id") 1757 response = DeleteAuthTokenResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1758 } else { 1759 response = DeleteAuthTokenResponse{} 1760 } 1761 } 1762 return 1763 } 1764 if convertedResponse, ok := ociResponse.(DeleteAuthTokenResponse); ok { 1765 response = convertedResponse 1766 } else { 1767 err = fmt.Errorf("failed to convert OCIResponse into DeleteAuthTokenResponse") 1768 } 1769 return 1770} 1771 1772// deleteAuthToken implements the OCIOperation interface (enables retrying operations) 1773func (client IdentityClient) deleteAuthToken(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1774 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/users/{userId}/authTokens/{authTokenId}") 1775 if err != nil { 1776 return nil, err 1777 } 1778 1779 var response DeleteAuthTokenResponse 1780 var httpResponse *http.Response 1781 httpResponse, err = client.Call(ctx, &httpRequest) 1782 defer common.CloseBodyIfValid(httpResponse) 1783 response.RawResponse = httpResponse 1784 if err != nil { 1785 return response, err 1786 } 1787 1788 err = common.UnmarshalResponse(httpResponse, &response) 1789 return response, err 1790} 1791 1792// DeleteCompartment Deletes the specified compartment. The compartment must be empty. 1793func (client IdentityClient) DeleteCompartment(ctx context.Context, request DeleteCompartmentRequest) (response DeleteCompartmentResponse, err error) { 1794 var ociResponse common.OCIResponse 1795 policy := common.NoRetryPolicy() 1796 if request.RetryPolicy() != nil { 1797 policy = *request.RetryPolicy() 1798 } 1799 ociResponse, err = common.Retry(ctx, request, client.deleteCompartment, policy) 1800 if err != nil { 1801 if ociResponse != nil { 1802 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1803 opcRequestId := httpResponse.Header.Get("opc-request-id") 1804 response = DeleteCompartmentResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1805 } else { 1806 response = DeleteCompartmentResponse{} 1807 } 1808 } 1809 return 1810 } 1811 if convertedResponse, ok := ociResponse.(DeleteCompartmentResponse); ok { 1812 response = convertedResponse 1813 } else { 1814 err = fmt.Errorf("failed to convert OCIResponse into DeleteCompartmentResponse") 1815 } 1816 return 1817} 1818 1819// deleteCompartment implements the OCIOperation interface (enables retrying operations) 1820func (client IdentityClient) deleteCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1821 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/compartments/{compartmentId}") 1822 if err != nil { 1823 return nil, err 1824 } 1825 1826 var response DeleteCompartmentResponse 1827 var httpResponse *http.Response 1828 httpResponse, err = client.Call(ctx, &httpRequest) 1829 defer common.CloseBodyIfValid(httpResponse) 1830 response.RawResponse = httpResponse 1831 if err != nil { 1832 return response, err 1833 } 1834 1835 err = common.UnmarshalResponse(httpResponse, &response) 1836 return response, err 1837} 1838 1839// DeleteCustomerSecretKey Deletes the specified secret key for the specified user. 1840func (client IdentityClient) DeleteCustomerSecretKey(ctx context.Context, request DeleteCustomerSecretKeyRequest) (response DeleteCustomerSecretKeyResponse, err error) { 1841 var ociResponse common.OCIResponse 1842 policy := common.NoRetryPolicy() 1843 if request.RetryPolicy() != nil { 1844 policy = *request.RetryPolicy() 1845 } 1846 ociResponse, err = common.Retry(ctx, request, client.deleteCustomerSecretKey, policy) 1847 if err != nil { 1848 if ociResponse != nil { 1849 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1850 opcRequestId := httpResponse.Header.Get("opc-request-id") 1851 response = DeleteCustomerSecretKeyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1852 } else { 1853 response = DeleteCustomerSecretKeyResponse{} 1854 } 1855 } 1856 return 1857 } 1858 if convertedResponse, ok := ociResponse.(DeleteCustomerSecretKeyResponse); ok { 1859 response = convertedResponse 1860 } else { 1861 err = fmt.Errorf("failed to convert OCIResponse into DeleteCustomerSecretKeyResponse") 1862 } 1863 return 1864} 1865 1866// deleteCustomerSecretKey implements the OCIOperation interface (enables retrying operations) 1867func (client IdentityClient) deleteCustomerSecretKey(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1868 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/users/{userId}/customerSecretKeys/{customerSecretKeyId}") 1869 if err != nil { 1870 return nil, err 1871 } 1872 1873 var response DeleteCustomerSecretKeyResponse 1874 var httpResponse *http.Response 1875 httpResponse, err = client.Call(ctx, &httpRequest) 1876 defer common.CloseBodyIfValid(httpResponse) 1877 response.RawResponse = httpResponse 1878 if err != nil { 1879 return response, err 1880 } 1881 1882 err = common.UnmarshalResponse(httpResponse, &response) 1883 return response, err 1884} 1885 1886// DeleteDynamicGroup Deletes the specified dynamic group. 1887func (client IdentityClient) DeleteDynamicGroup(ctx context.Context, request DeleteDynamicGroupRequest) (response DeleteDynamicGroupResponse, err error) { 1888 var ociResponse common.OCIResponse 1889 policy := common.NoRetryPolicy() 1890 if request.RetryPolicy() != nil { 1891 policy = *request.RetryPolicy() 1892 } 1893 ociResponse, err = common.Retry(ctx, request, client.deleteDynamicGroup, policy) 1894 if err != nil { 1895 if ociResponse != nil { 1896 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1897 opcRequestId := httpResponse.Header.Get("opc-request-id") 1898 response = DeleteDynamicGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1899 } else { 1900 response = DeleteDynamicGroupResponse{} 1901 } 1902 } 1903 return 1904 } 1905 if convertedResponse, ok := ociResponse.(DeleteDynamicGroupResponse); ok { 1906 response = convertedResponse 1907 } else { 1908 err = fmt.Errorf("failed to convert OCIResponse into DeleteDynamicGroupResponse") 1909 } 1910 return 1911} 1912 1913// deleteDynamicGroup implements the OCIOperation interface (enables retrying operations) 1914func (client IdentityClient) deleteDynamicGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1915 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/dynamicGroups/{dynamicGroupId}") 1916 if err != nil { 1917 return nil, err 1918 } 1919 1920 var response DeleteDynamicGroupResponse 1921 var httpResponse *http.Response 1922 httpResponse, err = client.Call(ctx, &httpRequest) 1923 defer common.CloseBodyIfValid(httpResponse) 1924 response.RawResponse = httpResponse 1925 if err != nil { 1926 return response, err 1927 } 1928 1929 err = common.UnmarshalResponse(httpResponse, &response) 1930 return response, err 1931} 1932 1933// DeleteGroup Deletes the specified group. The group must be empty. 1934func (client IdentityClient) DeleteGroup(ctx context.Context, request DeleteGroupRequest) (response DeleteGroupResponse, err error) { 1935 var ociResponse common.OCIResponse 1936 policy := common.NoRetryPolicy() 1937 if request.RetryPolicy() != nil { 1938 policy = *request.RetryPolicy() 1939 } 1940 ociResponse, err = common.Retry(ctx, request, client.deleteGroup, policy) 1941 if err != nil { 1942 if ociResponse != nil { 1943 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1944 opcRequestId := httpResponse.Header.Get("opc-request-id") 1945 response = DeleteGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1946 } else { 1947 response = DeleteGroupResponse{} 1948 } 1949 } 1950 return 1951 } 1952 if convertedResponse, ok := ociResponse.(DeleteGroupResponse); ok { 1953 response = convertedResponse 1954 } else { 1955 err = fmt.Errorf("failed to convert OCIResponse into DeleteGroupResponse") 1956 } 1957 return 1958} 1959 1960// deleteGroup implements the OCIOperation interface (enables retrying operations) 1961func (client IdentityClient) deleteGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 1962 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/groups/{groupId}") 1963 if err != nil { 1964 return nil, err 1965 } 1966 1967 var response DeleteGroupResponse 1968 var httpResponse *http.Response 1969 httpResponse, err = client.Call(ctx, &httpRequest) 1970 defer common.CloseBodyIfValid(httpResponse) 1971 response.RawResponse = httpResponse 1972 if err != nil { 1973 return response, err 1974 } 1975 1976 err = common.UnmarshalResponse(httpResponse, &response) 1977 return response, err 1978} 1979 1980// DeleteIdentityProvider Deletes the specified identity provider. The identity provider must not have 1981// any group mappings (see IdpGroupMapping). 1982func (client IdentityClient) DeleteIdentityProvider(ctx context.Context, request DeleteIdentityProviderRequest) (response DeleteIdentityProviderResponse, err error) { 1983 var ociResponse common.OCIResponse 1984 policy := common.NoRetryPolicy() 1985 if request.RetryPolicy() != nil { 1986 policy = *request.RetryPolicy() 1987 } 1988 ociResponse, err = common.Retry(ctx, request, client.deleteIdentityProvider, policy) 1989 if err != nil { 1990 if ociResponse != nil { 1991 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 1992 opcRequestId := httpResponse.Header.Get("opc-request-id") 1993 response = DeleteIdentityProviderResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 1994 } else { 1995 response = DeleteIdentityProviderResponse{} 1996 } 1997 } 1998 return 1999 } 2000 if convertedResponse, ok := ociResponse.(DeleteIdentityProviderResponse); ok { 2001 response = convertedResponse 2002 } else { 2003 err = fmt.Errorf("failed to convert OCIResponse into DeleteIdentityProviderResponse") 2004 } 2005 return 2006} 2007 2008// deleteIdentityProvider implements the OCIOperation interface (enables retrying operations) 2009func (client IdentityClient) deleteIdentityProvider(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2010 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/identityProviders/{identityProviderId}") 2011 if err != nil { 2012 return nil, err 2013 } 2014 2015 var response DeleteIdentityProviderResponse 2016 var httpResponse *http.Response 2017 httpResponse, err = client.Call(ctx, &httpRequest) 2018 defer common.CloseBodyIfValid(httpResponse) 2019 response.RawResponse = httpResponse 2020 if err != nil { 2021 return response, err 2022 } 2023 2024 err = common.UnmarshalResponse(httpResponse, &response) 2025 return response, err 2026} 2027 2028// DeleteIdpGroupMapping Deletes the specified group mapping. 2029func (client IdentityClient) DeleteIdpGroupMapping(ctx context.Context, request DeleteIdpGroupMappingRequest) (response DeleteIdpGroupMappingResponse, err error) { 2030 var ociResponse common.OCIResponse 2031 policy := common.NoRetryPolicy() 2032 if request.RetryPolicy() != nil { 2033 policy = *request.RetryPolicy() 2034 } 2035 ociResponse, err = common.Retry(ctx, request, client.deleteIdpGroupMapping, policy) 2036 if err != nil { 2037 if ociResponse != nil { 2038 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2039 opcRequestId := httpResponse.Header.Get("opc-request-id") 2040 response = DeleteIdpGroupMappingResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2041 } else { 2042 response = DeleteIdpGroupMappingResponse{} 2043 } 2044 } 2045 return 2046 } 2047 if convertedResponse, ok := ociResponse.(DeleteIdpGroupMappingResponse); ok { 2048 response = convertedResponse 2049 } else { 2050 err = fmt.Errorf("failed to convert OCIResponse into DeleteIdpGroupMappingResponse") 2051 } 2052 return 2053} 2054 2055// deleteIdpGroupMapping implements the OCIOperation interface (enables retrying operations) 2056func (client IdentityClient) deleteIdpGroupMapping(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2057 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/identityProviders/{identityProviderId}/groupMappings/{mappingId}") 2058 if err != nil { 2059 return nil, err 2060 } 2061 2062 var response DeleteIdpGroupMappingResponse 2063 var httpResponse *http.Response 2064 httpResponse, err = client.Call(ctx, &httpRequest) 2065 defer common.CloseBodyIfValid(httpResponse) 2066 response.RawResponse = httpResponse 2067 if err != nil { 2068 return response, err 2069 } 2070 2071 err = common.UnmarshalResponse(httpResponse, &response) 2072 return response, err 2073} 2074 2075// DeleteMfaTotpDevice Deletes the specified MFA TOTP device for the specified user. 2076func (client IdentityClient) DeleteMfaTotpDevice(ctx context.Context, request DeleteMfaTotpDeviceRequest) (response DeleteMfaTotpDeviceResponse, err error) { 2077 var ociResponse common.OCIResponse 2078 policy := common.NoRetryPolicy() 2079 if request.RetryPolicy() != nil { 2080 policy = *request.RetryPolicy() 2081 } 2082 ociResponse, err = common.Retry(ctx, request, client.deleteMfaTotpDevice, policy) 2083 if err != nil { 2084 if ociResponse != nil { 2085 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2086 opcRequestId := httpResponse.Header.Get("opc-request-id") 2087 response = DeleteMfaTotpDeviceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2088 } else { 2089 response = DeleteMfaTotpDeviceResponse{} 2090 } 2091 } 2092 return 2093 } 2094 if convertedResponse, ok := ociResponse.(DeleteMfaTotpDeviceResponse); ok { 2095 response = convertedResponse 2096 } else { 2097 err = fmt.Errorf("failed to convert OCIResponse into DeleteMfaTotpDeviceResponse") 2098 } 2099 return 2100} 2101 2102// deleteMfaTotpDevice implements the OCIOperation interface (enables retrying operations) 2103func (client IdentityClient) deleteMfaTotpDevice(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2104 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/users/{userId}/mfaTotpDevices/{mfaTotpDeviceId}") 2105 if err != nil { 2106 return nil, err 2107 } 2108 2109 var response DeleteMfaTotpDeviceResponse 2110 var httpResponse *http.Response 2111 httpResponse, err = client.Call(ctx, &httpRequest) 2112 defer common.CloseBodyIfValid(httpResponse) 2113 response.RawResponse = httpResponse 2114 if err != nil { 2115 return response, err 2116 } 2117 2118 err = common.UnmarshalResponse(httpResponse, &response) 2119 return response, err 2120} 2121 2122// DeleteNetworkSource Deletes the specified network source 2123func (client IdentityClient) DeleteNetworkSource(ctx context.Context, request DeleteNetworkSourceRequest) (response DeleteNetworkSourceResponse, err error) { 2124 var ociResponse common.OCIResponse 2125 policy := common.NoRetryPolicy() 2126 if request.RetryPolicy() != nil { 2127 policy = *request.RetryPolicy() 2128 } 2129 ociResponse, err = common.Retry(ctx, request, client.deleteNetworkSource, policy) 2130 if err != nil { 2131 if ociResponse != nil { 2132 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2133 opcRequestId := httpResponse.Header.Get("opc-request-id") 2134 response = DeleteNetworkSourceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2135 } else { 2136 response = DeleteNetworkSourceResponse{} 2137 } 2138 } 2139 return 2140 } 2141 if convertedResponse, ok := ociResponse.(DeleteNetworkSourceResponse); ok { 2142 response = convertedResponse 2143 } else { 2144 err = fmt.Errorf("failed to convert OCIResponse into DeleteNetworkSourceResponse") 2145 } 2146 return 2147} 2148 2149// deleteNetworkSource implements the OCIOperation interface (enables retrying operations) 2150func (client IdentityClient) deleteNetworkSource(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2151 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/networkSources/{networkSourceId}") 2152 if err != nil { 2153 return nil, err 2154 } 2155 2156 var response DeleteNetworkSourceResponse 2157 var httpResponse *http.Response 2158 httpResponse, err = client.Call(ctx, &httpRequest) 2159 defer common.CloseBodyIfValid(httpResponse) 2160 response.RawResponse = httpResponse 2161 if err != nil { 2162 return response, err 2163 } 2164 2165 err = common.UnmarshalResponse(httpResponse, &response) 2166 return response, err 2167} 2168 2169// DeleteOAuthClientCredential Delete Oauth token for the user 2170func (client IdentityClient) DeleteOAuthClientCredential(ctx context.Context, request DeleteOAuthClientCredentialRequest) (response DeleteOAuthClientCredentialResponse, err error) { 2171 var ociResponse common.OCIResponse 2172 policy := common.NoRetryPolicy() 2173 if request.RetryPolicy() != nil { 2174 policy = *request.RetryPolicy() 2175 } 2176 ociResponse, err = common.Retry(ctx, request, client.deleteOAuthClientCredential, policy) 2177 if err != nil { 2178 if ociResponse != nil { 2179 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2180 opcRequestId := httpResponse.Header.Get("opc-request-id") 2181 response = DeleteOAuthClientCredentialResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2182 } else { 2183 response = DeleteOAuthClientCredentialResponse{} 2184 } 2185 } 2186 return 2187 } 2188 if convertedResponse, ok := ociResponse.(DeleteOAuthClientCredentialResponse); ok { 2189 response = convertedResponse 2190 } else { 2191 err = fmt.Errorf("failed to convert OCIResponse into DeleteOAuthClientCredentialResponse") 2192 } 2193 return 2194} 2195 2196// deleteOAuthClientCredential implements the OCIOperation interface (enables retrying operations) 2197func (client IdentityClient) deleteOAuthClientCredential(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2198 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/users/{userId}/oauth2ClientCredentials/{oauth2ClientCredentialId}") 2199 if err != nil { 2200 return nil, err 2201 } 2202 2203 var response DeleteOAuthClientCredentialResponse 2204 var httpResponse *http.Response 2205 httpResponse, err = client.Call(ctx, &httpRequest) 2206 defer common.CloseBodyIfValid(httpResponse) 2207 response.RawResponse = httpResponse 2208 if err != nil { 2209 return response, err 2210 } 2211 2212 err = common.UnmarshalResponse(httpResponse, &response) 2213 return response, err 2214} 2215 2216// DeletePolicy Deletes the specified policy. The deletion takes effect typically within 10 seconds. 2217func (client IdentityClient) DeletePolicy(ctx context.Context, request DeletePolicyRequest) (response DeletePolicyResponse, err error) { 2218 var ociResponse common.OCIResponse 2219 policy := common.NoRetryPolicy() 2220 if request.RetryPolicy() != nil { 2221 policy = *request.RetryPolicy() 2222 } 2223 ociResponse, err = common.Retry(ctx, request, client.deletePolicy, policy) 2224 if err != nil { 2225 if ociResponse != nil { 2226 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2227 opcRequestId := httpResponse.Header.Get("opc-request-id") 2228 response = DeletePolicyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2229 } else { 2230 response = DeletePolicyResponse{} 2231 } 2232 } 2233 return 2234 } 2235 if convertedResponse, ok := ociResponse.(DeletePolicyResponse); ok { 2236 response = convertedResponse 2237 } else { 2238 err = fmt.Errorf("failed to convert OCIResponse into DeletePolicyResponse") 2239 } 2240 return 2241} 2242 2243// deletePolicy implements the OCIOperation interface (enables retrying operations) 2244func (client IdentityClient) deletePolicy(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2245 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/policies/{policyId}") 2246 if err != nil { 2247 return nil, err 2248 } 2249 2250 var response DeletePolicyResponse 2251 var httpResponse *http.Response 2252 httpResponse, err = client.Call(ctx, &httpRequest) 2253 defer common.CloseBodyIfValid(httpResponse) 2254 response.RawResponse = httpResponse 2255 if err != nil { 2256 return response, err 2257 } 2258 2259 err = common.UnmarshalResponse(httpResponse, &response) 2260 return response, err 2261} 2262 2263// DeleteSmtpCredential Deletes the specified SMTP credential for the specified user. 2264func (client IdentityClient) DeleteSmtpCredential(ctx context.Context, request DeleteSmtpCredentialRequest) (response DeleteSmtpCredentialResponse, err error) { 2265 var ociResponse common.OCIResponse 2266 policy := common.NoRetryPolicy() 2267 if request.RetryPolicy() != nil { 2268 policy = *request.RetryPolicy() 2269 } 2270 ociResponse, err = common.Retry(ctx, request, client.deleteSmtpCredential, policy) 2271 if err != nil { 2272 if ociResponse != nil { 2273 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2274 opcRequestId := httpResponse.Header.Get("opc-request-id") 2275 response = DeleteSmtpCredentialResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2276 } else { 2277 response = DeleteSmtpCredentialResponse{} 2278 } 2279 } 2280 return 2281 } 2282 if convertedResponse, ok := ociResponse.(DeleteSmtpCredentialResponse); ok { 2283 response = convertedResponse 2284 } else { 2285 err = fmt.Errorf("failed to convert OCIResponse into DeleteSmtpCredentialResponse") 2286 } 2287 return 2288} 2289 2290// deleteSmtpCredential implements the OCIOperation interface (enables retrying operations) 2291func (client IdentityClient) deleteSmtpCredential(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2292 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/users/{userId}/smtpCredentials/{smtpCredentialId}") 2293 if err != nil { 2294 return nil, err 2295 } 2296 2297 var response DeleteSmtpCredentialResponse 2298 var httpResponse *http.Response 2299 httpResponse, err = client.Call(ctx, &httpRequest) 2300 defer common.CloseBodyIfValid(httpResponse) 2301 response.RawResponse = httpResponse 2302 if err != nil { 2303 return response, err 2304 } 2305 2306 err = common.UnmarshalResponse(httpResponse, &response) 2307 return response, err 2308} 2309 2310// DeleteSwiftPassword **Deprecated. Use DeleteAuthToken instead.** 2311// Deletes the specified Swift password for the specified user. 2312func (client IdentityClient) DeleteSwiftPassword(ctx context.Context, request DeleteSwiftPasswordRequest) (response DeleteSwiftPasswordResponse, err error) { 2313 var ociResponse common.OCIResponse 2314 policy := common.NoRetryPolicy() 2315 if request.RetryPolicy() != nil { 2316 policy = *request.RetryPolicy() 2317 } 2318 ociResponse, err = common.Retry(ctx, request, client.deleteSwiftPassword, policy) 2319 if err != nil { 2320 if ociResponse != nil { 2321 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2322 opcRequestId := httpResponse.Header.Get("opc-request-id") 2323 response = DeleteSwiftPasswordResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2324 } else { 2325 response = DeleteSwiftPasswordResponse{} 2326 } 2327 } 2328 return 2329 } 2330 if convertedResponse, ok := ociResponse.(DeleteSwiftPasswordResponse); ok { 2331 response = convertedResponse 2332 } else { 2333 err = fmt.Errorf("failed to convert OCIResponse into DeleteSwiftPasswordResponse") 2334 } 2335 return 2336} 2337 2338// deleteSwiftPassword implements the OCIOperation interface (enables retrying operations) 2339func (client IdentityClient) deleteSwiftPassword(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2340 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/users/{userId}/swiftPasswords/{swiftPasswordId}") 2341 if err != nil { 2342 return nil, err 2343 } 2344 2345 var response DeleteSwiftPasswordResponse 2346 var httpResponse *http.Response 2347 httpResponse, err = client.Call(ctx, &httpRequest) 2348 defer common.CloseBodyIfValid(httpResponse) 2349 response.RawResponse = httpResponse 2350 if err != nil { 2351 return response, err 2352 } 2353 2354 err = common.UnmarshalResponse(httpResponse, &response) 2355 return response, err 2356} 2357 2358// DeleteTag Deletes the specified tag definition. This operation triggers a process that removes the 2359// tag from all resources in your tenancy. 2360// These things happen immediately: 2361// 2362// * If the tag was a cost-tracking tag, it no longer counts against your 10 cost-tracking 2363// tags limit, whether you first disabled it or not. 2364// * If the tag was used with dynamic groups, none of the rules that contain the tag will 2365// be evaluated against the tag. 2366// When you start the delete operation, the state of the tag changes to DELETING and tag removal 2367// from resources begins. This can take up to 48 hours depending on the number of resources that 2368// were tagged as well as the regions in which those resources reside. 2369// When all tags have been removed, the state changes to DELETED. You cannot restore a deleted tag. Once the deleted tag 2370// changes its state to DELETED, you can use the same tag name again. 2371// After you start this operation, you cannot start either the BulkDeleteTags or the CascadeDeleteTagNamespace operation until this process completes. 2372// To delete a tag, you must first retire it. Use UpdateTag 2373// to retire a tag. 2374func (client IdentityClient) DeleteTag(ctx context.Context, request DeleteTagRequest) (response DeleteTagResponse, err error) { 2375 var ociResponse common.OCIResponse 2376 policy := common.NoRetryPolicy() 2377 if request.RetryPolicy() != nil { 2378 policy = *request.RetryPolicy() 2379 } 2380 ociResponse, err = common.Retry(ctx, request, client.deleteTag, policy) 2381 if err != nil { 2382 if ociResponse != nil { 2383 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2384 opcRequestId := httpResponse.Header.Get("opc-request-id") 2385 response = DeleteTagResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2386 } else { 2387 response = DeleteTagResponse{} 2388 } 2389 } 2390 return 2391 } 2392 if convertedResponse, ok := ociResponse.(DeleteTagResponse); ok { 2393 response = convertedResponse 2394 } else { 2395 err = fmt.Errorf("failed to convert OCIResponse into DeleteTagResponse") 2396 } 2397 return 2398} 2399 2400// deleteTag implements the OCIOperation interface (enables retrying operations) 2401func (client IdentityClient) deleteTag(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2402 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/tagNamespaces/{tagNamespaceId}/tags/{tagName}") 2403 if err != nil { 2404 return nil, err 2405 } 2406 2407 var response DeleteTagResponse 2408 var httpResponse *http.Response 2409 httpResponse, err = client.Call(ctx, &httpRequest) 2410 defer common.CloseBodyIfValid(httpResponse) 2411 response.RawResponse = httpResponse 2412 if err != nil { 2413 return response, err 2414 } 2415 2416 err = common.UnmarshalResponse(httpResponse, &response) 2417 return response, err 2418} 2419 2420// DeleteTagDefault Deletes the the specified tag default. 2421func (client IdentityClient) DeleteTagDefault(ctx context.Context, request DeleteTagDefaultRequest) (response DeleteTagDefaultResponse, err error) { 2422 var ociResponse common.OCIResponse 2423 policy := common.NoRetryPolicy() 2424 if request.RetryPolicy() != nil { 2425 policy = *request.RetryPolicy() 2426 } 2427 ociResponse, err = common.Retry(ctx, request, client.deleteTagDefault, policy) 2428 if err != nil { 2429 if ociResponse != nil { 2430 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2431 opcRequestId := httpResponse.Header.Get("opc-request-id") 2432 response = DeleteTagDefaultResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2433 } else { 2434 response = DeleteTagDefaultResponse{} 2435 } 2436 } 2437 return 2438 } 2439 if convertedResponse, ok := ociResponse.(DeleteTagDefaultResponse); ok { 2440 response = convertedResponse 2441 } else { 2442 err = fmt.Errorf("failed to convert OCIResponse into DeleteTagDefaultResponse") 2443 } 2444 return 2445} 2446 2447// deleteTagDefault implements the OCIOperation interface (enables retrying operations) 2448func (client IdentityClient) deleteTagDefault(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2449 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/tagDefaults/{tagDefaultId}") 2450 if err != nil { 2451 return nil, err 2452 } 2453 2454 var response DeleteTagDefaultResponse 2455 var httpResponse *http.Response 2456 httpResponse, err = client.Call(ctx, &httpRequest) 2457 defer common.CloseBodyIfValid(httpResponse) 2458 response.RawResponse = httpResponse 2459 if err != nil { 2460 return response, err 2461 } 2462 2463 err = common.UnmarshalResponse(httpResponse, &response) 2464 return response, err 2465} 2466 2467// DeleteTagNamespace Deletes the specified tag namespace. Only an empty tag namespace can be deleted with this operation. To use this operation 2468// to delete a tag namespace that contains tag definitions, first delete all of its tag definitions. 2469// Use CascadeDeleteTagNamespace to delete a tag namespace along with all of 2470// the tag definitions contained within that namespace. 2471// Use DeleteTag to delete a tag definition. 2472func (client IdentityClient) DeleteTagNamespace(ctx context.Context, request DeleteTagNamespaceRequest) (response DeleteTagNamespaceResponse, err error) { 2473 var ociResponse common.OCIResponse 2474 policy := common.NoRetryPolicy() 2475 if request.RetryPolicy() != nil { 2476 policy = *request.RetryPolicy() 2477 } 2478 ociResponse, err = common.Retry(ctx, request, client.deleteTagNamespace, policy) 2479 if err != nil { 2480 if ociResponse != nil { 2481 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2482 opcRequestId := httpResponse.Header.Get("opc-request-id") 2483 response = DeleteTagNamespaceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2484 } else { 2485 response = DeleteTagNamespaceResponse{} 2486 } 2487 } 2488 return 2489 } 2490 if convertedResponse, ok := ociResponse.(DeleteTagNamespaceResponse); ok { 2491 response = convertedResponse 2492 } else { 2493 err = fmt.Errorf("failed to convert OCIResponse into DeleteTagNamespaceResponse") 2494 } 2495 return 2496} 2497 2498// deleteTagNamespace implements the OCIOperation interface (enables retrying operations) 2499func (client IdentityClient) deleteTagNamespace(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2500 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/tagNamespaces/{tagNamespaceId}") 2501 if err != nil { 2502 return nil, err 2503 } 2504 2505 var response DeleteTagNamespaceResponse 2506 var httpResponse *http.Response 2507 httpResponse, err = client.Call(ctx, &httpRequest) 2508 defer common.CloseBodyIfValid(httpResponse) 2509 response.RawResponse = httpResponse 2510 if err != nil { 2511 return response, err 2512 } 2513 2514 err = common.UnmarshalResponse(httpResponse, &response) 2515 return response, err 2516} 2517 2518// DeleteUser Deletes the specified user. The user must not be in any groups. 2519func (client IdentityClient) DeleteUser(ctx context.Context, request DeleteUserRequest) (response DeleteUserResponse, err error) { 2520 var ociResponse common.OCIResponse 2521 policy := common.NoRetryPolicy() 2522 if request.RetryPolicy() != nil { 2523 policy = *request.RetryPolicy() 2524 } 2525 ociResponse, err = common.Retry(ctx, request, client.deleteUser, policy) 2526 if err != nil { 2527 if ociResponse != nil { 2528 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2529 opcRequestId := httpResponse.Header.Get("opc-request-id") 2530 response = DeleteUserResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2531 } else { 2532 response = DeleteUserResponse{} 2533 } 2534 } 2535 return 2536 } 2537 if convertedResponse, ok := ociResponse.(DeleteUserResponse); ok { 2538 response = convertedResponse 2539 } else { 2540 err = fmt.Errorf("failed to convert OCIResponse into DeleteUserResponse") 2541 } 2542 return 2543} 2544 2545// deleteUser implements the OCIOperation interface (enables retrying operations) 2546func (client IdentityClient) deleteUser(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2547 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/users/{userId}") 2548 if err != nil { 2549 return nil, err 2550 } 2551 2552 var response DeleteUserResponse 2553 var httpResponse *http.Response 2554 httpResponse, err = client.Call(ctx, &httpRequest) 2555 defer common.CloseBodyIfValid(httpResponse) 2556 response.RawResponse = httpResponse 2557 if err != nil { 2558 return response, err 2559 } 2560 2561 err = common.UnmarshalResponse(httpResponse, &response) 2562 return response, err 2563} 2564 2565// GenerateTotpSeed Generate seed for the MFA TOTP device. 2566func (client IdentityClient) GenerateTotpSeed(ctx context.Context, request GenerateTotpSeedRequest) (response GenerateTotpSeedResponse, err error) { 2567 var ociResponse common.OCIResponse 2568 policy := common.NoRetryPolicy() 2569 if request.RetryPolicy() != nil { 2570 policy = *request.RetryPolicy() 2571 } 2572 ociResponse, err = common.Retry(ctx, request, client.generateTotpSeed, policy) 2573 if err != nil { 2574 if ociResponse != nil { 2575 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2576 opcRequestId := httpResponse.Header.Get("opc-request-id") 2577 response = GenerateTotpSeedResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2578 } else { 2579 response = GenerateTotpSeedResponse{} 2580 } 2581 } 2582 return 2583 } 2584 if convertedResponse, ok := ociResponse.(GenerateTotpSeedResponse); ok { 2585 response = convertedResponse 2586 } else { 2587 err = fmt.Errorf("failed to convert OCIResponse into GenerateTotpSeedResponse") 2588 } 2589 return 2590} 2591 2592// generateTotpSeed implements the OCIOperation interface (enables retrying operations) 2593func (client IdentityClient) generateTotpSeed(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2594 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/mfaTotpDevices/{mfaTotpDeviceId}/actions/generateSeed") 2595 if err != nil { 2596 return nil, err 2597 } 2598 2599 var response GenerateTotpSeedResponse 2600 var httpResponse *http.Response 2601 httpResponse, err = client.Call(ctx, &httpRequest) 2602 defer common.CloseBodyIfValid(httpResponse) 2603 response.RawResponse = httpResponse 2604 if err != nil { 2605 return response, err 2606 } 2607 2608 err = common.UnmarshalResponse(httpResponse, &response) 2609 return response, err 2610} 2611 2612// GetAuthenticationPolicy Gets the authentication policy for the given tenancy. You must specify your tenant’s OCID as the value for 2613// the compartment ID (remember that the tenancy is simply the root compartment). 2614func (client IdentityClient) GetAuthenticationPolicy(ctx context.Context, request GetAuthenticationPolicyRequest) (response GetAuthenticationPolicyResponse, err error) { 2615 var ociResponse common.OCIResponse 2616 policy := common.NoRetryPolicy() 2617 if request.RetryPolicy() != nil { 2618 policy = *request.RetryPolicy() 2619 } 2620 ociResponse, err = common.Retry(ctx, request, client.getAuthenticationPolicy, policy) 2621 if err != nil { 2622 if ociResponse != nil { 2623 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2624 opcRequestId := httpResponse.Header.Get("opc-request-id") 2625 response = GetAuthenticationPolicyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2626 } else { 2627 response = GetAuthenticationPolicyResponse{} 2628 } 2629 } 2630 return 2631 } 2632 if convertedResponse, ok := ociResponse.(GetAuthenticationPolicyResponse); ok { 2633 response = convertedResponse 2634 } else { 2635 err = fmt.Errorf("failed to convert OCIResponse into GetAuthenticationPolicyResponse") 2636 } 2637 return 2638} 2639 2640// getAuthenticationPolicy implements the OCIOperation interface (enables retrying operations) 2641func (client IdentityClient) getAuthenticationPolicy(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2642 httpRequest, err := request.HTTPRequest(http.MethodGet, "/authenticationPolicies/{compartmentId}") 2643 if err != nil { 2644 return nil, err 2645 } 2646 2647 var response GetAuthenticationPolicyResponse 2648 var httpResponse *http.Response 2649 httpResponse, err = client.Call(ctx, &httpRequest) 2650 defer common.CloseBodyIfValid(httpResponse) 2651 response.RawResponse = httpResponse 2652 if err != nil { 2653 return response, err 2654 } 2655 2656 err = common.UnmarshalResponse(httpResponse, &response) 2657 return response, err 2658} 2659 2660// GetCompartment Gets the specified compartment's information. 2661// This operation does not return a list of all the resources inside the compartment. There is no single 2662// API operation that does that. Compartments can contain multiple types of resources (instances, block 2663// storage volumes, etc.). To find out what's in a compartment, you must call the "List" operation for 2664// each resource type and specify the compartment's OCID as a query parameter in the request. For example, 2665// call the ListInstances operation in the Cloud Compute 2666// Service or the ListVolumes operation in Cloud Block Storage. 2667func (client IdentityClient) GetCompartment(ctx context.Context, request GetCompartmentRequest) (response GetCompartmentResponse, err error) { 2668 var ociResponse common.OCIResponse 2669 policy := common.NoRetryPolicy() 2670 if request.RetryPolicy() != nil { 2671 policy = *request.RetryPolicy() 2672 } 2673 ociResponse, err = common.Retry(ctx, request, client.getCompartment, policy) 2674 if err != nil { 2675 if ociResponse != nil { 2676 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2677 opcRequestId := httpResponse.Header.Get("opc-request-id") 2678 response = GetCompartmentResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2679 } else { 2680 response = GetCompartmentResponse{} 2681 } 2682 } 2683 return 2684 } 2685 if convertedResponse, ok := ociResponse.(GetCompartmentResponse); ok { 2686 response = convertedResponse 2687 } else { 2688 err = fmt.Errorf("failed to convert OCIResponse into GetCompartmentResponse") 2689 } 2690 return 2691} 2692 2693// getCompartment implements the OCIOperation interface (enables retrying operations) 2694func (client IdentityClient) getCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2695 httpRequest, err := request.HTTPRequest(http.MethodGet, "/compartments/{compartmentId}") 2696 if err != nil { 2697 return nil, err 2698 } 2699 2700 var response GetCompartmentResponse 2701 var httpResponse *http.Response 2702 httpResponse, err = client.Call(ctx, &httpRequest) 2703 defer common.CloseBodyIfValid(httpResponse) 2704 response.RawResponse = httpResponse 2705 if err != nil { 2706 return response, err 2707 } 2708 2709 err = common.UnmarshalResponse(httpResponse, &response) 2710 return response, err 2711} 2712 2713// GetDynamicGroup Gets the specified dynamic group's information. 2714func (client IdentityClient) GetDynamicGroup(ctx context.Context, request GetDynamicGroupRequest) (response GetDynamicGroupResponse, err error) { 2715 var ociResponse common.OCIResponse 2716 policy := common.NoRetryPolicy() 2717 if request.RetryPolicy() != nil { 2718 policy = *request.RetryPolicy() 2719 } 2720 ociResponse, err = common.Retry(ctx, request, client.getDynamicGroup, policy) 2721 if err != nil { 2722 if ociResponse != nil { 2723 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2724 opcRequestId := httpResponse.Header.Get("opc-request-id") 2725 response = GetDynamicGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2726 } else { 2727 response = GetDynamicGroupResponse{} 2728 } 2729 } 2730 return 2731 } 2732 if convertedResponse, ok := ociResponse.(GetDynamicGroupResponse); ok { 2733 response = convertedResponse 2734 } else { 2735 err = fmt.Errorf("failed to convert OCIResponse into GetDynamicGroupResponse") 2736 } 2737 return 2738} 2739 2740// getDynamicGroup implements the OCIOperation interface (enables retrying operations) 2741func (client IdentityClient) getDynamicGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2742 httpRequest, err := request.HTTPRequest(http.MethodGet, "/dynamicGroups/{dynamicGroupId}") 2743 if err != nil { 2744 return nil, err 2745 } 2746 2747 var response GetDynamicGroupResponse 2748 var httpResponse *http.Response 2749 httpResponse, err = client.Call(ctx, &httpRequest) 2750 defer common.CloseBodyIfValid(httpResponse) 2751 response.RawResponse = httpResponse 2752 if err != nil { 2753 return response, err 2754 } 2755 2756 err = common.UnmarshalResponse(httpResponse, &response) 2757 return response, err 2758} 2759 2760// GetGroup Gets the specified group's information. 2761// This operation does not return a list of all the users in the group. To do that, use 2762// ListUserGroupMemberships and 2763// provide the group's OCID as a query parameter in the request. 2764func (client IdentityClient) GetGroup(ctx context.Context, request GetGroupRequest) (response GetGroupResponse, err error) { 2765 var ociResponse common.OCIResponse 2766 policy := common.NoRetryPolicy() 2767 if request.RetryPolicy() != nil { 2768 policy = *request.RetryPolicy() 2769 } 2770 ociResponse, err = common.Retry(ctx, request, client.getGroup, policy) 2771 if err != nil { 2772 if ociResponse != nil { 2773 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2774 opcRequestId := httpResponse.Header.Get("opc-request-id") 2775 response = GetGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2776 } else { 2777 response = GetGroupResponse{} 2778 } 2779 } 2780 return 2781 } 2782 if convertedResponse, ok := ociResponse.(GetGroupResponse); ok { 2783 response = convertedResponse 2784 } else { 2785 err = fmt.Errorf("failed to convert OCIResponse into GetGroupResponse") 2786 } 2787 return 2788} 2789 2790// getGroup implements the OCIOperation interface (enables retrying operations) 2791func (client IdentityClient) getGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2792 httpRequest, err := request.HTTPRequest(http.MethodGet, "/groups/{groupId}") 2793 if err != nil { 2794 return nil, err 2795 } 2796 2797 var response GetGroupResponse 2798 var httpResponse *http.Response 2799 httpResponse, err = client.Call(ctx, &httpRequest) 2800 defer common.CloseBodyIfValid(httpResponse) 2801 response.RawResponse = httpResponse 2802 if err != nil { 2803 return response, err 2804 } 2805 2806 err = common.UnmarshalResponse(httpResponse, &response) 2807 return response, err 2808} 2809 2810// GetIdentityProvider Gets the specified identity provider's information. 2811func (client IdentityClient) GetIdentityProvider(ctx context.Context, request GetIdentityProviderRequest) (response GetIdentityProviderResponse, err error) { 2812 var ociResponse common.OCIResponse 2813 policy := common.NoRetryPolicy() 2814 if request.RetryPolicy() != nil { 2815 policy = *request.RetryPolicy() 2816 } 2817 ociResponse, err = common.Retry(ctx, request, client.getIdentityProvider, policy) 2818 if err != nil { 2819 if ociResponse != nil { 2820 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2821 opcRequestId := httpResponse.Header.Get("opc-request-id") 2822 response = GetIdentityProviderResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2823 } else { 2824 response = GetIdentityProviderResponse{} 2825 } 2826 } 2827 return 2828 } 2829 if convertedResponse, ok := ociResponse.(GetIdentityProviderResponse); ok { 2830 response = convertedResponse 2831 } else { 2832 err = fmt.Errorf("failed to convert OCIResponse into GetIdentityProviderResponse") 2833 } 2834 return 2835} 2836 2837// getIdentityProvider implements the OCIOperation interface (enables retrying operations) 2838func (client IdentityClient) getIdentityProvider(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2839 httpRequest, err := request.HTTPRequest(http.MethodGet, "/identityProviders/{identityProviderId}") 2840 if err != nil { 2841 return nil, err 2842 } 2843 2844 var response GetIdentityProviderResponse 2845 var httpResponse *http.Response 2846 httpResponse, err = client.Call(ctx, &httpRequest) 2847 defer common.CloseBodyIfValid(httpResponse) 2848 response.RawResponse = httpResponse 2849 if err != nil { 2850 return response, err 2851 } 2852 2853 err = common.UnmarshalResponseWithPolymorphicBody(httpResponse, &response, &identityprovider{}) 2854 return response, err 2855} 2856 2857// GetIdpGroupMapping Gets the specified group mapping. 2858func (client IdentityClient) GetIdpGroupMapping(ctx context.Context, request GetIdpGroupMappingRequest) (response GetIdpGroupMappingResponse, err error) { 2859 var ociResponse common.OCIResponse 2860 policy := common.NoRetryPolicy() 2861 if request.RetryPolicy() != nil { 2862 policy = *request.RetryPolicy() 2863 } 2864 ociResponse, err = common.Retry(ctx, request, client.getIdpGroupMapping, policy) 2865 if err != nil { 2866 if ociResponse != nil { 2867 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2868 opcRequestId := httpResponse.Header.Get("opc-request-id") 2869 response = GetIdpGroupMappingResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2870 } else { 2871 response = GetIdpGroupMappingResponse{} 2872 } 2873 } 2874 return 2875 } 2876 if convertedResponse, ok := ociResponse.(GetIdpGroupMappingResponse); ok { 2877 response = convertedResponse 2878 } else { 2879 err = fmt.Errorf("failed to convert OCIResponse into GetIdpGroupMappingResponse") 2880 } 2881 return 2882} 2883 2884// getIdpGroupMapping implements the OCIOperation interface (enables retrying operations) 2885func (client IdentityClient) getIdpGroupMapping(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2886 httpRequest, err := request.HTTPRequest(http.MethodGet, "/identityProviders/{identityProviderId}/groupMappings/{mappingId}") 2887 if err != nil { 2888 return nil, err 2889 } 2890 2891 var response GetIdpGroupMappingResponse 2892 var httpResponse *http.Response 2893 httpResponse, err = client.Call(ctx, &httpRequest) 2894 defer common.CloseBodyIfValid(httpResponse) 2895 response.RawResponse = httpResponse 2896 if err != nil { 2897 return response, err 2898 } 2899 2900 err = common.UnmarshalResponse(httpResponse, &response) 2901 return response, err 2902} 2903 2904// GetMfaTotpDevice Get the specified MFA TOTP device for the specified user. 2905func (client IdentityClient) GetMfaTotpDevice(ctx context.Context, request GetMfaTotpDeviceRequest) (response GetMfaTotpDeviceResponse, err error) { 2906 var ociResponse common.OCIResponse 2907 policy := common.NoRetryPolicy() 2908 if request.RetryPolicy() != nil { 2909 policy = *request.RetryPolicy() 2910 } 2911 ociResponse, err = common.Retry(ctx, request, client.getMfaTotpDevice, policy) 2912 if err != nil { 2913 if ociResponse != nil { 2914 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2915 opcRequestId := httpResponse.Header.Get("opc-request-id") 2916 response = GetMfaTotpDeviceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2917 } else { 2918 response = GetMfaTotpDeviceResponse{} 2919 } 2920 } 2921 return 2922 } 2923 if convertedResponse, ok := ociResponse.(GetMfaTotpDeviceResponse); ok { 2924 response = convertedResponse 2925 } else { 2926 err = fmt.Errorf("failed to convert OCIResponse into GetMfaTotpDeviceResponse") 2927 } 2928 return 2929} 2930 2931// getMfaTotpDevice implements the OCIOperation interface (enables retrying operations) 2932func (client IdentityClient) getMfaTotpDevice(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2933 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}/mfaTotpDevices/{mfaTotpDeviceId}") 2934 if err != nil { 2935 return nil, err 2936 } 2937 2938 var response GetMfaTotpDeviceResponse 2939 var httpResponse *http.Response 2940 httpResponse, err = client.Call(ctx, &httpRequest) 2941 defer common.CloseBodyIfValid(httpResponse) 2942 response.RawResponse = httpResponse 2943 if err != nil { 2944 return response, err 2945 } 2946 2947 err = common.UnmarshalResponse(httpResponse, &response) 2948 return response, err 2949} 2950 2951// GetNetworkSource Gets the specified network source's information. 2952func (client IdentityClient) GetNetworkSource(ctx context.Context, request GetNetworkSourceRequest) (response GetNetworkSourceResponse, err error) { 2953 var ociResponse common.OCIResponse 2954 policy := common.NoRetryPolicy() 2955 if request.RetryPolicy() != nil { 2956 policy = *request.RetryPolicy() 2957 } 2958 ociResponse, err = common.Retry(ctx, request, client.getNetworkSource, policy) 2959 if err != nil { 2960 if ociResponse != nil { 2961 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 2962 opcRequestId := httpResponse.Header.Get("opc-request-id") 2963 response = GetNetworkSourceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 2964 } else { 2965 response = GetNetworkSourceResponse{} 2966 } 2967 } 2968 return 2969 } 2970 if convertedResponse, ok := ociResponse.(GetNetworkSourceResponse); ok { 2971 response = convertedResponse 2972 } else { 2973 err = fmt.Errorf("failed to convert OCIResponse into GetNetworkSourceResponse") 2974 } 2975 return 2976} 2977 2978// getNetworkSource implements the OCIOperation interface (enables retrying operations) 2979func (client IdentityClient) getNetworkSource(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 2980 httpRequest, err := request.HTTPRequest(http.MethodGet, "/networkSources/{networkSourceId}") 2981 if err != nil { 2982 return nil, err 2983 } 2984 2985 var response GetNetworkSourceResponse 2986 var httpResponse *http.Response 2987 httpResponse, err = client.Call(ctx, &httpRequest) 2988 defer common.CloseBodyIfValid(httpResponse) 2989 response.RawResponse = httpResponse 2990 if err != nil { 2991 return response, err 2992 } 2993 2994 err = common.UnmarshalResponse(httpResponse, &response) 2995 return response, err 2996} 2997 2998// GetPolicy Gets the specified policy's information. 2999func (client IdentityClient) GetPolicy(ctx context.Context, request GetPolicyRequest) (response GetPolicyResponse, err error) { 3000 var ociResponse common.OCIResponse 3001 policy := common.NoRetryPolicy() 3002 if request.RetryPolicy() != nil { 3003 policy = *request.RetryPolicy() 3004 } 3005 ociResponse, err = common.Retry(ctx, request, client.getPolicy, policy) 3006 if err != nil { 3007 if ociResponse != nil { 3008 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3009 opcRequestId := httpResponse.Header.Get("opc-request-id") 3010 response = GetPolicyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3011 } else { 3012 response = GetPolicyResponse{} 3013 } 3014 } 3015 return 3016 } 3017 if convertedResponse, ok := ociResponse.(GetPolicyResponse); ok { 3018 response = convertedResponse 3019 } else { 3020 err = fmt.Errorf("failed to convert OCIResponse into GetPolicyResponse") 3021 } 3022 return 3023} 3024 3025// getPolicy implements the OCIOperation interface (enables retrying operations) 3026func (client IdentityClient) getPolicy(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3027 httpRequest, err := request.HTTPRequest(http.MethodGet, "/policies/{policyId}") 3028 if err != nil { 3029 return nil, err 3030 } 3031 3032 var response GetPolicyResponse 3033 var httpResponse *http.Response 3034 httpResponse, err = client.Call(ctx, &httpRequest) 3035 defer common.CloseBodyIfValid(httpResponse) 3036 response.RawResponse = httpResponse 3037 if err != nil { 3038 return response, err 3039 } 3040 3041 err = common.UnmarshalResponse(httpResponse, &response) 3042 return response, err 3043} 3044 3045// GetTag Gets the specified tag's information. 3046func (client IdentityClient) GetTag(ctx context.Context, request GetTagRequest) (response GetTagResponse, err error) { 3047 var ociResponse common.OCIResponse 3048 policy := common.NoRetryPolicy() 3049 if request.RetryPolicy() != nil { 3050 policy = *request.RetryPolicy() 3051 } 3052 ociResponse, err = common.Retry(ctx, request, client.getTag, policy) 3053 if err != nil { 3054 if ociResponse != nil { 3055 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3056 opcRequestId := httpResponse.Header.Get("opc-request-id") 3057 response = GetTagResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3058 } else { 3059 response = GetTagResponse{} 3060 } 3061 } 3062 return 3063 } 3064 if convertedResponse, ok := ociResponse.(GetTagResponse); ok { 3065 response = convertedResponse 3066 } else { 3067 err = fmt.Errorf("failed to convert OCIResponse into GetTagResponse") 3068 } 3069 return 3070} 3071 3072// getTag implements the OCIOperation interface (enables retrying operations) 3073func (client IdentityClient) getTag(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3074 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tagNamespaces/{tagNamespaceId}/tags/{tagName}") 3075 if err != nil { 3076 return nil, err 3077 } 3078 3079 var response GetTagResponse 3080 var httpResponse *http.Response 3081 httpResponse, err = client.Call(ctx, &httpRequest) 3082 defer common.CloseBodyIfValid(httpResponse) 3083 response.RawResponse = httpResponse 3084 if err != nil { 3085 return response, err 3086 } 3087 3088 err = common.UnmarshalResponse(httpResponse, &response) 3089 return response, err 3090} 3091 3092// GetTagDefault Retrieves the specified tag default. 3093func (client IdentityClient) GetTagDefault(ctx context.Context, request GetTagDefaultRequest) (response GetTagDefaultResponse, err error) { 3094 var ociResponse common.OCIResponse 3095 policy := common.NoRetryPolicy() 3096 if request.RetryPolicy() != nil { 3097 policy = *request.RetryPolicy() 3098 } 3099 ociResponse, err = common.Retry(ctx, request, client.getTagDefault, policy) 3100 if err != nil { 3101 if ociResponse != nil { 3102 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3103 opcRequestId := httpResponse.Header.Get("opc-request-id") 3104 response = GetTagDefaultResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3105 } else { 3106 response = GetTagDefaultResponse{} 3107 } 3108 } 3109 return 3110 } 3111 if convertedResponse, ok := ociResponse.(GetTagDefaultResponse); ok { 3112 response = convertedResponse 3113 } else { 3114 err = fmt.Errorf("failed to convert OCIResponse into GetTagDefaultResponse") 3115 } 3116 return 3117} 3118 3119// getTagDefault implements the OCIOperation interface (enables retrying operations) 3120func (client IdentityClient) getTagDefault(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3121 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tagDefaults/{tagDefaultId}") 3122 if err != nil { 3123 return nil, err 3124 } 3125 3126 var response GetTagDefaultResponse 3127 var httpResponse *http.Response 3128 httpResponse, err = client.Call(ctx, &httpRequest) 3129 defer common.CloseBodyIfValid(httpResponse) 3130 response.RawResponse = httpResponse 3131 if err != nil { 3132 return response, err 3133 } 3134 3135 err = common.UnmarshalResponse(httpResponse, &response) 3136 return response, err 3137} 3138 3139// GetTagNamespace Gets the specified tag namespace's information. 3140func (client IdentityClient) GetTagNamespace(ctx context.Context, request GetTagNamespaceRequest) (response GetTagNamespaceResponse, err error) { 3141 var ociResponse common.OCIResponse 3142 policy := common.NoRetryPolicy() 3143 if request.RetryPolicy() != nil { 3144 policy = *request.RetryPolicy() 3145 } 3146 ociResponse, err = common.Retry(ctx, request, client.getTagNamespace, policy) 3147 if err != nil { 3148 if ociResponse != nil { 3149 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3150 opcRequestId := httpResponse.Header.Get("opc-request-id") 3151 response = GetTagNamespaceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3152 } else { 3153 response = GetTagNamespaceResponse{} 3154 } 3155 } 3156 return 3157 } 3158 if convertedResponse, ok := ociResponse.(GetTagNamespaceResponse); ok { 3159 response = convertedResponse 3160 } else { 3161 err = fmt.Errorf("failed to convert OCIResponse into GetTagNamespaceResponse") 3162 } 3163 return 3164} 3165 3166// getTagNamespace implements the OCIOperation interface (enables retrying operations) 3167func (client IdentityClient) getTagNamespace(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3168 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tagNamespaces/{tagNamespaceId}") 3169 if err != nil { 3170 return nil, err 3171 } 3172 3173 var response GetTagNamespaceResponse 3174 var httpResponse *http.Response 3175 httpResponse, err = client.Call(ctx, &httpRequest) 3176 defer common.CloseBodyIfValid(httpResponse) 3177 response.RawResponse = httpResponse 3178 if err != nil { 3179 return response, err 3180 } 3181 3182 err = common.UnmarshalResponse(httpResponse, &response) 3183 return response, err 3184} 3185 3186// GetTaggingWorkRequest Gets details on a specified work request. The workRequestID is returned in the opc-workrequest-id header 3187// for any asynchronous operation in the Identity and Access Management service. 3188func (client IdentityClient) GetTaggingWorkRequest(ctx context.Context, request GetTaggingWorkRequestRequest) (response GetTaggingWorkRequestResponse, err error) { 3189 var ociResponse common.OCIResponse 3190 policy := common.NoRetryPolicy() 3191 if request.RetryPolicy() != nil { 3192 policy = *request.RetryPolicy() 3193 } 3194 ociResponse, err = common.Retry(ctx, request, client.getTaggingWorkRequest, policy) 3195 if err != nil { 3196 if ociResponse != nil { 3197 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3198 opcRequestId := httpResponse.Header.Get("opc-request-id") 3199 response = GetTaggingWorkRequestResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3200 } else { 3201 response = GetTaggingWorkRequestResponse{} 3202 } 3203 } 3204 return 3205 } 3206 if convertedResponse, ok := ociResponse.(GetTaggingWorkRequestResponse); ok { 3207 response = convertedResponse 3208 } else { 3209 err = fmt.Errorf("failed to convert OCIResponse into GetTaggingWorkRequestResponse") 3210 } 3211 return 3212} 3213 3214// getTaggingWorkRequest implements the OCIOperation interface (enables retrying operations) 3215func (client IdentityClient) getTaggingWorkRequest(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3216 httpRequest, err := request.HTTPRequest(http.MethodGet, "/taggingWorkRequests/{workRequestId}") 3217 if err != nil { 3218 return nil, err 3219 } 3220 3221 var response GetTaggingWorkRequestResponse 3222 var httpResponse *http.Response 3223 httpResponse, err = client.Call(ctx, &httpRequest) 3224 defer common.CloseBodyIfValid(httpResponse) 3225 response.RawResponse = httpResponse 3226 if err != nil { 3227 return response, err 3228 } 3229 3230 err = common.UnmarshalResponse(httpResponse, &response) 3231 return response, err 3232} 3233 3234// GetTenancy Get the specified tenancy's information. 3235func (client IdentityClient) GetTenancy(ctx context.Context, request GetTenancyRequest) (response GetTenancyResponse, err error) { 3236 var ociResponse common.OCIResponse 3237 policy := common.NoRetryPolicy() 3238 if request.RetryPolicy() != nil { 3239 policy = *request.RetryPolicy() 3240 } 3241 ociResponse, err = common.Retry(ctx, request, client.getTenancy, policy) 3242 if err != nil { 3243 if ociResponse != nil { 3244 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3245 opcRequestId := httpResponse.Header.Get("opc-request-id") 3246 response = GetTenancyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3247 } else { 3248 response = GetTenancyResponse{} 3249 } 3250 } 3251 return 3252 } 3253 if convertedResponse, ok := ociResponse.(GetTenancyResponse); ok { 3254 response = convertedResponse 3255 } else { 3256 err = fmt.Errorf("failed to convert OCIResponse into GetTenancyResponse") 3257 } 3258 return 3259} 3260 3261// getTenancy implements the OCIOperation interface (enables retrying operations) 3262func (client IdentityClient) getTenancy(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3263 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tenancies/{tenancyId}") 3264 if err != nil { 3265 return nil, err 3266 } 3267 3268 var response GetTenancyResponse 3269 var httpResponse *http.Response 3270 httpResponse, err = client.Call(ctx, &httpRequest) 3271 defer common.CloseBodyIfValid(httpResponse) 3272 response.RawResponse = httpResponse 3273 if err != nil { 3274 return response, err 3275 } 3276 3277 err = common.UnmarshalResponse(httpResponse, &response) 3278 return response, err 3279} 3280 3281// GetUser Gets the specified user's information. 3282func (client IdentityClient) GetUser(ctx context.Context, request GetUserRequest) (response GetUserResponse, err error) { 3283 var ociResponse common.OCIResponse 3284 policy := common.NoRetryPolicy() 3285 if request.RetryPolicy() != nil { 3286 policy = *request.RetryPolicy() 3287 } 3288 ociResponse, err = common.Retry(ctx, request, client.getUser, policy) 3289 if err != nil { 3290 if ociResponse != nil { 3291 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3292 opcRequestId := httpResponse.Header.Get("opc-request-id") 3293 response = GetUserResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3294 } else { 3295 response = GetUserResponse{} 3296 } 3297 } 3298 return 3299 } 3300 if convertedResponse, ok := ociResponse.(GetUserResponse); ok { 3301 response = convertedResponse 3302 } else { 3303 err = fmt.Errorf("failed to convert OCIResponse into GetUserResponse") 3304 } 3305 return 3306} 3307 3308// getUser implements the OCIOperation interface (enables retrying operations) 3309func (client IdentityClient) getUser(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3310 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}") 3311 if err != nil { 3312 return nil, err 3313 } 3314 3315 var response GetUserResponse 3316 var httpResponse *http.Response 3317 httpResponse, err = client.Call(ctx, &httpRequest) 3318 defer common.CloseBodyIfValid(httpResponse) 3319 response.RawResponse = httpResponse 3320 if err != nil { 3321 return response, err 3322 } 3323 3324 err = common.UnmarshalResponse(httpResponse, &response) 3325 return response, err 3326} 3327 3328// GetUserGroupMembership Gets the specified UserGroupMembership's information. 3329func (client IdentityClient) GetUserGroupMembership(ctx context.Context, request GetUserGroupMembershipRequest) (response GetUserGroupMembershipResponse, err error) { 3330 var ociResponse common.OCIResponse 3331 policy := common.NoRetryPolicy() 3332 if request.RetryPolicy() != nil { 3333 policy = *request.RetryPolicy() 3334 } 3335 ociResponse, err = common.Retry(ctx, request, client.getUserGroupMembership, policy) 3336 if err != nil { 3337 if ociResponse != nil { 3338 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3339 opcRequestId := httpResponse.Header.Get("opc-request-id") 3340 response = GetUserGroupMembershipResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3341 } else { 3342 response = GetUserGroupMembershipResponse{} 3343 } 3344 } 3345 return 3346 } 3347 if convertedResponse, ok := ociResponse.(GetUserGroupMembershipResponse); ok { 3348 response = convertedResponse 3349 } else { 3350 err = fmt.Errorf("failed to convert OCIResponse into GetUserGroupMembershipResponse") 3351 } 3352 return 3353} 3354 3355// getUserGroupMembership implements the OCIOperation interface (enables retrying operations) 3356func (client IdentityClient) getUserGroupMembership(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3357 httpRequest, err := request.HTTPRequest(http.MethodGet, "/userGroupMemberships/{userGroupMembershipId}") 3358 if err != nil { 3359 return nil, err 3360 } 3361 3362 var response GetUserGroupMembershipResponse 3363 var httpResponse *http.Response 3364 httpResponse, err = client.Call(ctx, &httpRequest) 3365 defer common.CloseBodyIfValid(httpResponse) 3366 response.RawResponse = httpResponse 3367 if err != nil { 3368 return response, err 3369 } 3370 3371 err = common.UnmarshalResponse(httpResponse, &response) 3372 return response, err 3373} 3374 3375// GetUserUIPasswordInformation Gets the specified user's console password information. The returned object contains the user's OCID, 3376// but not the password itself. The actual password is returned only when created or reset. 3377func (client IdentityClient) GetUserUIPasswordInformation(ctx context.Context, request GetUserUIPasswordInformationRequest) (response GetUserUIPasswordInformationResponse, err error) { 3378 var ociResponse common.OCIResponse 3379 policy := common.NoRetryPolicy() 3380 if request.RetryPolicy() != nil { 3381 policy = *request.RetryPolicy() 3382 } 3383 ociResponse, err = common.Retry(ctx, request, client.getUserUIPasswordInformation, policy) 3384 if err != nil { 3385 if ociResponse != nil { 3386 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3387 opcRequestId := httpResponse.Header.Get("opc-request-id") 3388 response = GetUserUIPasswordInformationResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3389 } else { 3390 response = GetUserUIPasswordInformationResponse{} 3391 } 3392 } 3393 return 3394 } 3395 if convertedResponse, ok := ociResponse.(GetUserUIPasswordInformationResponse); ok { 3396 response = convertedResponse 3397 } else { 3398 err = fmt.Errorf("failed to convert OCIResponse into GetUserUIPasswordInformationResponse") 3399 } 3400 return 3401} 3402 3403// getUserUIPasswordInformation implements the OCIOperation interface (enables retrying operations) 3404func (client IdentityClient) getUserUIPasswordInformation(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3405 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}/uiPassword") 3406 if err != nil { 3407 return nil, err 3408 } 3409 3410 var response GetUserUIPasswordInformationResponse 3411 var httpResponse *http.Response 3412 httpResponse, err = client.Call(ctx, &httpRequest) 3413 defer common.CloseBodyIfValid(httpResponse) 3414 response.RawResponse = httpResponse 3415 if err != nil { 3416 return response, err 3417 } 3418 3419 err = common.UnmarshalResponse(httpResponse, &response) 3420 return response, err 3421} 3422 3423// GetWorkRequest Gets details on a specified work request. The workRequestID is returned in the opc-workrequest-id header 3424// for any asynchronous operation in the Identity and Access Management service. 3425func (client IdentityClient) GetWorkRequest(ctx context.Context, request GetWorkRequestRequest) (response GetWorkRequestResponse, err error) { 3426 var ociResponse common.OCIResponse 3427 policy := common.NoRetryPolicy() 3428 if request.RetryPolicy() != nil { 3429 policy = *request.RetryPolicy() 3430 } 3431 ociResponse, err = common.Retry(ctx, request, client.getWorkRequest, policy) 3432 if err != nil { 3433 if ociResponse != nil { 3434 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3435 opcRequestId := httpResponse.Header.Get("opc-request-id") 3436 response = GetWorkRequestResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3437 } else { 3438 response = GetWorkRequestResponse{} 3439 } 3440 } 3441 return 3442 } 3443 if convertedResponse, ok := ociResponse.(GetWorkRequestResponse); ok { 3444 response = convertedResponse 3445 } else { 3446 err = fmt.Errorf("failed to convert OCIResponse into GetWorkRequestResponse") 3447 } 3448 return 3449} 3450 3451// getWorkRequest implements the OCIOperation interface (enables retrying operations) 3452func (client IdentityClient) getWorkRequest(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3453 httpRequest, err := request.HTTPRequest(http.MethodGet, "/workRequests/{workRequestId}") 3454 if err != nil { 3455 return nil, err 3456 } 3457 3458 var response GetWorkRequestResponse 3459 var httpResponse *http.Response 3460 httpResponse, err = client.Call(ctx, &httpRequest) 3461 defer common.CloseBodyIfValid(httpResponse) 3462 response.RawResponse = httpResponse 3463 if err != nil { 3464 return response, err 3465 } 3466 3467 err = common.UnmarshalResponse(httpResponse, &response) 3468 return response, err 3469} 3470 3471// ListApiKeys Lists the API signing keys for the specified user. A user can have a maximum of three keys. 3472// Every user has permission to use this API call for *their own user ID*. An administrator in your 3473// organization does not need to write a policy to give users this ability. 3474func (client IdentityClient) ListApiKeys(ctx context.Context, request ListApiKeysRequest) (response ListApiKeysResponse, err error) { 3475 var ociResponse common.OCIResponse 3476 policy := common.NoRetryPolicy() 3477 if request.RetryPolicy() != nil { 3478 policy = *request.RetryPolicy() 3479 } 3480 ociResponse, err = common.Retry(ctx, request, client.listApiKeys, policy) 3481 if err != nil { 3482 if ociResponse != nil { 3483 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3484 opcRequestId := httpResponse.Header.Get("opc-request-id") 3485 response = ListApiKeysResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3486 } else { 3487 response = ListApiKeysResponse{} 3488 } 3489 } 3490 return 3491 } 3492 if convertedResponse, ok := ociResponse.(ListApiKeysResponse); ok { 3493 response = convertedResponse 3494 } else { 3495 err = fmt.Errorf("failed to convert OCIResponse into ListApiKeysResponse") 3496 } 3497 return 3498} 3499 3500// listApiKeys implements the OCIOperation interface (enables retrying operations) 3501func (client IdentityClient) listApiKeys(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3502 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}/apiKeys") 3503 if err != nil { 3504 return nil, err 3505 } 3506 3507 var response ListApiKeysResponse 3508 var httpResponse *http.Response 3509 httpResponse, err = client.Call(ctx, &httpRequest) 3510 defer common.CloseBodyIfValid(httpResponse) 3511 response.RawResponse = httpResponse 3512 if err != nil { 3513 return response, err 3514 } 3515 3516 err = common.UnmarshalResponse(httpResponse, &response) 3517 return response, err 3518} 3519 3520// ListAuthTokens Lists the auth tokens for the specified user. The returned object contains the token's OCID, but not 3521// the token itself. The actual token is returned only upon creation. 3522func (client IdentityClient) ListAuthTokens(ctx context.Context, request ListAuthTokensRequest) (response ListAuthTokensResponse, err error) { 3523 var ociResponse common.OCIResponse 3524 policy := common.NoRetryPolicy() 3525 if request.RetryPolicy() != nil { 3526 policy = *request.RetryPolicy() 3527 } 3528 ociResponse, err = common.Retry(ctx, request, client.listAuthTokens, policy) 3529 if err != nil { 3530 if ociResponse != nil { 3531 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3532 opcRequestId := httpResponse.Header.Get("opc-request-id") 3533 response = ListAuthTokensResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3534 } else { 3535 response = ListAuthTokensResponse{} 3536 } 3537 } 3538 return 3539 } 3540 if convertedResponse, ok := ociResponse.(ListAuthTokensResponse); ok { 3541 response = convertedResponse 3542 } else { 3543 err = fmt.Errorf("failed to convert OCIResponse into ListAuthTokensResponse") 3544 } 3545 return 3546} 3547 3548// listAuthTokens implements the OCIOperation interface (enables retrying operations) 3549func (client IdentityClient) listAuthTokens(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3550 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}/authTokens") 3551 if err != nil { 3552 return nil, err 3553 } 3554 3555 var response ListAuthTokensResponse 3556 var httpResponse *http.Response 3557 httpResponse, err = client.Call(ctx, &httpRequest) 3558 defer common.CloseBodyIfValid(httpResponse) 3559 response.RawResponse = httpResponse 3560 if err != nil { 3561 return response, err 3562 } 3563 3564 err = common.UnmarshalResponse(httpResponse, &response) 3565 return response, err 3566} 3567 3568// ListAvailabilityDomains Lists the availability domains in your tenancy. Specify the OCID of either the tenancy or another 3569// of your compartments as the value for the compartment ID (remember that the tenancy is simply the root compartment). 3570// See Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five). 3571// Note that the order of the results returned can change if availability domains are added or removed; therefore, do not 3572// create a dependency on the list order. 3573func (client IdentityClient) ListAvailabilityDomains(ctx context.Context, request ListAvailabilityDomainsRequest) (response ListAvailabilityDomainsResponse, err error) { 3574 var ociResponse common.OCIResponse 3575 policy := common.NoRetryPolicy() 3576 if request.RetryPolicy() != nil { 3577 policy = *request.RetryPolicy() 3578 } 3579 ociResponse, err = common.Retry(ctx, request, client.listAvailabilityDomains, policy) 3580 if err != nil { 3581 if ociResponse != nil { 3582 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3583 opcRequestId := httpResponse.Header.Get("opc-request-id") 3584 response = ListAvailabilityDomainsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3585 } else { 3586 response = ListAvailabilityDomainsResponse{} 3587 } 3588 } 3589 return 3590 } 3591 if convertedResponse, ok := ociResponse.(ListAvailabilityDomainsResponse); ok { 3592 response = convertedResponse 3593 } else { 3594 err = fmt.Errorf("failed to convert OCIResponse into ListAvailabilityDomainsResponse") 3595 } 3596 return 3597} 3598 3599// listAvailabilityDomains implements the OCIOperation interface (enables retrying operations) 3600func (client IdentityClient) listAvailabilityDomains(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3601 httpRequest, err := request.HTTPRequest(http.MethodGet, "/availabilityDomains") 3602 if err != nil { 3603 return nil, err 3604 } 3605 3606 var response ListAvailabilityDomainsResponse 3607 var httpResponse *http.Response 3608 httpResponse, err = client.Call(ctx, &httpRequest) 3609 defer common.CloseBodyIfValid(httpResponse) 3610 response.RawResponse = httpResponse 3611 if err != nil { 3612 return response, err 3613 } 3614 3615 err = common.UnmarshalResponse(httpResponse, &response) 3616 return response, err 3617} 3618 3619// ListBulkActionResourceTypes Lists the resource-types supported by compartment bulk actions. Use this API to help you provide the correct 3620// resource-type information to the BulkDeleteResources 3621// and BulkMoveResources operations. The returned list of 3622// resource-types provides the appropriate resource-type names to use with the bulk action operations along with 3623// the type of identifying information you'll need to provide for each resource-type. Most resource-types just 3624// require an OCID (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) to identify a specific resource, but some resource-types, 3625// such as buckets, require you to provide other identifying information. 3626func (client IdentityClient) ListBulkActionResourceTypes(ctx context.Context, request ListBulkActionResourceTypesRequest) (response ListBulkActionResourceTypesResponse, err error) { 3627 var ociResponse common.OCIResponse 3628 policy := common.NoRetryPolicy() 3629 if request.RetryPolicy() != nil { 3630 policy = *request.RetryPolicy() 3631 } 3632 ociResponse, err = common.Retry(ctx, request, client.listBulkActionResourceTypes, policy) 3633 if err != nil { 3634 if ociResponse != nil { 3635 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3636 opcRequestId := httpResponse.Header.Get("opc-request-id") 3637 response = ListBulkActionResourceTypesResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3638 } else { 3639 response = ListBulkActionResourceTypesResponse{} 3640 } 3641 } 3642 return 3643 } 3644 if convertedResponse, ok := ociResponse.(ListBulkActionResourceTypesResponse); ok { 3645 response = convertedResponse 3646 } else { 3647 err = fmt.Errorf("failed to convert OCIResponse into ListBulkActionResourceTypesResponse") 3648 } 3649 return 3650} 3651 3652// listBulkActionResourceTypes implements the OCIOperation interface (enables retrying operations) 3653func (client IdentityClient) listBulkActionResourceTypes(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3654 httpRequest, err := request.HTTPRequest(http.MethodGet, "/compartments/bulkActionResourceTypes") 3655 if err != nil { 3656 return nil, err 3657 } 3658 3659 var response ListBulkActionResourceTypesResponse 3660 var httpResponse *http.Response 3661 httpResponse, err = client.Call(ctx, &httpRequest) 3662 defer common.CloseBodyIfValid(httpResponse) 3663 response.RawResponse = httpResponse 3664 if err != nil { 3665 return response, err 3666 } 3667 3668 err = common.UnmarshalResponse(httpResponse, &response) 3669 return response, err 3670} 3671 3672// ListCompartments Lists the compartments in a specified compartment. The members of the list 3673// returned depends on the values set for several parameters. 3674// With the exception of the tenancy (root compartment), the ListCompartments operation 3675// returns only the first-level child compartments in the parent compartment specified in 3676// `compartmentId`. The list does not include any subcompartments of the child 3677// compartments (grandchildren). 3678// The parameter `accessLevel` specifies whether to return only those compartments for which the 3679// requestor has INSPECT permissions on at least one resource directly 3680// or indirectly (the resource can be in a subcompartment). 3681// The parameter `compartmentIdInSubtree` applies only when you perform ListCompartments on the 3682// tenancy (root compartment). When set to true, the entire hierarchy of compartments can be returned. 3683// To get a full list of all compartments and subcompartments in the tenancy (root compartment), 3684// set the parameter `compartmentIdInSubtree` to true and `accessLevel` to ANY. 3685// See Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five). 3686func (client IdentityClient) ListCompartments(ctx context.Context, request ListCompartmentsRequest) (response ListCompartmentsResponse, err error) { 3687 var ociResponse common.OCIResponse 3688 policy := common.NoRetryPolicy() 3689 if request.RetryPolicy() != nil { 3690 policy = *request.RetryPolicy() 3691 } 3692 ociResponse, err = common.Retry(ctx, request, client.listCompartments, policy) 3693 if err != nil { 3694 if ociResponse != nil { 3695 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3696 opcRequestId := httpResponse.Header.Get("opc-request-id") 3697 response = ListCompartmentsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3698 } else { 3699 response = ListCompartmentsResponse{} 3700 } 3701 } 3702 return 3703 } 3704 if convertedResponse, ok := ociResponse.(ListCompartmentsResponse); ok { 3705 response = convertedResponse 3706 } else { 3707 err = fmt.Errorf("failed to convert OCIResponse into ListCompartmentsResponse") 3708 } 3709 return 3710} 3711 3712// listCompartments implements the OCIOperation interface (enables retrying operations) 3713func (client IdentityClient) listCompartments(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3714 httpRequest, err := request.HTTPRequest(http.MethodGet, "/compartments") 3715 if err != nil { 3716 return nil, err 3717 } 3718 3719 var response ListCompartmentsResponse 3720 var httpResponse *http.Response 3721 httpResponse, err = client.Call(ctx, &httpRequest) 3722 defer common.CloseBodyIfValid(httpResponse) 3723 response.RawResponse = httpResponse 3724 if err != nil { 3725 return response, err 3726 } 3727 3728 err = common.UnmarshalResponse(httpResponse, &response) 3729 return response, err 3730} 3731 3732// ListCostTrackingTags Lists all the tags enabled for cost-tracking in the specified tenancy. For information about 3733// cost-tracking tags, see Using Cost-tracking Tags (https://docs.cloud.oracle.com/Content/Identity/Concepts/taggingoverview.htm#costs). 3734func (client IdentityClient) ListCostTrackingTags(ctx context.Context, request ListCostTrackingTagsRequest) (response ListCostTrackingTagsResponse, err error) { 3735 var ociResponse common.OCIResponse 3736 policy := common.NoRetryPolicy() 3737 if request.RetryPolicy() != nil { 3738 policy = *request.RetryPolicy() 3739 } 3740 ociResponse, err = common.Retry(ctx, request, client.listCostTrackingTags, policy) 3741 if err != nil { 3742 if ociResponse != nil { 3743 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3744 opcRequestId := httpResponse.Header.Get("opc-request-id") 3745 response = ListCostTrackingTagsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3746 } else { 3747 response = ListCostTrackingTagsResponse{} 3748 } 3749 } 3750 return 3751 } 3752 if convertedResponse, ok := ociResponse.(ListCostTrackingTagsResponse); ok { 3753 response = convertedResponse 3754 } else { 3755 err = fmt.Errorf("failed to convert OCIResponse into ListCostTrackingTagsResponse") 3756 } 3757 return 3758} 3759 3760// listCostTrackingTags implements the OCIOperation interface (enables retrying operations) 3761func (client IdentityClient) listCostTrackingTags(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3762 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tagNamespaces/actions/listCostTrackingTags") 3763 if err != nil { 3764 return nil, err 3765 } 3766 3767 var response ListCostTrackingTagsResponse 3768 var httpResponse *http.Response 3769 httpResponse, err = client.Call(ctx, &httpRequest) 3770 defer common.CloseBodyIfValid(httpResponse) 3771 response.RawResponse = httpResponse 3772 if err != nil { 3773 return response, err 3774 } 3775 3776 err = common.UnmarshalResponse(httpResponse, &response) 3777 return response, err 3778} 3779 3780// ListCustomerSecretKeys Lists the secret keys for the specified user. The returned object contains the secret key's OCID, but not 3781// the secret key itself. The actual secret key is returned only upon creation. 3782func (client IdentityClient) ListCustomerSecretKeys(ctx context.Context, request ListCustomerSecretKeysRequest) (response ListCustomerSecretKeysResponse, err error) { 3783 var ociResponse common.OCIResponse 3784 policy := common.NoRetryPolicy() 3785 if request.RetryPolicy() != nil { 3786 policy = *request.RetryPolicy() 3787 } 3788 ociResponse, err = common.Retry(ctx, request, client.listCustomerSecretKeys, policy) 3789 if err != nil { 3790 if ociResponse != nil { 3791 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3792 opcRequestId := httpResponse.Header.Get("opc-request-id") 3793 response = ListCustomerSecretKeysResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3794 } else { 3795 response = ListCustomerSecretKeysResponse{} 3796 } 3797 } 3798 return 3799 } 3800 if convertedResponse, ok := ociResponse.(ListCustomerSecretKeysResponse); ok { 3801 response = convertedResponse 3802 } else { 3803 err = fmt.Errorf("failed to convert OCIResponse into ListCustomerSecretKeysResponse") 3804 } 3805 return 3806} 3807 3808// listCustomerSecretKeys implements the OCIOperation interface (enables retrying operations) 3809func (client IdentityClient) listCustomerSecretKeys(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3810 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}/customerSecretKeys") 3811 if err != nil { 3812 return nil, err 3813 } 3814 3815 var response ListCustomerSecretKeysResponse 3816 var httpResponse *http.Response 3817 httpResponse, err = client.Call(ctx, &httpRequest) 3818 defer common.CloseBodyIfValid(httpResponse) 3819 response.RawResponse = httpResponse 3820 if err != nil { 3821 return response, err 3822 } 3823 3824 err = common.UnmarshalResponse(httpResponse, &response) 3825 return response, err 3826} 3827 3828// ListDynamicGroups Lists the dynamic groups in your tenancy. You must specify your tenancy's OCID as the value for 3829// the compartment ID (remember that the tenancy is simply the root compartment). 3830// See Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five). 3831func (client IdentityClient) ListDynamicGroups(ctx context.Context, request ListDynamicGroupsRequest) (response ListDynamicGroupsResponse, err error) { 3832 var ociResponse common.OCIResponse 3833 policy := common.NoRetryPolicy() 3834 if request.RetryPolicy() != nil { 3835 policy = *request.RetryPolicy() 3836 } 3837 ociResponse, err = common.Retry(ctx, request, client.listDynamicGroups, policy) 3838 if err != nil { 3839 if ociResponse != nil { 3840 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3841 opcRequestId := httpResponse.Header.Get("opc-request-id") 3842 response = ListDynamicGroupsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3843 } else { 3844 response = ListDynamicGroupsResponse{} 3845 } 3846 } 3847 return 3848 } 3849 if convertedResponse, ok := ociResponse.(ListDynamicGroupsResponse); ok { 3850 response = convertedResponse 3851 } else { 3852 err = fmt.Errorf("failed to convert OCIResponse into ListDynamicGroupsResponse") 3853 } 3854 return 3855} 3856 3857// listDynamicGroups implements the OCIOperation interface (enables retrying operations) 3858func (client IdentityClient) listDynamicGroups(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3859 httpRequest, err := request.HTTPRequest(http.MethodGet, "/dynamicGroups") 3860 if err != nil { 3861 return nil, err 3862 } 3863 3864 var response ListDynamicGroupsResponse 3865 var httpResponse *http.Response 3866 httpResponse, err = client.Call(ctx, &httpRequest) 3867 defer common.CloseBodyIfValid(httpResponse) 3868 response.RawResponse = httpResponse 3869 if err != nil { 3870 return response, err 3871 } 3872 3873 err = common.UnmarshalResponse(httpResponse, &response) 3874 return response, err 3875} 3876 3877// ListFaultDomains Lists the Fault Domains in your tenancy. Specify the OCID of either the tenancy or another 3878// of your compartments as the value for the compartment ID (remember that the tenancy is simply the root compartment). 3879// See Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five). 3880func (client IdentityClient) ListFaultDomains(ctx context.Context, request ListFaultDomainsRequest) (response ListFaultDomainsResponse, err error) { 3881 var ociResponse common.OCIResponse 3882 policy := common.NoRetryPolicy() 3883 if request.RetryPolicy() != nil { 3884 policy = *request.RetryPolicy() 3885 } 3886 ociResponse, err = common.Retry(ctx, request, client.listFaultDomains, policy) 3887 if err != nil { 3888 if ociResponse != nil { 3889 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3890 opcRequestId := httpResponse.Header.Get("opc-request-id") 3891 response = ListFaultDomainsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3892 } else { 3893 response = ListFaultDomainsResponse{} 3894 } 3895 } 3896 return 3897 } 3898 if convertedResponse, ok := ociResponse.(ListFaultDomainsResponse); ok { 3899 response = convertedResponse 3900 } else { 3901 err = fmt.Errorf("failed to convert OCIResponse into ListFaultDomainsResponse") 3902 } 3903 return 3904} 3905 3906// listFaultDomains implements the OCIOperation interface (enables retrying operations) 3907func (client IdentityClient) listFaultDomains(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3908 httpRequest, err := request.HTTPRequest(http.MethodGet, "/faultDomains") 3909 if err != nil { 3910 return nil, err 3911 } 3912 3913 var response ListFaultDomainsResponse 3914 var httpResponse *http.Response 3915 httpResponse, err = client.Call(ctx, &httpRequest) 3916 defer common.CloseBodyIfValid(httpResponse) 3917 response.RawResponse = httpResponse 3918 if err != nil { 3919 return response, err 3920 } 3921 3922 err = common.UnmarshalResponse(httpResponse, &response) 3923 return response, err 3924} 3925 3926// ListGroups Lists the groups in your tenancy. You must specify your tenancy's OCID as the value for 3927// the compartment ID (remember that the tenancy is simply the root compartment). 3928// See Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five). 3929func (client IdentityClient) ListGroups(ctx context.Context, request ListGroupsRequest) (response ListGroupsResponse, err error) { 3930 var ociResponse common.OCIResponse 3931 policy := common.NoRetryPolicy() 3932 if request.RetryPolicy() != nil { 3933 policy = *request.RetryPolicy() 3934 } 3935 ociResponse, err = common.Retry(ctx, request, client.listGroups, policy) 3936 if err != nil { 3937 if ociResponse != nil { 3938 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3939 opcRequestId := httpResponse.Header.Get("opc-request-id") 3940 response = ListGroupsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3941 } else { 3942 response = ListGroupsResponse{} 3943 } 3944 } 3945 return 3946 } 3947 if convertedResponse, ok := ociResponse.(ListGroupsResponse); ok { 3948 response = convertedResponse 3949 } else { 3950 err = fmt.Errorf("failed to convert OCIResponse into ListGroupsResponse") 3951 } 3952 return 3953} 3954 3955// listGroups implements the OCIOperation interface (enables retrying operations) 3956func (client IdentityClient) listGroups(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 3957 httpRequest, err := request.HTTPRequest(http.MethodGet, "/groups") 3958 if err != nil { 3959 return nil, err 3960 } 3961 3962 var response ListGroupsResponse 3963 var httpResponse *http.Response 3964 httpResponse, err = client.Call(ctx, &httpRequest) 3965 defer common.CloseBodyIfValid(httpResponse) 3966 response.RawResponse = httpResponse 3967 if err != nil { 3968 return response, err 3969 } 3970 3971 err = common.UnmarshalResponse(httpResponse, &response) 3972 return response, err 3973} 3974 3975// ListIdentityProviderGroups Lists the identity provider groups. 3976func (client IdentityClient) ListIdentityProviderGroups(ctx context.Context, request ListIdentityProviderGroupsRequest) (response ListIdentityProviderGroupsResponse, err error) { 3977 var ociResponse common.OCIResponse 3978 policy := common.NoRetryPolicy() 3979 if request.RetryPolicy() != nil { 3980 policy = *request.RetryPolicy() 3981 } 3982 ociResponse, err = common.Retry(ctx, request, client.listIdentityProviderGroups, policy) 3983 if err != nil { 3984 if ociResponse != nil { 3985 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 3986 opcRequestId := httpResponse.Header.Get("opc-request-id") 3987 response = ListIdentityProviderGroupsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 3988 } else { 3989 response = ListIdentityProviderGroupsResponse{} 3990 } 3991 } 3992 return 3993 } 3994 if convertedResponse, ok := ociResponse.(ListIdentityProviderGroupsResponse); ok { 3995 response = convertedResponse 3996 } else { 3997 err = fmt.Errorf("failed to convert OCIResponse into ListIdentityProviderGroupsResponse") 3998 } 3999 return 4000} 4001 4002// listIdentityProviderGroups implements the OCIOperation interface (enables retrying operations) 4003func (client IdentityClient) listIdentityProviderGroups(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4004 httpRequest, err := request.HTTPRequest(http.MethodGet, "/identityProviders/{identityProviderId}/groups") 4005 if err != nil { 4006 return nil, err 4007 } 4008 4009 var response ListIdentityProviderGroupsResponse 4010 var httpResponse *http.Response 4011 httpResponse, err = client.Call(ctx, &httpRequest) 4012 defer common.CloseBodyIfValid(httpResponse) 4013 response.RawResponse = httpResponse 4014 if err != nil { 4015 return response, err 4016 } 4017 4018 err = common.UnmarshalResponse(httpResponse, &response) 4019 return response, err 4020} 4021 4022//listidentityprovider allows to unmarshal list of polymorphic IdentityProvider 4023type listidentityprovider []identityprovider 4024 4025//UnmarshalPolymorphicJSON unmarshals polymorphic json list of items 4026func (m *listidentityprovider) UnmarshalPolymorphicJSON(data []byte) (interface{}, error) { 4027 res := make([]IdentityProvider, len(*m)) 4028 for i, v := range *m { 4029 nn, err := v.UnmarshalPolymorphicJSON(v.JsonData) 4030 if err != nil { 4031 return nil, err 4032 } 4033 res[i] = nn.(IdentityProvider) 4034 } 4035 return res, nil 4036} 4037 4038// ListIdentityProviders Lists all the identity providers in your tenancy. You must specify the identity provider type (e.g., `SAML2` for 4039// identity providers using the SAML2.0 protocol). You must specify your tenancy's OCID as the value for the 4040// compartment ID (remember that the tenancy is simply the root compartment). 4041// See Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five). 4042func (client IdentityClient) ListIdentityProviders(ctx context.Context, request ListIdentityProvidersRequest) (response ListIdentityProvidersResponse, err error) { 4043 var ociResponse common.OCIResponse 4044 policy := common.NoRetryPolicy() 4045 if request.RetryPolicy() != nil { 4046 policy = *request.RetryPolicy() 4047 } 4048 ociResponse, err = common.Retry(ctx, request, client.listIdentityProviders, policy) 4049 if err != nil { 4050 if ociResponse != nil { 4051 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4052 opcRequestId := httpResponse.Header.Get("opc-request-id") 4053 response = ListIdentityProvidersResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4054 } else { 4055 response = ListIdentityProvidersResponse{} 4056 } 4057 } 4058 return 4059 } 4060 if convertedResponse, ok := ociResponse.(ListIdentityProvidersResponse); ok { 4061 response = convertedResponse 4062 } else { 4063 err = fmt.Errorf("failed to convert OCIResponse into ListIdentityProvidersResponse") 4064 } 4065 return 4066} 4067 4068// listIdentityProviders implements the OCIOperation interface (enables retrying operations) 4069func (client IdentityClient) listIdentityProviders(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4070 httpRequest, err := request.HTTPRequest(http.MethodGet, "/identityProviders") 4071 if err != nil { 4072 return nil, err 4073 } 4074 4075 var response ListIdentityProvidersResponse 4076 var httpResponse *http.Response 4077 httpResponse, err = client.Call(ctx, &httpRequest) 4078 defer common.CloseBodyIfValid(httpResponse) 4079 response.RawResponse = httpResponse 4080 if err != nil { 4081 return response, err 4082 } 4083 4084 err = common.UnmarshalResponseWithPolymorphicBody(httpResponse, &response, &listidentityprovider{}) 4085 return response, err 4086} 4087 4088// ListIdpGroupMappings Lists the group mappings for the specified identity provider. 4089func (client IdentityClient) ListIdpGroupMappings(ctx context.Context, request ListIdpGroupMappingsRequest) (response ListIdpGroupMappingsResponse, err error) { 4090 var ociResponse common.OCIResponse 4091 policy := common.NoRetryPolicy() 4092 if request.RetryPolicy() != nil { 4093 policy = *request.RetryPolicy() 4094 } 4095 ociResponse, err = common.Retry(ctx, request, client.listIdpGroupMappings, policy) 4096 if err != nil { 4097 if ociResponse != nil { 4098 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4099 opcRequestId := httpResponse.Header.Get("opc-request-id") 4100 response = ListIdpGroupMappingsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4101 } else { 4102 response = ListIdpGroupMappingsResponse{} 4103 } 4104 } 4105 return 4106 } 4107 if convertedResponse, ok := ociResponse.(ListIdpGroupMappingsResponse); ok { 4108 response = convertedResponse 4109 } else { 4110 err = fmt.Errorf("failed to convert OCIResponse into ListIdpGroupMappingsResponse") 4111 } 4112 return 4113} 4114 4115// listIdpGroupMappings implements the OCIOperation interface (enables retrying operations) 4116func (client IdentityClient) listIdpGroupMappings(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4117 httpRequest, err := request.HTTPRequest(http.MethodGet, "/identityProviders/{identityProviderId}/groupMappings") 4118 if err != nil { 4119 return nil, err 4120 } 4121 4122 var response ListIdpGroupMappingsResponse 4123 var httpResponse *http.Response 4124 httpResponse, err = client.Call(ctx, &httpRequest) 4125 defer common.CloseBodyIfValid(httpResponse) 4126 response.RawResponse = httpResponse 4127 if err != nil { 4128 return response, err 4129 } 4130 4131 err = common.UnmarshalResponse(httpResponse, &response) 4132 return response, err 4133} 4134 4135// ListMfaTotpDevices Lists the MFA TOTP devices for the specified user. The returned object contains the device's OCID, but not 4136// the seed. The seed is returned only upon creation or when the IAM service regenerates the MFA seed for the device. 4137func (client IdentityClient) ListMfaTotpDevices(ctx context.Context, request ListMfaTotpDevicesRequest) (response ListMfaTotpDevicesResponse, err error) { 4138 var ociResponse common.OCIResponse 4139 policy := common.NoRetryPolicy() 4140 if request.RetryPolicy() != nil { 4141 policy = *request.RetryPolicy() 4142 } 4143 ociResponse, err = common.Retry(ctx, request, client.listMfaTotpDevices, policy) 4144 if err != nil { 4145 if ociResponse != nil { 4146 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4147 opcRequestId := httpResponse.Header.Get("opc-request-id") 4148 response = ListMfaTotpDevicesResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4149 } else { 4150 response = ListMfaTotpDevicesResponse{} 4151 } 4152 } 4153 return 4154 } 4155 if convertedResponse, ok := ociResponse.(ListMfaTotpDevicesResponse); ok { 4156 response = convertedResponse 4157 } else { 4158 err = fmt.Errorf("failed to convert OCIResponse into ListMfaTotpDevicesResponse") 4159 } 4160 return 4161} 4162 4163// listMfaTotpDevices implements the OCIOperation interface (enables retrying operations) 4164func (client IdentityClient) listMfaTotpDevices(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4165 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}/mfaTotpDevices") 4166 if err != nil { 4167 return nil, err 4168 } 4169 4170 var response ListMfaTotpDevicesResponse 4171 var httpResponse *http.Response 4172 httpResponse, err = client.Call(ctx, &httpRequest) 4173 defer common.CloseBodyIfValid(httpResponse) 4174 response.RawResponse = httpResponse 4175 if err != nil { 4176 return response, err 4177 } 4178 4179 err = common.UnmarshalResponse(httpResponse, &response) 4180 return response, err 4181} 4182 4183// ListNetworkSources Lists the network sources in your tenancy. You must specify your tenancy's OCID as the value for 4184// the compartment ID (remember that the tenancy is simply the root compartment). 4185// See Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five). 4186func (client IdentityClient) ListNetworkSources(ctx context.Context, request ListNetworkSourcesRequest) (response ListNetworkSourcesResponse, err error) { 4187 var ociResponse common.OCIResponse 4188 policy := common.NoRetryPolicy() 4189 if request.RetryPolicy() != nil { 4190 policy = *request.RetryPolicy() 4191 } 4192 ociResponse, err = common.Retry(ctx, request, client.listNetworkSources, policy) 4193 if err != nil { 4194 if ociResponse != nil { 4195 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4196 opcRequestId := httpResponse.Header.Get("opc-request-id") 4197 response = ListNetworkSourcesResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4198 } else { 4199 response = ListNetworkSourcesResponse{} 4200 } 4201 } 4202 return 4203 } 4204 if convertedResponse, ok := ociResponse.(ListNetworkSourcesResponse); ok { 4205 response = convertedResponse 4206 } else { 4207 err = fmt.Errorf("failed to convert OCIResponse into ListNetworkSourcesResponse") 4208 } 4209 return 4210} 4211 4212// listNetworkSources implements the OCIOperation interface (enables retrying operations) 4213func (client IdentityClient) listNetworkSources(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4214 httpRequest, err := request.HTTPRequest(http.MethodGet, "/networkSources") 4215 if err != nil { 4216 return nil, err 4217 } 4218 4219 var response ListNetworkSourcesResponse 4220 var httpResponse *http.Response 4221 httpResponse, err = client.Call(ctx, &httpRequest) 4222 defer common.CloseBodyIfValid(httpResponse) 4223 response.RawResponse = httpResponse 4224 if err != nil { 4225 return response, err 4226 } 4227 4228 err = common.UnmarshalResponse(httpResponse, &response) 4229 return response, err 4230} 4231 4232// ListOAuthClientCredentials List of Oauth tokens for the user 4233func (client IdentityClient) ListOAuthClientCredentials(ctx context.Context, request ListOAuthClientCredentialsRequest) (response ListOAuthClientCredentialsResponse, err error) { 4234 var ociResponse common.OCIResponse 4235 policy := common.NoRetryPolicy() 4236 if request.RetryPolicy() != nil { 4237 policy = *request.RetryPolicy() 4238 } 4239 ociResponse, err = common.Retry(ctx, request, client.listOAuthClientCredentials, policy) 4240 if err != nil { 4241 if ociResponse != nil { 4242 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4243 opcRequestId := httpResponse.Header.Get("opc-request-id") 4244 response = ListOAuthClientCredentialsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4245 } else { 4246 response = ListOAuthClientCredentialsResponse{} 4247 } 4248 } 4249 return 4250 } 4251 if convertedResponse, ok := ociResponse.(ListOAuthClientCredentialsResponse); ok { 4252 response = convertedResponse 4253 } else { 4254 err = fmt.Errorf("failed to convert OCIResponse into ListOAuthClientCredentialsResponse") 4255 } 4256 return 4257} 4258 4259// listOAuthClientCredentials implements the OCIOperation interface (enables retrying operations) 4260func (client IdentityClient) listOAuthClientCredentials(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4261 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}/oauth2ClientCredentials") 4262 if err != nil { 4263 return nil, err 4264 } 4265 4266 var response ListOAuthClientCredentialsResponse 4267 var httpResponse *http.Response 4268 httpResponse, err = client.Call(ctx, &httpRequest) 4269 defer common.CloseBodyIfValid(httpResponse) 4270 response.RawResponse = httpResponse 4271 if err != nil { 4272 return response, err 4273 } 4274 4275 err = common.UnmarshalResponse(httpResponse, &response) 4276 return response, err 4277} 4278 4279// ListPolicies Lists the policies in the specified compartment (either the tenancy or another of your compartments). 4280// See Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five). 4281// To determine which policies apply to a particular group or compartment, you must view the individual 4282// statements inside all your policies. There isn't a way to automatically obtain that information via the API. 4283func (client IdentityClient) ListPolicies(ctx context.Context, request ListPoliciesRequest) (response ListPoliciesResponse, err error) { 4284 var ociResponse common.OCIResponse 4285 policy := common.NoRetryPolicy() 4286 if request.RetryPolicy() != nil { 4287 policy = *request.RetryPolicy() 4288 } 4289 ociResponse, err = common.Retry(ctx, request, client.listPolicies, policy) 4290 if err != nil { 4291 if ociResponse != nil { 4292 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4293 opcRequestId := httpResponse.Header.Get("opc-request-id") 4294 response = ListPoliciesResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4295 } else { 4296 response = ListPoliciesResponse{} 4297 } 4298 } 4299 return 4300 } 4301 if convertedResponse, ok := ociResponse.(ListPoliciesResponse); ok { 4302 response = convertedResponse 4303 } else { 4304 err = fmt.Errorf("failed to convert OCIResponse into ListPoliciesResponse") 4305 } 4306 return 4307} 4308 4309// listPolicies implements the OCIOperation interface (enables retrying operations) 4310func (client IdentityClient) listPolicies(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4311 httpRequest, err := request.HTTPRequest(http.MethodGet, "/policies") 4312 if err != nil { 4313 return nil, err 4314 } 4315 4316 var response ListPoliciesResponse 4317 var httpResponse *http.Response 4318 httpResponse, err = client.Call(ctx, &httpRequest) 4319 defer common.CloseBodyIfValid(httpResponse) 4320 response.RawResponse = httpResponse 4321 if err != nil { 4322 return response, err 4323 } 4324 4325 err = common.UnmarshalResponse(httpResponse, &response) 4326 return response, err 4327} 4328 4329// ListRegionSubscriptions Lists the region subscriptions for the specified tenancy. 4330func (client IdentityClient) ListRegionSubscriptions(ctx context.Context, request ListRegionSubscriptionsRequest) (response ListRegionSubscriptionsResponse, err error) { 4331 var ociResponse common.OCIResponse 4332 policy := common.NoRetryPolicy() 4333 if request.RetryPolicy() != nil { 4334 policy = *request.RetryPolicy() 4335 } 4336 ociResponse, err = common.Retry(ctx, request, client.listRegionSubscriptions, policy) 4337 if err != nil { 4338 if ociResponse != nil { 4339 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4340 opcRequestId := httpResponse.Header.Get("opc-request-id") 4341 response = ListRegionSubscriptionsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4342 } else { 4343 response = ListRegionSubscriptionsResponse{} 4344 } 4345 } 4346 return 4347 } 4348 if convertedResponse, ok := ociResponse.(ListRegionSubscriptionsResponse); ok { 4349 response = convertedResponse 4350 } else { 4351 err = fmt.Errorf("failed to convert OCIResponse into ListRegionSubscriptionsResponse") 4352 } 4353 return 4354} 4355 4356// listRegionSubscriptions implements the OCIOperation interface (enables retrying operations) 4357func (client IdentityClient) listRegionSubscriptions(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4358 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tenancies/{tenancyId}/regionSubscriptions") 4359 if err != nil { 4360 return nil, err 4361 } 4362 4363 var response ListRegionSubscriptionsResponse 4364 var httpResponse *http.Response 4365 httpResponse, err = client.Call(ctx, &httpRequest) 4366 defer common.CloseBodyIfValid(httpResponse) 4367 response.RawResponse = httpResponse 4368 if err != nil { 4369 return response, err 4370 } 4371 4372 err = common.UnmarshalResponse(httpResponse, &response) 4373 return response, err 4374} 4375 4376// ListRegions Lists all the regions offered by Oracle Cloud Infrastructure. 4377func (client IdentityClient) ListRegions(ctx context.Context) (response ListRegionsResponse, err error) { 4378 var ociResponse common.OCIResponse 4379 ociResponse, err = client.listRegions(ctx) 4380 if err != nil { 4381 if ociResponse != nil { 4382 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4383 opcRequestId := httpResponse.Header.Get("opc-request-id") 4384 response = ListRegionsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4385 } else { 4386 response = ListRegionsResponse{} 4387 } 4388 } 4389 return 4390 } 4391 if convertedResponse, ok := ociResponse.(ListRegionsResponse); ok { 4392 response = convertedResponse 4393 } else { 4394 err = fmt.Errorf("failed to convert OCIResponse into ListRegionsResponse") 4395 } 4396 return 4397} 4398 4399// listRegions performs the request (retry policy is not enabled without a request object) 4400func (client IdentityClient) listRegions(ctx context.Context) (common.OCIResponse, error) { 4401 httpRequest := common.MakeDefaultHTTPRequest(http.MethodGet, "/regions") 4402 var err error 4403 4404 var response ListRegionsResponse 4405 var httpResponse *http.Response 4406 httpResponse, err = client.Call(ctx, &httpRequest) 4407 defer common.CloseBodyIfValid(httpResponse) 4408 response.RawResponse = httpResponse 4409 if err != nil { 4410 return response, err 4411 } 4412 4413 err = common.UnmarshalResponse(httpResponse, &response) 4414 return response, err 4415} 4416 4417// ListSmtpCredentials Lists the SMTP credentials for the specified user. The returned object contains the credential's OCID, 4418// the SMTP user name but not the SMTP password. The SMTP password is returned only upon creation. 4419func (client IdentityClient) ListSmtpCredentials(ctx context.Context, request ListSmtpCredentialsRequest) (response ListSmtpCredentialsResponse, err error) { 4420 var ociResponse common.OCIResponse 4421 policy := common.NoRetryPolicy() 4422 if request.RetryPolicy() != nil { 4423 policy = *request.RetryPolicy() 4424 } 4425 ociResponse, err = common.Retry(ctx, request, client.listSmtpCredentials, policy) 4426 if err != nil { 4427 if ociResponse != nil { 4428 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4429 opcRequestId := httpResponse.Header.Get("opc-request-id") 4430 response = ListSmtpCredentialsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4431 } else { 4432 response = ListSmtpCredentialsResponse{} 4433 } 4434 } 4435 return 4436 } 4437 if convertedResponse, ok := ociResponse.(ListSmtpCredentialsResponse); ok { 4438 response = convertedResponse 4439 } else { 4440 err = fmt.Errorf("failed to convert OCIResponse into ListSmtpCredentialsResponse") 4441 } 4442 return 4443} 4444 4445// listSmtpCredentials implements the OCIOperation interface (enables retrying operations) 4446func (client IdentityClient) listSmtpCredentials(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4447 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}/smtpCredentials") 4448 if err != nil { 4449 return nil, err 4450 } 4451 4452 var response ListSmtpCredentialsResponse 4453 var httpResponse *http.Response 4454 httpResponse, err = client.Call(ctx, &httpRequest) 4455 defer common.CloseBodyIfValid(httpResponse) 4456 response.RawResponse = httpResponse 4457 if err != nil { 4458 return response, err 4459 } 4460 4461 err = common.UnmarshalResponse(httpResponse, &response) 4462 return response, err 4463} 4464 4465// ListSwiftPasswords **Deprecated. Use ListAuthTokens instead.** 4466// Lists the Swift passwords for the specified user. The returned object contains the password's OCID, but not 4467// the password itself. The actual password is returned only upon creation. 4468func (client IdentityClient) ListSwiftPasswords(ctx context.Context, request ListSwiftPasswordsRequest) (response ListSwiftPasswordsResponse, err error) { 4469 var ociResponse common.OCIResponse 4470 policy := common.NoRetryPolicy() 4471 if request.RetryPolicy() != nil { 4472 policy = *request.RetryPolicy() 4473 } 4474 ociResponse, err = common.Retry(ctx, request, client.listSwiftPasswords, policy) 4475 if err != nil { 4476 if ociResponse != nil { 4477 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4478 opcRequestId := httpResponse.Header.Get("opc-request-id") 4479 response = ListSwiftPasswordsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4480 } else { 4481 response = ListSwiftPasswordsResponse{} 4482 } 4483 } 4484 return 4485 } 4486 if convertedResponse, ok := ociResponse.(ListSwiftPasswordsResponse); ok { 4487 response = convertedResponse 4488 } else { 4489 err = fmt.Errorf("failed to convert OCIResponse into ListSwiftPasswordsResponse") 4490 } 4491 return 4492} 4493 4494// listSwiftPasswords implements the OCIOperation interface (enables retrying operations) 4495func (client IdentityClient) listSwiftPasswords(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4496 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users/{userId}/swiftPasswords") 4497 if err != nil { 4498 return nil, err 4499 } 4500 4501 var response ListSwiftPasswordsResponse 4502 var httpResponse *http.Response 4503 httpResponse, err = client.Call(ctx, &httpRequest) 4504 defer common.CloseBodyIfValid(httpResponse) 4505 response.RawResponse = httpResponse 4506 if err != nil { 4507 return response, err 4508 } 4509 4510 err = common.UnmarshalResponse(httpResponse, &response) 4511 return response, err 4512} 4513 4514// ListTagDefaults Lists the tag defaults for tag definitions in the specified compartment. 4515func (client IdentityClient) ListTagDefaults(ctx context.Context, request ListTagDefaultsRequest) (response ListTagDefaultsResponse, err error) { 4516 var ociResponse common.OCIResponse 4517 policy := common.NoRetryPolicy() 4518 if request.RetryPolicy() != nil { 4519 policy = *request.RetryPolicy() 4520 } 4521 ociResponse, err = common.Retry(ctx, request, client.listTagDefaults, policy) 4522 if err != nil { 4523 if ociResponse != nil { 4524 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4525 opcRequestId := httpResponse.Header.Get("opc-request-id") 4526 response = ListTagDefaultsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4527 } else { 4528 response = ListTagDefaultsResponse{} 4529 } 4530 } 4531 return 4532 } 4533 if convertedResponse, ok := ociResponse.(ListTagDefaultsResponse); ok { 4534 response = convertedResponse 4535 } else { 4536 err = fmt.Errorf("failed to convert OCIResponse into ListTagDefaultsResponse") 4537 } 4538 return 4539} 4540 4541// listTagDefaults implements the OCIOperation interface (enables retrying operations) 4542func (client IdentityClient) listTagDefaults(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4543 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tagDefaults") 4544 if err != nil { 4545 return nil, err 4546 } 4547 4548 var response ListTagDefaultsResponse 4549 var httpResponse *http.Response 4550 httpResponse, err = client.Call(ctx, &httpRequest) 4551 defer common.CloseBodyIfValid(httpResponse) 4552 response.RawResponse = httpResponse 4553 if err != nil { 4554 return response, err 4555 } 4556 4557 err = common.UnmarshalResponse(httpResponse, &response) 4558 return response, err 4559} 4560 4561// ListTagNamespaces Lists the tag namespaces in the specified compartment. 4562func (client IdentityClient) ListTagNamespaces(ctx context.Context, request ListTagNamespacesRequest) (response ListTagNamespacesResponse, err error) { 4563 var ociResponse common.OCIResponse 4564 policy := common.NoRetryPolicy() 4565 if request.RetryPolicy() != nil { 4566 policy = *request.RetryPolicy() 4567 } 4568 ociResponse, err = common.Retry(ctx, request, client.listTagNamespaces, policy) 4569 if err != nil { 4570 if ociResponse != nil { 4571 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4572 opcRequestId := httpResponse.Header.Get("opc-request-id") 4573 response = ListTagNamespacesResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4574 } else { 4575 response = ListTagNamespacesResponse{} 4576 } 4577 } 4578 return 4579 } 4580 if convertedResponse, ok := ociResponse.(ListTagNamespacesResponse); ok { 4581 response = convertedResponse 4582 } else { 4583 err = fmt.Errorf("failed to convert OCIResponse into ListTagNamespacesResponse") 4584 } 4585 return 4586} 4587 4588// listTagNamespaces implements the OCIOperation interface (enables retrying operations) 4589func (client IdentityClient) listTagNamespaces(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4590 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tagNamespaces") 4591 if err != nil { 4592 return nil, err 4593 } 4594 4595 var response ListTagNamespacesResponse 4596 var httpResponse *http.Response 4597 httpResponse, err = client.Call(ctx, &httpRequest) 4598 defer common.CloseBodyIfValid(httpResponse) 4599 response.RawResponse = httpResponse 4600 if err != nil { 4601 return response, err 4602 } 4603 4604 err = common.UnmarshalResponse(httpResponse, &response) 4605 return response, err 4606} 4607 4608// ListTaggingWorkRequestErrors Gets the errors for a work request. 4609func (client IdentityClient) ListTaggingWorkRequestErrors(ctx context.Context, request ListTaggingWorkRequestErrorsRequest) (response ListTaggingWorkRequestErrorsResponse, err error) { 4610 var ociResponse common.OCIResponse 4611 policy := common.NoRetryPolicy() 4612 if request.RetryPolicy() != nil { 4613 policy = *request.RetryPolicy() 4614 } 4615 ociResponse, err = common.Retry(ctx, request, client.listTaggingWorkRequestErrors, policy) 4616 if err != nil { 4617 if ociResponse != nil { 4618 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4619 opcRequestId := httpResponse.Header.Get("opc-request-id") 4620 response = ListTaggingWorkRequestErrorsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4621 } else { 4622 response = ListTaggingWorkRequestErrorsResponse{} 4623 } 4624 } 4625 return 4626 } 4627 if convertedResponse, ok := ociResponse.(ListTaggingWorkRequestErrorsResponse); ok { 4628 response = convertedResponse 4629 } else { 4630 err = fmt.Errorf("failed to convert OCIResponse into ListTaggingWorkRequestErrorsResponse") 4631 } 4632 return 4633} 4634 4635// listTaggingWorkRequestErrors implements the OCIOperation interface (enables retrying operations) 4636func (client IdentityClient) listTaggingWorkRequestErrors(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4637 httpRequest, err := request.HTTPRequest(http.MethodGet, "/taggingWorkRequests/{workRequestId}/errors") 4638 if err != nil { 4639 return nil, err 4640 } 4641 4642 var response ListTaggingWorkRequestErrorsResponse 4643 var httpResponse *http.Response 4644 httpResponse, err = client.Call(ctx, &httpRequest) 4645 defer common.CloseBodyIfValid(httpResponse) 4646 response.RawResponse = httpResponse 4647 if err != nil { 4648 return response, err 4649 } 4650 4651 err = common.UnmarshalResponse(httpResponse, &response) 4652 return response, err 4653} 4654 4655// ListTaggingWorkRequestLogs Gets the logs for a work request. 4656func (client IdentityClient) ListTaggingWorkRequestLogs(ctx context.Context, request ListTaggingWorkRequestLogsRequest) (response ListTaggingWorkRequestLogsResponse, err error) { 4657 var ociResponse common.OCIResponse 4658 policy := common.NoRetryPolicy() 4659 if request.RetryPolicy() != nil { 4660 policy = *request.RetryPolicy() 4661 } 4662 ociResponse, err = common.Retry(ctx, request, client.listTaggingWorkRequestLogs, policy) 4663 if err != nil { 4664 if ociResponse != nil { 4665 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4666 opcRequestId := httpResponse.Header.Get("opc-request-id") 4667 response = ListTaggingWorkRequestLogsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4668 } else { 4669 response = ListTaggingWorkRequestLogsResponse{} 4670 } 4671 } 4672 return 4673 } 4674 if convertedResponse, ok := ociResponse.(ListTaggingWorkRequestLogsResponse); ok { 4675 response = convertedResponse 4676 } else { 4677 err = fmt.Errorf("failed to convert OCIResponse into ListTaggingWorkRequestLogsResponse") 4678 } 4679 return 4680} 4681 4682// listTaggingWorkRequestLogs implements the OCIOperation interface (enables retrying operations) 4683func (client IdentityClient) listTaggingWorkRequestLogs(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4684 httpRequest, err := request.HTTPRequest(http.MethodGet, "/taggingWorkRequests/{workRequestId}/logs") 4685 if err != nil { 4686 return nil, err 4687 } 4688 4689 var response ListTaggingWorkRequestLogsResponse 4690 var httpResponse *http.Response 4691 httpResponse, err = client.Call(ctx, &httpRequest) 4692 defer common.CloseBodyIfValid(httpResponse) 4693 response.RawResponse = httpResponse 4694 if err != nil { 4695 return response, err 4696 } 4697 4698 err = common.UnmarshalResponse(httpResponse, &response) 4699 return response, err 4700} 4701 4702// ListTaggingWorkRequests Lists the tagging work requests in compartment. 4703func (client IdentityClient) ListTaggingWorkRequests(ctx context.Context, request ListTaggingWorkRequestsRequest) (response ListTaggingWorkRequestsResponse, err error) { 4704 var ociResponse common.OCIResponse 4705 policy := common.NoRetryPolicy() 4706 if request.RetryPolicy() != nil { 4707 policy = *request.RetryPolicy() 4708 } 4709 ociResponse, err = common.Retry(ctx, request, client.listTaggingWorkRequests, policy) 4710 if err != nil { 4711 if ociResponse != nil { 4712 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4713 opcRequestId := httpResponse.Header.Get("opc-request-id") 4714 response = ListTaggingWorkRequestsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4715 } else { 4716 response = ListTaggingWorkRequestsResponse{} 4717 } 4718 } 4719 return 4720 } 4721 if convertedResponse, ok := ociResponse.(ListTaggingWorkRequestsResponse); ok { 4722 response = convertedResponse 4723 } else { 4724 err = fmt.Errorf("failed to convert OCIResponse into ListTaggingWorkRequestsResponse") 4725 } 4726 return 4727} 4728 4729// listTaggingWorkRequests implements the OCIOperation interface (enables retrying operations) 4730func (client IdentityClient) listTaggingWorkRequests(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4731 httpRequest, err := request.HTTPRequest(http.MethodGet, "/taggingWorkRequests") 4732 if err != nil { 4733 return nil, err 4734 } 4735 4736 var response ListTaggingWorkRequestsResponse 4737 var httpResponse *http.Response 4738 httpResponse, err = client.Call(ctx, &httpRequest) 4739 defer common.CloseBodyIfValid(httpResponse) 4740 response.RawResponse = httpResponse 4741 if err != nil { 4742 return response, err 4743 } 4744 4745 err = common.UnmarshalResponse(httpResponse, &response) 4746 return response, err 4747} 4748 4749// ListTags Lists the tag definitions in the specified tag namespace. 4750func (client IdentityClient) ListTags(ctx context.Context, request ListTagsRequest) (response ListTagsResponse, err error) { 4751 var ociResponse common.OCIResponse 4752 policy := common.NoRetryPolicy() 4753 if request.RetryPolicy() != nil { 4754 policy = *request.RetryPolicy() 4755 } 4756 ociResponse, err = common.Retry(ctx, request, client.listTags, policy) 4757 if err != nil { 4758 if ociResponse != nil { 4759 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4760 opcRequestId := httpResponse.Header.Get("opc-request-id") 4761 response = ListTagsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4762 } else { 4763 response = ListTagsResponse{} 4764 } 4765 } 4766 return 4767 } 4768 if convertedResponse, ok := ociResponse.(ListTagsResponse); ok { 4769 response = convertedResponse 4770 } else { 4771 err = fmt.Errorf("failed to convert OCIResponse into ListTagsResponse") 4772 } 4773 return 4774} 4775 4776// listTags implements the OCIOperation interface (enables retrying operations) 4777func (client IdentityClient) listTags(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4778 httpRequest, err := request.HTTPRequest(http.MethodGet, "/tagNamespaces/{tagNamespaceId}/tags") 4779 if err != nil { 4780 return nil, err 4781 } 4782 4783 var response ListTagsResponse 4784 var httpResponse *http.Response 4785 httpResponse, err = client.Call(ctx, &httpRequest) 4786 defer common.CloseBodyIfValid(httpResponse) 4787 response.RawResponse = httpResponse 4788 if err != nil { 4789 return response, err 4790 } 4791 4792 err = common.UnmarshalResponse(httpResponse, &response) 4793 return response, err 4794} 4795 4796// ListUserGroupMemberships Lists the `UserGroupMembership` objects in your tenancy. You must specify your tenancy's OCID 4797// as the value for the compartment ID 4798// (see Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five)). 4799// You must also then filter the list in one of these ways: 4800// - You can limit the results to just the memberships for a given user by specifying a `userId`. 4801// - Similarly, you can limit the results to just the memberships for a given group by specifying a `groupId`. 4802// - You can set both the `userId` and `groupId` to determine if the specified user is in the specified group. 4803// If the answer is no, the response is an empty list. 4804// - Although`userId` and `groupId` are not individually required, you must set one of them. 4805func (client IdentityClient) ListUserGroupMemberships(ctx context.Context, request ListUserGroupMembershipsRequest) (response ListUserGroupMembershipsResponse, err error) { 4806 var ociResponse common.OCIResponse 4807 policy := common.NoRetryPolicy() 4808 if request.RetryPolicy() != nil { 4809 policy = *request.RetryPolicy() 4810 } 4811 ociResponse, err = common.Retry(ctx, request, client.listUserGroupMemberships, policy) 4812 if err != nil { 4813 if ociResponse != nil { 4814 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4815 opcRequestId := httpResponse.Header.Get("opc-request-id") 4816 response = ListUserGroupMembershipsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4817 } else { 4818 response = ListUserGroupMembershipsResponse{} 4819 } 4820 } 4821 return 4822 } 4823 if convertedResponse, ok := ociResponse.(ListUserGroupMembershipsResponse); ok { 4824 response = convertedResponse 4825 } else { 4826 err = fmt.Errorf("failed to convert OCIResponse into ListUserGroupMembershipsResponse") 4827 } 4828 return 4829} 4830 4831// listUserGroupMemberships implements the OCIOperation interface (enables retrying operations) 4832func (client IdentityClient) listUserGroupMemberships(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4833 httpRequest, err := request.HTTPRequest(http.MethodGet, "/userGroupMemberships") 4834 if err != nil { 4835 return nil, err 4836 } 4837 4838 var response ListUserGroupMembershipsResponse 4839 var httpResponse *http.Response 4840 httpResponse, err = client.Call(ctx, &httpRequest) 4841 defer common.CloseBodyIfValid(httpResponse) 4842 response.RawResponse = httpResponse 4843 if err != nil { 4844 return response, err 4845 } 4846 4847 err = common.UnmarshalResponse(httpResponse, &response) 4848 return response, err 4849} 4850 4851// ListUsers Lists the users in your tenancy. You must specify your tenancy's OCID as the value for the 4852// compartment ID (remember that the tenancy is simply the root compartment). 4853// See Where to Get the Tenancy's OCID and User's OCID (https://docs.cloud.oracle.com/Content/API/Concepts/apisigningkey.htm#five). 4854func (client IdentityClient) ListUsers(ctx context.Context, request ListUsersRequest) (response ListUsersResponse, err error) { 4855 var ociResponse common.OCIResponse 4856 policy := common.NoRetryPolicy() 4857 if request.RetryPolicy() != nil { 4858 policy = *request.RetryPolicy() 4859 } 4860 ociResponse, err = common.Retry(ctx, request, client.listUsers, policy) 4861 if err != nil { 4862 if ociResponse != nil { 4863 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4864 opcRequestId := httpResponse.Header.Get("opc-request-id") 4865 response = ListUsersResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4866 } else { 4867 response = ListUsersResponse{} 4868 } 4869 } 4870 return 4871 } 4872 if convertedResponse, ok := ociResponse.(ListUsersResponse); ok { 4873 response = convertedResponse 4874 } else { 4875 err = fmt.Errorf("failed to convert OCIResponse into ListUsersResponse") 4876 } 4877 return 4878} 4879 4880// listUsers implements the OCIOperation interface (enables retrying operations) 4881func (client IdentityClient) listUsers(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4882 httpRequest, err := request.HTTPRequest(http.MethodGet, "/users") 4883 if err != nil { 4884 return nil, err 4885 } 4886 4887 var response ListUsersResponse 4888 var httpResponse *http.Response 4889 httpResponse, err = client.Call(ctx, &httpRequest) 4890 defer common.CloseBodyIfValid(httpResponse) 4891 response.RawResponse = httpResponse 4892 if err != nil { 4893 return response, err 4894 } 4895 4896 err = common.UnmarshalResponse(httpResponse, &response) 4897 return response, err 4898} 4899 4900// ListWorkRequests Lists the work requests in compartment. 4901func (client IdentityClient) ListWorkRequests(ctx context.Context, request ListWorkRequestsRequest) (response ListWorkRequestsResponse, err error) { 4902 var ociResponse common.OCIResponse 4903 policy := common.NoRetryPolicy() 4904 if request.RetryPolicy() != nil { 4905 policy = *request.RetryPolicy() 4906 } 4907 ociResponse, err = common.Retry(ctx, request, client.listWorkRequests, policy) 4908 if err != nil { 4909 if ociResponse != nil { 4910 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4911 opcRequestId := httpResponse.Header.Get("opc-request-id") 4912 response = ListWorkRequestsResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4913 } else { 4914 response = ListWorkRequestsResponse{} 4915 } 4916 } 4917 return 4918 } 4919 if convertedResponse, ok := ociResponse.(ListWorkRequestsResponse); ok { 4920 response = convertedResponse 4921 } else { 4922 err = fmt.Errorf("failed to convert OCIResponse into ListWorkRequestsResponse") 4923 } 4924 return 4925} 4926 4927// listWorkRequests implements the OCIOperation interface (enables retrying operations) 4928func (client IdentityClient) listWorkRequests(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4929 httpRequest, err := request.HTTPRequest(http.MethodGet, "/workRequests") 4930 if err != nil { 4931 return nil, err 4932 } 4933 4934 var response ListWorkRequestsResponse 4935 var httpResponse *http.Response 4936 httpResponse, err = client.Call(ctx, &httpRequest) 4937 defer common.CloseBodyIfValid(httpResponse) 4938 response.RawResponse = httpResponse 4939 if err != nil { 4940 return response, err 4941 } 4942 4943 err = common.UnmarshalResponse(httpResponse, &response) 4944 return response, err 4945} 4946 4947// MoveCompartment Move the compartment to a different parent compartment in the same tenancy. When you move a 4948// compartment, all its contents (subcompartments and resources) are moved with it. Note that 4949// the `CompartmentId` that you specify in the path is the compartment that you want to move. 4950// **IMPORTANT**: After you move a compartment to a new parent compartment, the access policies of 4951// the new parent take effect and the policies of the previous parent no longer apply. Ensure that you 4952// are aware of the implications for the compartment contents before you move it. For more 4953// information, see Moving a Compartment (https://docs.cloud.oracle.com/Content/Identity/Tasks/managingcompartments.htm#MoveCompartment). 4954func (client IdentityClient) MoveCompartment(ctx context.Context, request MoveCompartmentRequest) (response MoveCompartmentResponse, err error) { 4955 var ociResponse common.OCIResponse 4956 policy := common.NoRetryPolicy() 4957 if request.RetryPolicy() != nil { 4958 policy = *request.RetryPolicy() 4959 } 4960 4961 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 4962 request.OpcRetryToken = common.String(common.RetryToken()) 4963 } 4964 4965 ociResponse, err = common.Retry(ctx, request, client.moveCompartment, policy) 4966 if err != nil { 4967 if ociResponse != nil { 4968 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 4969 opcRequestId := httpResponse.Header.Get("opc-request-id") 4970 response = MoveCompartmentResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 4971 } else { 4972 response = MoveCompartmentResponse{} 4973 } 4974 } 4975 return 4976 } 4977 if convertedResponse, ok := ociResponse.(MoveCompartmentResponse); ok { 4978 response = convertedResponse 4979 } else { 4980 err = fmt.Errorf("failed to convert OCIResponse into MoveCompartmentResponse") 4981 } 4982 return 4983} 4984 4985// moveCompartment implements the OCIOperation interface (enables retrying operations) 4986func (client IdentityClient) moveCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 4987 httpRequest, err := request.HTTPRequest(http.MethodPost, "/compartments/{compartmentId}/actions/moveCompartment") 4988 if err != nil { 4989 return nil, err 4990 } 4991 4992 var response MoveCompartmentResponse 4993 var httpResponse *http.Response 4994 httpResponse, err = client.Call(ctx, &httpRequest) 4995 defer common.CloseBodyIfValid(httpResponse) 4996 response.RawResponse = httpResponse 4997 if err != nil { 4998 return response, err 4999 } 5000 5001 err = common.UnmarshalResponse(httpResponse, &response) 5002 return response, err 5003} 5004 5005// RecoverCompartment Recover the compartment from DELETED state to ACTIVE state. 5006func (client IdentityClient) RecoverCompartment(ctx context.Context, request RecoverCompartmentRequest) (response RecoverCompartmentResponse, err error) { 5007 var ociResponse common.OCIResponse 5008 policy := common.NoRetryPolicy() 5009 if request.RetryPolicy() != nil { 5010 policy = *request.RetryPolicy() 5011 } 5012 ociResponse, err = common.Retry(ctx, request, client.recoverCompartment, policy) 5013 if err != nil { 5014 if ociResponse != nil { 5015 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5016 opcRequestId := httpResponse.Header.Get("opc-request-id") 5017 response = RecoverCompartmentResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5018 } else { 5019 response = RecoverCompartmentResponse{} 5020 } 5021 } 5022 return 5023 } 5024 if convertedResponse, ok := ociResponse.(RecoverCompartmentResponse); ok { 5025 response = convertedResponse 5026 } else { 5027 err = fmt.Errorf("failed to convert OCIResponse into RecoverCompartmentResponse") 5028 } 5029 return 5030} 5031 5032// recoverCompartment implements the OCIOperation interface (enables retrying operations) 5033func (client IdentityClient) recoverCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5034 httpRequest, err := request.HTTPRequest(http.MethodPost, "/compartments/{compartmentId}/actions/recoverCompartment") 5035 if err != nil { 5036 return nil, err 5037 } 5038 5039 var response RecoverCompartmentResponse 5040 var httpResponse *http.Response 5041 httpResponse, err = client.Call(ctx, &httpRequest) 5042 defer common.CloseBodyIfValid(httpResponse) 5043 response.RawResponse = httpResponse 5044 if err != nil { 5045 return response, err 5046 } 5047 5048 err = common.UnmarshalResponse(httpResponse, &response) 5049 return response, err 5050} 5051 5052// RemoveUserFromGroup Removes a user from a group by deleting the corresponding `UserGroupMembership`. 5053func (client IdentityClient) RemoveUserFromGroup(ctx context.Context, request RemoveUserFromGroupRequest) (response RemoveUserFromGroupResponse, err error) { 5054 var ociResponse common.OCIResponse 5055 policy := common.NoRetryPolicy() 5056 if request.RetryPolicy() != nil { 5057 policy = *request.RetryPolicy() 5058 } 5059 ociResponse, err = common.Retry(ctx, request, client.removeUserFromGroup, policy) 5060 if err != nil { 5061 if ociResponse != nil { 5062 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5063 opcRequestId := httpResponse.Header.Get("opc-request-id") 5064 response = RemoveUserFromGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5065 } else { 5066 response = RemoveUserFromGroupResponse{} 5067 } 5068 } 5069 return 5070 } 5071 if convertedResponse, ok := ociResponse.(RemoveUserFromGroupResponse); ok { 5072 response = convertedResponse 5073 } else { 5074 err = fmt.Errorf("failed to convert OCIResponse into RemoveUserFromGroupResponse") 5075 } 5076 return 5077} 5078 5079// removeUserFromGroup implements the OCIOperation interface (enables retrying operations) 5080func (client IdentityClient) removeUserFromGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5081 httpRequest, err := request.HTTPRequest(http.MethodDelete, "/userGroupMemberships/{userGroupMembershipId}") 5082 if err != nil { 5083 return nil, err 5084 } 5085 5086 var response RemoveUserFromGroupResponse 5087 var httpResponse *http.Response 5088 httpResponse, err = client.Call(ctx, &httpRequest) 5089 defer common.CloseBodyIfValid(httpResponse) 5090 response.RawResponse = httpResponse 5091 if err != nil { 5092 return response, err 5093 } 5094 5095 err = common.UnmarshalResponse(httpResponse, &response) 5096 return response, err 5097} 5098 5099// ResetIdpScimClient Resets the OAuth2 client credentials for the SCIM client associated with this identity provider. 5100func (client IdentityClient) ResetIdpScimClient(ctx context.Context, request ResetIdpScimClientRequest) (response ResetIdpScimClientResponse, err error) { 5101 var ociResponse common.OCIResponse 5102 policy := common.NoRetryPolicy() 5103 if request.RetryPolicy() != nil { 5104 policy = *request.RetryPolicy() 5105 } 5106 ociResponse, err = common.Retry(ctx, request, client.resetIdpScimClient, policy) 5107 if err != nil { 5108 if ociResponse != nil { 5109 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5110 opcRequestId := httpResponse.Header.Get("opc-request-id") 5111 response = ResetIdpScimClientResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5112 } else { 5113 response = ResetIdpScimClientResponse{} 5114 } 5115 } 5116 return 5117 } 5118 if convertedResponse, ok := ociResponse.(ResetIdpScimClientResponse); ok { 5119 response = convertedResponse 5120 } else { 5121 err = fmt.Errorf("failed to convert OCIResponse into ResetIdpScimClientResponse") 5122 } 5123 return 5124} 5125 5126// resetIdpScimClient implements the OCIOperation interface (enables retrying operations) 5127func (client IdentityClient) resetIdpScimClient(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5128 httpRequest, err := request.HTTPRequest(http.MethodPost, "/identityProviders/{identityProviderId}/actions/resetScimClient") 5129 if err != nil { 5130 return nil, err 5131 } 5132 5133 var response ResetIdpScimClientResponse 5134 var httpResponse *http.Response 5135 httpResponse, err = client.Call(ctx, &httpRequest) 5136 defer common.CloseBodyIfValid(httpResponse) 5137 response.RawResponse = httpResponse 5138 if err != nil { 5139 return response, err 5140 } 5141 5142 err = common.UnmarshalResponse(httpResponse, &response) 5143 return response, err 5144} 5145 5146// UpdateAuthToken Updates the specified auth token's description. 5147func (client IdentityClient) UpdateAuthToken(ctx context.Context, request UpdateAuthTokenRequest) (response UpdateAuthTokenResponse, err error) { 5148 var ociResponse common.OCIResponse 5149 policy := common.NoRetryPolicy() 5150 if request.RetryPolicy() != nil { 5151 policy = *request.RetryPolicy() 5152 } 5153 ociResponse, err = common.Retry(ctx, request, client.updateAuthToken, policy) 5154 if err != nil { 5155 if ociResponse != nil { 5156 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5157 opcRequestId := httpResponse.Header.Get("opc-request-id") 5158 response = UpdateAuthTokenResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5159 } else { 5160 response = UpdateAuthTokenResponse{} 5161 } 5162 } 5163 return 5164 } 5165 if convertedResponse, ok := ociResponse.(UpdateAuthTokenResponse); ok { 5166 response = convertedResponse 5167 } else { 5168 err = fmt.Errorf("failed to convert OCIResponse into UpdateAuthTokenResponse") 5169 } 5170 return 5171} 5172 5173// updateAuthToken implements the OCIOperation interface (enables retrying operations) 5174func (client IdentityClient) updateAuthToken(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5175 httpRequest, err := request.HTTPRequest(http.MethodPut, "/users/{userId}/authTokens/{authTokenId}") 5176 if err != nil { 5177 return nil, err 5178 } 5179 5180 var response UpdateAuthTokenResponse 5181 var httpResponse *http.Response 5182 httpResponse, err = client.Call(ctx, &httpRequest) 5183 defer common.CloseBodyIfValid(httpResponse) 5184 response.RawResponse = httpResponse 5185 if err != nil { 5186 return response, err 5187 } 5188 5189 err = common.UnmarshalResponse(httpResponse, &response) 5190 return response, err 5191} 5192 5193// UpdateAuthenticationPolicy Updates authentication policy for the specified tenancy 5194func (client IdentityClient) UpdateAuthenticationPolicy(ctx context.Context, request UpdateAuthenticationPolicyRequest) (response UpdateAuthenticationPolicyResponse, err error) { 5195 var ociResponse common.OCIResponse 5196 policy := common.NoRetryPolicy() 5197 if request.RetryPolicy() != nil { 5198 policy = *request.RetryPolicy() 5199 } 5200 ociResponse, err = common.Retry(ctx, request, client.updateAuthenticationPolicy, policy) 5201 if err != nil { 5202 if ociResponse != nil { 5203 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5204 opcRequestId := httpResponse.Header.Get("opc-request-id") 5205 response = UpdateAuthenticationPolicyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5206 } else { 5207 response = UpdateAuthenticationPolicyResponse{} 5208 } 5209 } 5210 return 5211 } 5212 if convertedResponse, ok := ociResponse.(UpdateAuthenticationPolicyResponse); ok { 5213 response = convertedResponse 5214 } else { 5215 err = fmt.Errorf("failed to convert OCIResponse into UpdateAuthenticationPolicyResponse") 5216 } 5217 return 5218} 5219 5220// updateAuthenticationPolicy implements the OCIOperation interface (enables retrying operations) 5221func (client IdentityClient) updateAuthenticationPolicy(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5222 httpRequest, err := request.HTTPRequest(http.MethodPut, "/authenticationPolicies/{compartmentId}") 5223 if err != nil { 5224 return nil, err 5225 } 5226 5227 var response UpdateAuthenticationPolicyResponse 5228 var httpResponse *http.Response 5229 httpResponse, err = client.Call(ctx, &httpRequest) 5230 defer common.CloseBodyIfValid(httpResponse) 5231 response.RawResponse = httpResponse 5232 if err != nil { 5233 return response, err 5234 } 5235 5236 err = common.UnmarshalResponse(httpResponse, &response) 5237 return response, err 5238} 5239 5240// UpdateCompartment Updates the specified compartment's description or name. You can't update the root compartment. 5241func (client IdentityClient) UpdateCompartment(ctx context.Context, request UpdateCompartmentRequest) (response UpdateCompartmentResponse, err error) { 5242 var ociResponse common.OCIResponse 5243 policy := common.NoRetryPolicy() 5244 if request.RetryPolicy() != nil { 5245 policy = *request.RetryPolicy() 5246 } 5247 ociResponse, err = common.Retry(ctx, request, client.updateCompartment, policy) 5248 if err != nil { 5249 if ociResponse != nil { 5250 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5251 opcRequestId := httpResponse.Header.Get("opc-request-id") 5252 response = UpdateCompartmentResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5253 } else { 5254 response = UpdateCompartmentResponse{} 5255 } 5256 } 5257 return 5258 } 5259 if convertedResponse, ok := ociResponse.(UpdateCompartmentResponse); ok { 5260 response = convertedResponse 5261 } else { 5262 err = fmt.Errorf("failed to convert OCIResponse into UpdateCompartmentResponse") 5263 } 5264 return 5265} 5266 5267// updateCompartment implements the OCIOperation interface (enables retrying operations) 5268func (client IdentityClient) updateCompartment(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5269 httpRequest, err := request.HTTPRequest(http.MethodPut, "/compartments/{compartmentId}") 5270 if err != nil { 5271 return nil, err 5272 } 5273 5274 var response UpdateCompartmentResponse 5275 var httpResponse *http.Response 5276 httpResponse, err = client.Call(ctx, &httpRequest) 5277 defer common.CloseBodyIfValid(httpResponse) 5278 response.RawResponse = httpResponse 5279 if err != nil { 5280 return response, err 5281 } 5282 5283 err = common.UnmarshalResponse(httpResponse, &response) 5284 return response, err 5285} 5286 5287// UpdateCustomerSecretKey Updates the specified secret key's description. 5288func (client IdentityClient) UpdateCustomerSecretKey(ctx context.Context, request UpdateCustomerSecretKeyRequest) (response UpdateCustomerSecretKeyResponse, err error) { 5289 var ociResponse common.OCIResponse 5290 policy := common.NoRetryPolicy() 5291 if request.RetryPolicy() != nil { 5292 policy = *request.RetryPolicy() 5293 } 5294 ociResponse, err = common.Retry(ctx, request, client.updateCustomerSecretKey, policy) 5295 if err != nil { 5296 if ociResponse != nil { 5297 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5298 opcRequestId := httpResponse.Header.Get("opc-request-id") 5299 response = UpdateCustomerSecretKeyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5300 } else { 5301 response = UpdateCustomerSecretKeyResponse{} 5302 } 5303 } 5304 return 5305 } 5306 if convertedResponse, ok := ociResponse.(UpdateCustomerSecretKeyResponse); ok { 5307 response = convertedResponse 5308 } else { 5309 err = fmt.Errorf("failed to convert OCIResponse into UpdateCustomerSecretKeyResponse") 5310 } 5311 return 5312} 5313 5314// updateCustomerSecretKey implements the OCIOperation interface (enables retrying operations) 5315func (client IdentityClient) updateCustomerSecretKey(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5316 httpRequest, err := request.HTTPRequest(http.MethodPut, "/users/{userId}/customerSecretKeys/{customerSecretKeyId}") 5317 if err != nil { 5318 return nil, err 5319 } 5320 5321 var response UpdateCustomerSecretKeyResponse 5322 var httpResponse *http.Response 5323 httpResponse, err = client.Call(ctx, &httpRequest) 5324 defer common.CloseBodyIfValid(httpResponse) 5325 response.RawResponse = httpResponse 5326 if err != nil { 5327 return response, err 5328 } 5329 5330 err = common.UnmarshalResponse(httpResponse, &response) 5331 return response, err 5332} 5333 5334// UpdateDynamicGroup Updates the specified dynamic group. 5335func (client IdentityClient) UpdateDynamicGroup(ctx context.Context, request UpdateDynamicGroupRequest) (response UpdateDynamicGroupResponse, err error) { 5336 var ociResponse common.OCIResponse 5337 policy := common.NoRetryPolicy() 5338 if request.RetryPolicy() != nil { 5339 policy = *request.RetryPolicy() 5340 } 5341 ociResponse, err = common.Retry(ctx, request, client.updateDynamicGroup, policy) 5342 if err != nil { 5343 if ociResponse != nil { 5344 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5345 opcRequestId := httpResponse.Header.Get("opc-request-id") 5346 response = UpdateDynamicGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5347 } else { 5348 response = UpdateDynamicGroupResponse{} 5349 } 5350 } 5351 return 5352 } 5353 if convertedResponse, ok := ociResponse.(UpdateDynamicGroupResponse); ok { 5354 response = convertedResponse 5355 } else { 5356 err = fmt.Errorf("failed to convert OCIResponse into UpdateDynamicGroupResponse") 5357 } 5358 return 5359} 5360 5361// updateDynamicGroup implements the OCIOperation interface (enables retrying operations) 5362func (client IdentityClient) updateDynamicGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5363 httpRequest, err := request.HTTPRequest(http.MethodPut, "/dynamicGroups/{dynamicGroupId}") 5364 if err != nil { 5365 return nil, err 5366 } 5367 5368 var response UpdateDynamicGroupResponse 5369 var httpResponse *http.Response 5370 httpResponse, err = client.Call(ctx, &httpRequest) 5371 defer common.CloseBodyIfValid(httpResponse) 5372 response.RawResponse = httpResponse 5373 if err != nil { 5374 return response, err 5375 } 5376 5377 err = common.UnmarshalResponse(httpResponse, &response) 5378 return response, err 5379} 5380 5381// UpdateGroup Updates the specified group. 5382func (client IdentityClient) UpdateGroup(ctx context.Context, request UpdateGroupRequest) (response UpdateGroupResponse, err error) { 5383 var ociResponse common.OCIResponse 5384 policy := common.NoRetryPolicy() 5385 if request.RetryPolicy() != nil { 5386 policy = *request.RetryPolicy() 5387 } 5388 ociResponse, err = common.Retry(ctx, request, client.updateGroup, policy) 5389 if err != nil { 5390 if ociResponse != nil { 5391 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5392 opcRequestId := httpResponse.Header.Get("opc-request-id") 5393 response = UpdateGroupResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5394 } else { 5395 response = UpdateGroupResponse{} 5396 } 5397 } 5398 return 5399 } 5400 if convertedResponse, ok := ociResponse.(UpdateGroupResponse); ok { 5401 response = convertedResponse 5402 } else { 5403 err = fmt.Errorf("failed to convert OCIResponse into UpdateGroupResponse") 5404 } 5405 return 5406} 5407 5408// updateGroup implements the OCIOperation interface (enables retrying operations) 5409func (client IdentityClient) updateGroup(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5410 httpRequest, err := request.HTTPRequest(http.MethodPut, "/groups/{groupId}") 5411 if err != nil { 5412 return nil, err 5413 } 5414 5415 var response UpdateGroupResponse 5416 var httpResponse *http.Response 5417 httpResponse, err = client.Call(ctx, &httpRequest) 5418 defer common.CloseBodyIfValid(httpResponse) 5419 response.RawResponse = httpResponse 5420 if err != nil { 5421 return response, err 5422 } 5423 5424 err = common.UnmarshalResponse(httpResponse, &response) 5425 return response, err 5426} 5427 5428// UpdateIdentityProvider Updates the specified identity provider. 5429func (client IdentityClient) UpdateIdentityProvider(ctx context.Context, request UpdateIdentityProviderRequest) (response UpdateIdentityProviderResponse, err error) { 5430 var ociResponse common.OCIResponse 5431 policy := common.NoRetryPolicy() 5432 if request.RetryPolicy() != nil { 5433 policy = *request.RetryPolicy() 5434 } 5435 ociResponse, err = common.Retry(ctx, request, client.updateIdentityProvider, policy) 5436 if err != nil { 5437 if ociResponse != nil { 5438 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5439 opcRequestId := httpResponse.Header.Get("opc-request-id") 5440 response = UpdateIdentityProviderResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5441 } else { 5442 response = UpdateIdentityProviderResponse{} 5443 } 5444 } 5445 return 5446 } 5447 if convertedResponse, ok := ociResponse.(UpdateIdentityProviderResponse); ok { 5448 response = convertedResponse 5449 } else { 5450 err = fmt.Errorf("failed to convert OCIResponse into UpdateIdentityProviderResponse") 5451 } 5452 return 5453} 5454 5455// updateIdentityProvider implements the OCIOperation interface (enables retrying operations) 5456func (client IdentityClient) updateIdentityProvider(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5457 httpRequest, err := request.HTTPRequest(http.MethodPut, "/identityProviders/{identityProviderId}") 5458 if err != nil { 5459 return nil, err 5460 } 5461 5462 var response UpdateIdentityProviderResponse 5463 var httpResponse *http.Response 5464 httpResponse, err = client.Call(ctx, &httpRequest) 5465 defer common.CloseBodyIfValid(httpResponse) 5466 response.RawResponse = httpResponse 5467 if err != nil { 5468 return response, err 5469 } 5470 5471 err = common.UnmarshalResponseWithPolymorphicBody(httpResponse, &response, &identityprovider{}) 5472 return response, err 5473} 5474 5475// UpdateIdpGroupMapping Updates the specified group mapping. 5476func (client IdentityClient) UpdateIdpGroupMapping(ctx context.Context, request UpdateIdpGroupMappingRequest) (response UpdateIdpGroupMappingResponse, err error) { 5477 var ociResponse common.OCIResponse 5478 policy := common.NoRetryPolicy() 5479 if request.RetryPolicy() != nil { 5480 policy = *request.RetryPolicy() 5481 } 5482 ociResponse, err = common.Retry(ctx, request, client.updateIdpGroupMapping, policy) 5483 if err != nil { 5484 if ociResponse != nil { 5485 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5486 opcRequestId := httpResponse.Header.Get("opc-request-id") 5487 response = UpdateIdpGroupMappingResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5488 } else { 5489 response = UpdateIdpGroupMappingResponse{} 5490 } 5491 } 5492 return 5493 } 5494 if convertedResponse, ok := ociResponse.(UpdateIdpGroupMappingResponse); ok { 5495 response = convertedResponse 5496 } else { 5497 err = fmt.Errorf("failed to convert OCIResponse into UpdateIdpGroupMappingResponse") 5498 } 5499 return 5500} 5501 5502// updateIdpGroupMapping implements the OCIOperation interface (enables retrying operations) 5503func (client IdentityClient) updateIdpGroupMapping(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5504 httpRequest, err := request.HTTPRequest(http.MethodPut, "/identityProviders/{identityProviderId}/groupMappings/{mappingId}") 5505 if err != nil { 5506 return nil, err 5507 } 5508 5509 var response UpdateIdpGroupMappingResponse 5510 var httpResponse *http.Response 5511 httpResponse, err = client.Call(ctx, &httpRequest) 5512 defer common.CloseBodyIfValid(httpResponse) 5513 response.RawResponse = httpResponse 5514 if err != nil { 5515 return response, err 5516 } 5517 5518 err = common.UnmarshalResponse(httpResponse, &response) 5519 return response, err 5520} 5521 5522// UpdateNetworkSource Updates the specified network source. 5523func (client IdentityClient) UpdateNetworkSource(ctx context.Context, request UpdateNetworkSourceRequest) (response UpdateNetworkSourceResponse, err error) { 5524 var ociResponse common.OCIResponse 5525 policy := common.NoRetryPolicy() 5526 if request.RetryPolicy() != nil { 5527 policy = *request.RetryPolicy() 5528 } 5529 ociResponse, err = common.Retry(ctx, request, client.updateNetworkSource, policy) 5530 if err != nil { 5531 if ociResponse != nil { 5532 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5533 opcRequestId := httpResponse.Header.Get("opc-request-id") 5534 response = UpdateNetworkSourceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5535 } else { 5536 response = UpdateNetworkSourceResponse{} 5537 } 5538 } 5539 return 5540 } 5541 if convertedResponse, ok := ociResponse.(UpdateNetworkSourceResponse); ok { 5542 response = convertedResponse 5543 } else { 5544 err = fmt.Errorf("failed to convert OCIResponse into UpdateNetworkSourceResponse") 5545 } 5546 return 5547} 5548 5549// updateNetworkSource implements the OCIOperation interface (enables retrying operations) 5550func (client IdentityClient) updateNetworkSource(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5551 httpRequest, err := request.HTTPRequest(http.MethodPut, "/networkSources/{networkSourceId}") 5552 if err != nil { 5553 return nil, err 5554 } 5555 5556 var response UpdateNetworkSourceResponse 5557 var httpResponse *http.Response 5558 httpResponse, err = client.Call(ctx, &httpRequest) 5559 defer common.CloseBodyIfValid(httpResponse) 5560 response.RawResponse = httpResponse 5561 if err != nil { 5562 return response, err 5563 } 5564 5565 err = common.UnmarshalResponse(httpResponse, &response) 5566 return response, err 5567} 5568 5569// UpdateOAuthClientCredential Updates Oauth token for the user 5570func (client IdentityClient) UpdateOAuthClientCredential(ctx context.Context, request UpdateOAuthClientCredentialRequest) (response UpdateOAuthClientCredentialResponse, err error) { 5571 var ociResponse common.OCIResponse 5572 policy := common.NoRetryPolicy() 5573 if request.RetryPolicy() != nil { 5574 policy = *request.RetryPolicy() 5575 } 5576 ociResponse, err = common.Retry(ctx, request, client.updateOAuthClientCredential, policy) 5577 if err != nil { 5578 if ociResponse != nil { 5579 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5580 opcRequestId := httpResponse.Header.Get("opc-request-id") 5581 response = UpdateOAuthClientCredentialResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5582 } else { 5583 response = UpdateOAuthClientCredentialResponse{} 5584 } 5585 } 5586 return 5587 } 5588 if convertedResponse, ok := ociResponse.(UpdateOAuthClientCredentialResponse); ok { 5589 response = convertedResponse 5590 } else { 5591 err = fmt.Errorf("failed to convert OCIResponse into UpdateOAuthClientCredentialResponse") 5592 } 5593 return 5594} 5595 5596// updateOAuthClientCredential implements the OCIOperation interface (enables retrying operations) 5597func (client IdentityClient) updateOAuthClientCredential(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5598 httpRequest, err := request.HTTPRequest(http.MethodPut, "/users/{userId}/oauth2ClientCredentials/{oauth2ClientCredentialId}") 5599 if err != nil { 5600 return nil, err 5601 } 5602 5603 var response UpdateOAuthClientCredentialResponse 5604 var httpResponse *http.Response 5605 httpResponse, err = client.Call(ctx, &httpRequest) 5606 defer common.CloseBodyIfValid(httpResponse) 5607 response.RawResponse = httpResponse 5608 if err != nil { 5609 return response, err 5610 } 5611 5612 err = common.UnmarshalResponse(httpResponse, &response) 5613 return response, err 5614} 5615 5616// UpdatePolicy Updates the specified policy. You can update the description or the policy statements themselves. 5617// Policy changes take effect typically within 10 seconds. 5618func (client IdentityClient) UpdatePolicy(ctx context.Context, request UpdatePolicyRequest) (response UpdatePolicyResponse, err error) { 5619 var ociResponse common.OCIResponse 5620 policy := common.NoRetryPolicy() 5621 if request.RetryPolicy() != nil { 5622 policy = *request.RetryPolicy() 5623 } 5624 ociResponse, err = common.Retry(ctx, request, client.updatePolicy, policy) 5625 if err != nil { 5626 if ociResponse != nil { 5627 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5628 opcRequestId := httpResponse.Header.Get("opc-request-id") 5629 response = UpdatePolicyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5630 } else { 5631 response = UpdatePolicyResponse{} 5632 } 5633 } 5634 return 5635 } 5636 if convertedResponse, ok := ociResponse.(UpdatePolicyResponse); ok { 5637 response = convertedResponse 5638 } else { 5639 err = fmt.Errorf("failed to convert OCIResponse into UpdatePolicyResponse") 5640 } 5641 return 5642} 5643 5644// updatePolicy implements the OCIOperation interface (enables retrying operations) 5645func (client IdentityClient) updatePolicy(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5646 httpRequest, err := request.HTTPRequest(http.MethodPut, "/policies/{policyId}") 5647 if err != nil { 5648 return nil, err 5649 } 5650 5651 var response UpdatePolicyResponse 5652 var httpResponse *http.Response 5653 httpResponse, err = client.Call(ctx, &httpRequest) 5654 defer common.CloseBodyIfValid(httpResponse) 5655 response.RawResponse = httpResponse 5656 if err != nil { 5657 return response, err 5658 } 5659 5660 err = common.UnmarshalResponse(httpResponse, &response) 5661 return response, err 5662} 5663 5664// UpdateSmtpCredential Updates the specified SMTP credential's description. 5665func (client IdentityClient) UpdateSmtpCredential(ctx context.Context, request UpdateSmtpCredentialRequest) (response UpdateSmtpCredentialResponse, err error) { 5666 var ociResponse common.OCIResponse 5667 policy := common.NoRetryPolicy() 5668 if request.RetryPolicy() != nil { 5669 policy = *request.RetryPolicy() 5670 } 5671 ociResponse, err = common.Retry(ctx, request, client.updateSmtpCredential, policy) 5672 if err != nil { 5673 if ociResponse != nil { 5674 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5675 opcRequestId := httpResponse.Header.Get("opc-request-id") 5676 response = UpdateSmtpCredentialResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5677 } else { 5678 response = UpdateSmtpCredentialResponse{} 5679 } 5680 } 5681 return 5682 } 5683 if convertedResponse, ok := ociResponse.(UpdateSmtpCredentialResponse); ok { 5684 response = convertedResponse 5685 } else { 5686 err = fmt.Errorf("failed to convert OCIResponse into UpdateSmtpCredentialResponse") 5687 } 5688 return 5689} 5690 5691// updateSmtpCredential implements the OCIOperation interface (enables retrying operations) 5692func (client IdentityClient) updateSmtpCredential(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5693 httpRequest, err := request.HTTPRequest(http.MethodPut, "/users/{userId}/smtpCredentials/{smtpCredentialId}") 5694 if err != nil { 5695 return nil, err 5696 } 5697 5698 var response UpdateSmtpCredentialResponse 5699 var httpResponse *http.Response 5700 httpResponse, err = client.Call(ctx, &httpRequest) 5701 defer common.CloseBodyIfValid(httpResponse) 5702 response.RawResponse = httpResponse 5703 if err != nil { 5704 return response, err 5705 } 5706 5707 err = common.UnmarshalResponse(httpResponse, &response) 5708 return response, err 5709} 5710 5711// UpdateSwiftPassword **Deprecated. Use UpdateAuthToken instead.** 5712// Updates the specified Swift password's description. 5713func (client IdentityClient) UpdateSwiftPassword(ctx context.Context, request UpdateSwiftPasswordRequest) (response UpdateSwiftPasswordResponse, err error) { 5714 var ociResponse common.OCIResponse 5715 policy := common.NoRetryPolicy() 5716 if request.RetryPolicy() != nil { 5717 policy = *request.RetryPolicy() 5718 } 5719 ociResponse, err = common.Retry(ctx, request, client.updateSwiftPassword, policy) 5720 if err != nil { 5721 if ociResponse != nil { 5722 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5723 opcRequestId := httpResponse.Header.Get("opc-request-id") 5724 response = UpdateSwiftPasswordResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5725 } else { 5726 response = UpdateSwiftPasswordResponse{} 5727 } 5728 } 5729 return 5730 } 5731 if convertedResponse, ok := ociResponse.(UpdateSwiftPasswordResponse); ok { 5732 response = convertedResponse 5733 } else { 5734 err = fmt.Errorf("failed to convert OCIResponse into UpdateSwiftPasswordResponse") 5735 } 5736 return 5737} 5738 5739// updateSwiftPassword implements the OCIOperation interface (enables retrying operations) 5740func (client IdentityClient) updateSwiftPassword(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5741 httpRequest, err := request.HTTPRequest(http.MethodPut, "/users/{userId}/swiftPasswords/{swiftPasswordId}") 5742 if err != nil { 5743 return nil, err 5744 } 5745 5746 var response UpdateSwiftPasswordResponse 5747 var httpResponse *http.Response 5748 httpResponse, err = client.Call(ctx, &httpRequest) 5749 defer common.CloseBodyIfValid(httpResponse) 5750 response.RawResponse = httpResponse 5751 if err != nil { 5752 return response, err 5753 } 5754 5755 err = common.UnmarshalResponse(httpResponse, &response) 5756 return response, err 5757} 5758 5759// UpdateTag Updates the specified tag definition. 5760// Setting `validator` determines the value type. Tags can use either a static value or a 5761// list of possible values. Static values are entered by a user applying the tag to a resource. 5762// Lists are created by you and the user must apply a value from the list. On update, any values 5763// in a list that were previously set do not change, but new values must pass validation. Values 5764// already applied to a resource do not change. 5765// You cannot remove list values that appear in a TagDefault. To remove a list value that 5766// appears in a TagDefault, first update the TagDefault to use a different value. 5767func (client IdentityClient) UpdateTag(ctx context.Context, request UpdateTagRequest) (response UpdateTagResponse, err error) { 5768 var ociResponse common.OCIResponse 5769 policy := common.NoRetryPolicy() 5770 if request.RetryPolicy() != nil { 5771 policy = *request.RetryPolicy() 5772 } 5773 ociResponse, err = common.Retry(ctx, request, client.updateTag, policy) 5774 if err != nil { 5775 if ociResponse != nil { 5776 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5777 opcRequestId := httpResponse.Header.Get("opc-request-id") 5778 response = UpdateTagResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5779 } else { 5780 response = UpdateTagResponse{} 5781 } 5782 } 5783 return 5784 } 5785 if convertedResponse, ok := ociResponse.(UpdateTagResponse); ok { 5786 response = convertedResponse 5787 } else { 5788 err = fmt.Errorf("failed to convert OCIResponse into UpdateTagResponse") 5789 } 5790 return 5791} 5792 5793// updateTag implements the OCIOperation interface (enables retrying operations) 5794func (client IdentityClient) updateTag(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5795 httpRequest, err := request.HTTPRequest(http.MethodPut, "/tagNamespaces/{tagNamespaceId}/tags/{tagName}") 5796 if err != nil { 5797 return nil, err 5798 } 5799 5800 var response UpdateTagResponse 5801 var httpResponse *http.Response 5802 httpResponse, err = client.Call(ctx, &httpRequest) 5803 defer common.CloseBodyIfValid(httpResponse) 5804 response.RawResponse = httpResponse 5805 if err != nil { 5806 return response, err 5807 } 5808 5809 err = common.UnmarshalResponse(httpResponse, &response) 5810 return response, err 5811} 5812 5813// UpdateTagDefault Updates the specified tag default. If you specify that a value is required, a value is set 5814// during resource creation (either by the user creating the resource or another tag defualt). 5815// If no value is set, resource creation is blocked. 5816// * If the `isRequired` flag is set to "true", the value is set during resource creation. 5817// * If the `isRequired` flag is set to "false", the value you enter is set during resource creation. 5818func (client IdentityClient) UpdateTagDefault(ctx context.Context, request UpdateTagDefaultRequest) (response UpdateTagDefaultResponse, err error) { 5819 var ociResponse common.OCIResponse 5820 policy := common.NoRetryPolicy() 5821 if request.RetryPolicy() != nil { 5822 policy = *request.RetryPolicy() 5823 } 5824 ociResponse, err = common.Retry(ctx, request, client.updateTagDefault, policy) 5825 if err != nil { 5826 if ociResponse != nil { 5827 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5828 opcRequestId := httpResponse.Header.Get("opc-request-id") 5829 response = UpdateTagDefaultResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5830 } else { 5831 response = UpdateTagDefaultResponse{} 5832 } 5833 } 5834 return 5835 } 5836 if convertedResponse, ok := ociResponse.(UpdateTagDefaultResponse); ok { 5837 response = convertedResponse 5838 } else { 5839 err = fmt.Errorf("failed to convert OCIResponse into UpdateTagDefaultResponse") 5840 } 5841 return 5842} 5843 5844// updateTagDefault implements the OCIOperation interface (enables retrying operations) 5845func (client IdentityClient) updateTagDefault(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5846 httpRequest, err := request.HTTPRequest(http.MethodPut, "/tagDefaults/{tagDefaultId}") 5847 if err != nil { 5848 return nil, err 5849 } 5850 5851 var response UpdateTagDefaultResponse 5852 var httpResponse *http.Response 5853 httpResponse, err = client.Call(ctx, &httpRequest) 5854 defer common.CloseBodyIfValid(httpResponse) 5855 response.RawResponse = httpResponse 5856 if err != nil { 5857 return response, err 5858 } 5859 5860 err = common.UnmarshalResponse(httpResponse, &response) 5861 return response, err 5862} 5863 5864// UpdateTagNamespace Updates the the specified tag namespace. You can't update the namespace name. 5865// Updating `isRetired` to 'true' retires the namespace and all the tag definitions in the namespace. Reactivating a 5866// namespace (changing `isRetired` from 'true' to 'false') does not reactivate tag definitions. 5867// To reactivate the tag definitions, you must reactivate each one individually *after* you reactivate the namespace, 5868// using UpdateTag. For more information about retiring tag namespaces, see 5869// Retiring Key Definitions and Namespace Definitions (https://docs.cloud.oracle.com/Content/Identity/Concepts/taggingoverview.htm#Retiring). 5870// You can't add a namespace with the same name as a retired namespace in the same tenancy. 5871func (client IdentityClient) UpdateTagNamespace(ctx context.Context, request UpdateTagNamespaceRequest) (response UpdateTagNamespaceResponse, err error) { 5872 var ociResponse common.OCIResponse 5873 policy := common.NoRetryPolicy() 5874 if request.RetryPolicy() != nil { 5875 policy = *request.RetryPolicy() 5876 } 5877 ociResponse, err = common.Retry(ctx, request, client.updateTagNamespace, policy) 5878 if err != nil { 5879 if ociResponse != nil { 5880 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5881 opcRequestId := httpResponse.Header.Get("opc-request-id") 5882 response = UpdateTagNamespaceResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5883 } else { 5884 response = UpdateTagNamespaceResponse{} 5885 } 5886 } 5887 return 5888 } 5889 if convertedResponse, ok := ociResponse.(UpdateTagNamespaceResponse); ok { 5890 response = convertedResponse 5891 } else { 5892 err = fmt.Errorf("failed to convert OCIResponse into UpdateTagNamespaceResponse") 5893 } 5894 return 5895} 5896 5897// updateTagNamespace implements the OCIOperation interface (enables retrying operations) 5898func (client IdentityClient) updateTagNamespace(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5899 httpRequest, err := request.HTTPRequest(http.MethodPut, "/tagNamespaces/{tagNamespaceId}") 5900 if err != nil { 5901 return nil, err 5902 } 5903 5904 var response UpdateTagNamespaceResponse 5905 var httpResponse *http.Response 5906 httpResponse, err = client.Call(ctx, &httpRequest) 5907 defer common.CloseBodyIfValid(httpResponse) 5908 response.RawResponse = httpResponse 5909 if err != nil { 5910 return response, err 5911 } 5912 5913 err = common.UnmarshalResponse(httpResponse, &response) 5914 return response, err 5915} 5916 5917// UpdateUser Updates the description of the specified user. 5918func (client IdentityClient) UpdateUser(ctx context.Context, request UpdateUserRequest) (response UpdateUserResponse, err error) { 5919 var ociResponse common.OCIResponse 5920 policy := common.NoRetryPolicy() 5921 if request.RetryPolicy() != nil { 5922 policy = *request.RetryPolicy() 5923 } 5924 ociResponse, err = common.Retry(ctx, request, client.updateUser, policy) 5925 if err != nil { 5926 if ociResponse != nil { 5927 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5928 opcRequestId := httpResponse.Header.Get("opc-request-id") 5929 response = UpdateUserResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5930 } else { 5931 response = UpdateUserResponse{} 5932 } 5933 } 5934 return 5935 } 5936 if convertedResponse, ok := ociResponse.(UpdateUserResponse); ok { 5937 response = convertedResponse 5938 } else { 5939 err = fmt.Errorf("failed to convert OCIResponse into UpdateUserResponse") 5940 } 5941 return 5942} 5943 5944// updateUser implements the OCIOperation interface (enables retrying operations) 5945func (client IdentityClient) updateUser(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5946 httpRequest, err := request.HTTPRequest(http.MethodPut, "/users/{userId}") 5947 if err != nil { 5948 return nil, err 5949 } 5950 5951 var response UpdateUserResponse 5952 var httpResponse *http.Response 5953 httpResponse, err = client.Call(ctx, &httpRequest) 5954 defer common.CloseBodyIfValid(httpResponse) 5955 response.RawResponse = httpResponse 5956 if err != nil { 5957 return response, err 5958 } 5959 5960 err = common.UnmarshalResponse(httpResponse, &response) 5961 return response, err 5962} 5963 5964// UpdateUserCapabilities Updates the capabilities of the specified user. 5965func (client IdentityClient) UpdateUserCapabilities(ctx context.Context, request UpdateUserCapabilitiesRequest) (response UpdateUserCapabilitiesResponse, err error) { 5966 var ociResponse common.OCIResponse 5967 policy := common.NoRetryPolicy() 5968 if request.RetryPolicy() != nil { 5969 policy = *request.RetryPolicy() 5970 } 5971 ociResponse, err = common.Retry(ctx, request, client.updateUserCapabilities, policy) 5972 if err != nil { 5973 if ociResponse != nil { 5974 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 5975 opcRequestId := httpResponse.Header.Get("opc-request-id") 5976 response = UpdateUserCapabilitiesResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 5977 } else { 5978 response = UpdateUserCapabilitiesResponse{} 5979 } 5980 } 5981 return 5982 } 5983 if convertedResponse, ok := ociResponse.(UpdateUserCapabilitiesResponse); ok { 5984 response = convertedResponse 5985 } else { 5986 err = fmt.Errorf("failed to convert OCIResponse into UpdateUserCapabilitiesResponse") 5987 } 5988 return 5989} 5990 5991// updateUserCapabilities implements the OCIOperation interface (enables retrying operations) 5992func (client IdentityClient) updateUserCapabilities(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 5993 httpRequest, err := request.HTTPRequest(http.MethodPut, "/users/{userId}/capabilities") 5994 if err != nil { 5995 return nil, err 5996 } 5997 5998 var response UpdateUserCapabilitiesResponse 5999 var httpResponse *http.Response 6000 httpResponse, err = client.Call(ctx, &httpRequest) 6001 defer common.CloseBodyIfValid(httpResponse) 6002 response.RawResponse = httpResponse 6003 if err != nil { 6004 return response, err 6005 } 6006 6007 err = common.UnmarshalResponse(httpResponse, &response) 6008 return response, err 6009} 6010 6011// UpdateUserState Updates the state of the specified user. 6012func (client IdentityClient) UpdateUserState(ctx context.Context, request UpdateUserStateRequest) (response UpdateUserStateResponse, err error) { 6013 var ociResponse common.OCIResponse 6014 policy := common.NoRetryPolicy() 6015 if request.RetryPolicy() != nil { 6016 policy = *request.RetryPolicy() 6017 } 6018 ociResponse, err = common.Retry(ctx, request, client.updateUserState, policy) 6019 if err != nil { 6020 if ociResponse != nil { 6021 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 6022 opcRequestId := httpResponse.Header.Get("opc-request-id") 6023 response = UpdateUserStateResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 6024 } else { 6025 response = UpdateUserStateResponse{} 6026 } 6027 } 6028 return 6029 } 6030 if convertedResponse, ok := ociResponse.(UpdateUserStateResponse); ok { 6031 response = convertedResponse 6032 } else { 6033 err = fmt.Errorf("failed to convert OCIResponse into UpdateUserStateResponse") 6034 } 6035 return 6036} 6037 6038// updateUserState implements the OCIOperation interface (enables retrying operations) 6039func (client IdentityClient) updateUserState(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6040 httpRequest, err := request.HTTPRequest(http.MethodPut, "/users/{userId}/state") 6041 if err != nil { 6042 return nil, err 6043 } 6044 6045 var response UpdateUserStateResponse 6046 var httpResponse *http.Response 6047 httpResponse, err = client.Call(ctx, &httpRequest) 6048 defer common.CloseBodyIfValid(httpResponse) 6049 response.RawResponse = httpResponse 6050 if err != nil { 6051 return response, err 6052 } 6053 6054 err = common.UnmarshalResponse(httpResponse, &response) 6055 return response, err 6056} 6057 6058// UploadApiKey Uploads an API signing key for the specified user. 6059// Every user has permission to use this operation to upload a key for *their own user ID*. An 6060// administrator in your organization does not need to write a policy to give users this ability. 6061// To compare, administrators who have permission to the tenancy can use this operation to upload a 6062// key for any user, including themselves. 6063// **Important:** Even though you have permission to upload an API key, you might not yet 6064// have permission to do much else. If you try calling an operation unrelated to your own credential 6065// management (e.g., `ListUsers`, `LaunchInstance`) and receive an "unauthorized" error, 6066// check with an administrator to confirm which IAM Service group(s) you're in and what access 6067// you have. Also confirm you're working in the correct compartment. 6068// After you send your request, the new object's `lifecycleState` will temporarily be CREATING. Before using 6069// the object, first make sure its `lifecycleState` has changed to ACTIVE. 6070func (client IdentityClient) UploadApiKey(ctx context.Context, request UploadApiKeyRequest) (response UploadApiKeyResponse, err error) { 6071 var ociResponse common.OCIResponse 6072 policy := common.NoRetryPolicy() 6073 if request.RetryPolicy() != nil { 6074 policy = *request.RetryPolicy() 6075 } 6076 6077 if !(request.OpcRetryToken != nil && *request.OpcRetryToken != "") { 6078 request.OpcRetryToken = common.String(common.RetryToken()) 6079 } 6080 6081 ociResponse, err = common.Retry(ctx, request, client.uploadApiKey, policy) 6082 if err != nil { 6083 if ociResponse != nil { 6084 if httpResponse := ociResponse.HTTPResponse(); httpResponse != nil { 6085 opcRequestId := httpResponse.Header.Get("opc-request-id") 6086 response = UploadApiKeyResponse{RawResponse: httpResponse, OpcRequestId: &opcRequestId} 6087 } else { 6088 response = UploadApiKeyResponse{} 6089 } 6090 } 6091 return 6092 } 6093 if convertedResponse, ok := ociResponse.(UploadApiKeyResponse); ok { 6094 response = convertedResponse 6095 } else { 6096 err = fmt.Errorf("failed to convert OCIResponse into UploadApiKeyResponse") 6097 } 6098 return 6099} 6100 6101// uploadApiKey implements the OCIOperation interface (enables retrying operations) 6102func (client IdentityClient) uploadApiKey(ctx context.Context, request common.OCIRequest) (common.OCIResponse, error) { 6103 httpRequest, err := request.HTTPRequest(http.MethodPost, "/users/{userId}/apiKeys") 6104 if err != nil { 6105 return nil, err 6106 } 6107 6108 var response UploadApiKeyResponse 6109 var httpResponse *http.Response 6110 httpResponse, err = client.Call(ctx, &httpRequest) 6111 defer common.CloseBodyIfValid(httpResponse) 6112 response.RawResponse = httpResponse 6113 if err != nil { 6114 return response, err 6115 } 6116 6117 err = common.UnmarshalResponse(httpResponse, &response) 6118 return response, err 6119} 6120