From 728440e1a570e59a06f15da8684da95065c048fc Mon Sep 17 00:00:00 2001 From: Patrick Cowland Date: Tue, 8 Oct 2024 18:39:24 +0100 Subject: [PATCH 1/8] begin draft for `authorize` service Terraform export --- internal/connector/common/resources_common.go | 31 ++++++ .../authorize/pingone_authorize_connector.go | 73 ++++++++++++++ .../pingone_authorize_connector_test.go | 94 +++++++++++++++++++ .../pingone_authorize_api_service.go | 70 ++++++++++++++ .../pingone_authorize_api_service_test.go | 27 ++++++ 5 files changed, 295 insertions(+) create mode 100644 internal/connector/pingone/authorize/pingone_authorize_connector.go create mode 100644 internal/connector/pingone/authorize/pingone_authorize_connector_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_api_service_test.go diff --git a/internal/connector/common/resources_common.go b/internal/connector/common/resources_common.go index c3c1c9e3..e67f6582 100644 --- a/internal/connector/common/resources_common.go +++ b/internal/connector/common/resources_common.go @@ -4,6 +4,7 @@ import ( "fmt" "net/http" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/patrickcping/pingone-go-sdk-v2/management" "github.com/patrickcping/pingone-go-sdk-v2/mfa" "github.com/patrickcping/pingone-go-sdk-v2/risk" @@ -32,6 +33,36 @@ func HandleClientResponse(response *http.Response, err error, apiFunctionName st return nil } +// Executes the function apiExecuteFunc for the AuthorizeAPIClient +// Handles err and response if Client call failed +// Returns embedded data if not nil +// Treats nil embedded data as an error +func GetAuthorizeEmbedded(apiExecuteFunc func() (*authorize.EntityArray, *http.Response, error), apiFunctionName string, resourceType string) (*authorize.EntityArrayEmbedded, error) { + l := logger.Get() + + entityArray, response, err := apiExecuteFunc() + + err = HandleClientResponse(response, err, apiFunctionName, resourceType) + if err != nil { + return nil, err + } + + if entityArray == nil { + l.Error().Msgf("Returned %s() entityArray is nil.", apiFunctionName) + l.Error().Msgf("%s Response Code: %s\nResponse Body: %s", apiFunctionName, response.Status, response.Body) + return nil, fmt.Errorf("failed to fetch %s resources via %s()", resourceType, apiFunctionName) + } + + embedded, embeddedOk := entityArray.GetEmbeddedOk() + if !embeddedOk { + l.Error().Msgf("Returned %s() embedded data is nil.", apiFunctionName) + l.Error().Msgf("%s Response Code: %s\nResponse Body: %s", apiFunctionName, response.Status, response.Body) + return nil, fmt.Errorf("failed to fetch %s resources via %s()", resourceType, apiFunctionName) + } + + return embedded, nil +} + // Executes the function apiExecuteFunc for the ManagementAPIClient // Handles err and response if Client call failed // Returns embedded data if not nil diff --git a/internal/connector/pingone/authorize/pingone_authorize_connector.go b/internal/connector/pingone/authorize/pingone_authorize_connector.go new file mode 100644 index 00000000..e4829bf2 --- /dev/null +++ b/internal/connector/pingone/authorize/pingone_authorize_connector.go @@ -0,0 +1,73 @@ +package authorize + +import ( + "context" + + pingoneGoClient "github.com/patrickcping/pingone-go-sdk-v2/pingone" + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/logger" +) + +const ( + serviceName = "pingone-authorize" +) + +// Verify that the connector satisfies the expected interfaces +var ( + _ connector.Exportable = &PingoneAuthorizeConnector{} + _ connector.Authenticatable = &PingoneAuthorizeConnector{} +) + +type PingoneAuthorizeConnector struct { + clientInfo connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeConnector +func AuthorizeConnector(ctx context.Context, apiClient *pingoneGoClient.Client, apiClientId *string, exportEnvironmentID string) *PingoneAuthorizeConnector { + return &PingoneAuthorizeConnector{ + clientInfo: connector.PingOneClientInfo{ + Context: ctx, + ApiClient: apiClient, + ApiClientId: apiClientId, + ExportEnvironmentID: exportEnvironmentID, + }, + } +} + +func (c *PingoneAuthorizeConnector) Export(format, outputDir string, overwriteExport bool) error { + l := logger.Get() + + l.Debug().Msgf("Exporting all PingOne Authorize Resources...") + + exportableResources := []connector.ExportableResource{ + resources.AuthorizeAPIService(&c.clientInfo), + resources.AuthorizeAPIServiceDeployment(&c.clientInfo), + resources.AuthorizeAPIServiceOperation(&c.clientInfo), + resources.AuthorizeApplicationRole(&c.clientInfo), + resources.AuthorizeApplicationRolePermission(&c.clientInfo), + resources.AuthorizeDecisionEndpoint(&c.clientInfo), + resources.AuthorizePolicyManagementPolicy(&c.clientInfo), + resources.AuthorizePolicyManagementRule(&c.clientInfo), + resources.AuthorizePolicyManagementStatement(&c.clientInfo), + resources.AuthorizeTrustFrameworkAttribute(&c.clientInfo), + resources.AuthorizeTrustFrameworkCondition(&c.clientInfo), + resources.AuthorizeTrustFrameworkProcessor(&c.clientInfo), + resources.AuthorizeTrustFrameworkService(&c.clientInfo), + } + + return common.WriteFiles(exportableResources, format, outputDir, overwriteExport) +} + +func (c *PingoneAuthorizeConnector) ConnectorServiceName() string { + return serviceName +} + +func (c *PingoneAuthorizeConnector) Login() error { + return nil +} + +func (c *PingoneAuthorizeConnector) Logout() error { + return nil +} diff --git a/internal/connector/pingone/authorize/pingone_authorize_connector_test.go b/internal/connector/pingone/authorize/pingone_authorize_connector_test.go new file mode 100644 index 00000000..922ed50e --- /dev/null +++ b/internal/connector/pingone/authorize/pingone_authorize_connector_test.go @@ -0,0 +1,94 @@ +package authorize_test + +import ( + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingctl/internal/testing/testutils_terraform" +) + +func TestAuthorizeTerraformPlan(t *testing.T) { + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + + testutils_terraform.InitPingOneTerraform(t) + + testCases := []struct { + name string + resource connector.ExportableResource + ignoredErrors []string + }{ + { + name: "AuthorizeAPIService", + resource: resources.AuthorizeAPIService(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizeAPIServiceDeployment", + resource: resources.AuthorizeAPIServiceDeployment(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizeAPIServiceOperation", + resource: resources.AuthorizeAPIServiceOperation(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizeApplicationRole", + resource: resources.AuthorizeApplicationRole(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizeApplicationRolePermission", + resource: resources.AuthorizeApplicationRolePermission(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizeDecisionEndpoint", + resource: resources.AuthorizeDecisionEndpoint(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizePolicyManagementPolicy", + resource: resources.AuthorizePolicyManagementPolicy(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizePolicyManagementRule", + resource: resources.AuthorizePolicyManagementRule(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizePolicyManagementStatement", + resource: resources.AuthorizePolicyManagementStatement(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizeTrustFrameworkAttribute", + resource: resources.AuthorizeTrustFrameworkAttribute(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizeTrustFrameworkCondition", + resource: resources.AuthorizeTrustFrameworkCondition(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizeTrustFrameworkProcessor", + resource: resources.AuthorizeTrustFrameworkProcessor(PingOneClientInfo), + ignoredErrors: nil, + }, + { + name: "AuthorizeTrustFrameworkService", + resource: resources.AuthorizeTrustFrameworkService(PingOneClientInfo), + ignoredErrors: nil, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + testutils_terraform.ValidateTerraformPlan(t, tc.resource, tc.ignoredErrors) + }) + } +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go new file mode 100644 index 00000000..725da4e3 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go @@ -0,0 +1,70 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeAPIServiceResource{} +) + +type PingoneAuthorizeAPIServiceResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeAPIServiceResource +func AuthorizeAPIService(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeAPIServiceResource { + return &PingoneAuthorizeAPIServiceResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeAPIServiceResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServersApi.ReadAllAPIServers(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ReadAllAPIServers" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, apiServer := range embedded.GetApiServers() { + apiServerName, apiServerNameOk := apiServer.GetNameOk() + apiServerId, apiServerIdOk := apiServer.GetIdOk() + + if apiServerNameOk && apiServerIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize API Service Name": *apiServerName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize API Service ID": *apiServerId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *apiServerName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *apiServerId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeAPIServiceResource) ResourceType() string { + return "pingone_authorize_api_service" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_test.go new file mode 100644 index 00000000..c71e636f --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeAPIServiceExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeAPIService(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_api_service", + ResourceName: "Test Authorize API Service", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} From ef7b359dbee040e9e76408b0b6a3361710c3a26e Mon Sep 17 00:00:00 2001 From: Patrick Cowland Date: Thu, 10 Oct 2024 18:27:12 +0100 Subject: [PATCH 2/8] development updates --- ...ingone_authorize_api_service_deployment.go | 95 ++++++++++++++++++ ...e_authorize_api_service_deployment_test.go | 27 ++++++ ...pingone_authorize_api_service_operation.go | 96 +++++++++++++++++++ ...ne_authorize_api_service_operation_test.go | 27 ++++++ .../pingone_authorize_application_role.go | 70 ++++++++++++++ ...e_authorize_application_role_permission.go | 95 ++++++++++++++++++ ...horize_application_role_permission_test.go | 27 ++++++ ...pingone_authorize_application_role_test.go | 27 ++++++ .../pingone_authorize_decision_endpoint.go | 70 ++++++++++++++ ...ingone_authorize_decision_endpoint_test.go | 27 ++++++ ...authorize_policy_management_policy_test.go | 27 ++++++ ...e_authorize_policy_management_rule_test.go | 27 ++++++ ...horize_policy_management_statement_test.go | 27 ++++++ ...uthorize_trust_framework_attribute_test.go | 27 ++++++ ...uthorize_trust_framework_condition_test.go | 27 ++++++ ...uthorize_trust_framework_processor_test.go | 27 ++++++ ..._authorize_trust_framework_service_test.go | 27 ++++++ 17 files changed, 750 insertions(+) create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_application_role_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor_test.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service_test.go diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go new file mode 100644 index 00000000..e06a6fec --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go @@ -0,0 +1,95 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeAPIServiceDeploymentResource{} +) + +type PingoneAuthorizeAPIServiceDeploymentResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeAPIServiceDeploymentResource +func AuthorizeAPIServiceDeployment(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeAPIServiceDeploymentResource { + return &PingoneAuthorizeAPIServiceDeploymentResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeAPIServiceDeploymentResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServersApi.ReadAllAPIServers(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ReadAllAPIServers" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, apiServer := range embedded.GetApiServers() { + var ( + apiServerId *string + apiServerIdOk bool + apiServerName *string + apiServerNameOk bool + ) + + apiServerId, apiServerIdOk = apiServer.GetIdOk() + apiServerName, apiServerNameOk = apiServer.GetNameOk() + + if apiServerIdOk && apiServerNameOk { + + _, response, err := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServerDeploymentApi.ReadDeploymentStatus(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID, *apiServerId).Execute() + err = common.HandleClientResponse(response, err, "ReadDeploymentStatus", r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + if response.StatusCode == 204 { + l.Debug().Msgf("No exportable %s resource found", r.ResourceType()) + return &importBlocks, nil + } + + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize API Service Name": *apiServerName, + "Authorize API Service ID": *apiServerId, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *apiServerName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *apiServerId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + + return &importBlocks, nil + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeAPIServiceDeploymentResource) ResourceType() string { + return "pingone_authorize_api_service_deployment" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go new file mode 100644 index 00000000..d5e28a5a --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeAPIServiceDeploymentExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeAPIServiceDeployment(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_api_service_deployment", + ResourceName: "Test Authorize API Service Deployment", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go new file mode 100644 index 00000000..084cded5 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go @@ -0,0 +1,96 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeAPIServiceOperationResource{} +) + +type PingoneAuthorizeAPIServiceOperationResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeAPIServiceOperationResource +func AuthorizeAPIServiceOperation(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeAPIServiceOperationResource { + return &PingoneAuthorizeAPIServiceOperationResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeAPIServiceOperationResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteAPIServersFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServersApi.ReadAllAPIServers(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiAPIServersFunctionName := "ReadAllAPIServers" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteAPIServersFunc, apiAPIServersFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, apiServer := range embedded.GetApiServers() { + var ( + apiServerId *string + apiServerIdOk bool + apiServerName *string + apiServerNameOk bool + ) + + apiServerId, apiServerIdOk = apiServer.GetIdOk() + apiServerName, apiServerNameOk = apiServer.GetNameOk() + + if apiServerIdOk && apiServerNameOk { + apiExecuteOperationsFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServerOperationsApi.ReadAllAPIServerOperations(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID, *apiServerId).Execute + apiOperationsFunctionName := "ReadAllAPIServerOperations" + + operationsEmbedded, err := common.GetAuthorizeEmbedded(apiExecuteOperationsFunc, apiOperationsFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + for _, apiServerOperation := range operationsEmbedded.GetOperations() { + apiServerOperationId, apiServerOperationIdOk := apiServerOperation.GetIdOk() + apiServerOperationName, apiServerOperationNameOk := apiServerOperation.GetNameOk() + + if apiServerOperationNameOk && apiServerOperationIdOk { + + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize API Service Name": *apiServerName, + "Authorize API Service ID": *apiServerId, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize API Service Operation Name": *apiServerOperationName, + "Authorize API Service Operation ID": *apiServerOperationId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: fmt.Sprintf("%s_%s", *apiServerName, *apiServerOperationName), + ResourceID: fmt.Sprintf("%s/%s/%s", r.clientInfo.ExportEnvironmentID, *apiServerId, *apiServerOperationId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + + } + } + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeAPIServiceOperationResource) ResourceType() string { + return "pingone_authorize_api_service_operation" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation_test.go new file mode 100644 index 00000000..49337619 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeAPIServiceOperationExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeAPIServiceOperation(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_api_service_operation", + ResourceName: "Example API Service Operation", + ResourceID: fmt.Sprintf("%s/2a7c1b5d-415b-4fb5-a6c0-1e290f776785/056ed696-f2e9-44b1-8d2c-68e690cd1f24", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go new file mode 100644 index 00000000..5bc3a964 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go @@ -0,0 +1,70 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeApplicationRoleResource{} +) + +type PingoneAuthorizeApplicationRoleResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeApplicationRoleResource +func AuthorizeApplicationRole(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeApplicationRoleResource { + return &PingoneAuthorizeApplicationRoleResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeApplicationRoleResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.ApplicationRolesApi.ReadApplicationRoles(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ReadApplicationRoles" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, appRole := range embedded.GetRoles() { + appRoleName, appRoleNameOk := appRole.GetNameOk() + appRoleId, appRoleIdOk := appRole.GetIdOk() + + if appRoleNameOk && appRoleIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Application Role Name": *appRoleName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Application Role ID": *appRoleId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *appRoleName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *appRoleId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeApplicationRoleResource) ResourceType() string { + return "pingone_authorize_application_role" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go new file mode 100644 index 00000000..2d4cf55a --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go @@ -0,0 +1,95 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeApplicationRolePermissionResource{} +) + +type PingoneAuthorizeApplicationRolePermissionResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeApplicationRolePermissionResource +func AuthorizeApplicationRolePermission(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeApplicationRolePermissionResource { + return &PingoneAuthorizeApplicationRolePermissionResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeApplicationRolePermissionResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteApplicationRoleFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.ApplicationRolesApi.ReadApplicationRoles(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiApplicationRoleFunctionName := "ReadApplicationRoles" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteApplicationRoleFunc, apiApplicationRoleFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, applicationRole := range embedded.GetRoles() { + var ( + applicationRoleId *string + applicationRoleIdOk bool + applicationRoleName *string + applicationRoleNameOk bool + ) + + applicationRoleId, applicationRoleIdOk = applicationRole.GetIdOk() + applicationRoleName, applicationRoleNameOk = applicationRole.GetNameOk() + + if applicationRoleIdOk && applicationRoleNameOk { + apiExecutePermissionsFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.ApplicationResourcePermissionsApi.ReadApplicationPermissions(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID, *applicationRoleId).Execute + apiPermissionsFunctionName := "ReadApplicationPermissions" + + permissionsEmbedded, err := common.GetAuthorizeEmbedded(apiExecutePermissionsFunc, apiPermissionsFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + for _, applicationRolePermission := range permissionsEmbedded.GetPermissions() { + if v := applicationRolePermission.ApplicationRolePermission; v != nil { + applicationRolePermissionId, applicationRolePermissionIdOk := v.GetIdOk() + + if applicationRolePermissionIdOk { + + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Application Role Name": *applicationRoleName, + "Authorize Application Role ID": *applicationRoleId, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Application Role Permission ID": *applicationRolePermissionId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: fmt.Sprintf("%s_%s", *applicationRoleName, *applicationRolePermissionId), + ResourceID: fmt.Sprintf("%s/%s/%s", r.clientInfo.ExportEnvironmentID, *applicationRoleId, *applicationRolePermissionId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + } + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeApplicationRolePermissionResource) ResourceType() string { + return "pingone_authorize_api_service_operation" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission_test.go new file mode 100644 index 00000000..770a2420 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeApplicationRolePermissionExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeApplicationRolePermission(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_application_role_permission", + ResourceName: "Test Authorize Application Role Permission", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_test.go new file mode 100644 index 00000000..eed239e1 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeApplicationRoleExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeApplicationRole(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_application_role", + ResourceName: "Test Authorize Application Role", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go new file mode 100644 index 00000000..be1df95c --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go @@ -0,0 +1,70 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeDecisionEndpointResource{} +) + +type PingoneAuthorizeDecisionEndpointResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeDecisionEndpointResource +func AuthorizeDecisionEndpoint(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeDecisionEndpointResource { + return &PingoneAuthorizeDecisionEndpointResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeDecisionEndpointResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.PolicyDecisionManagementApi.ReadAllDecisionEndpoints(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ReadAllDecisionEndpoints" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, decisionEndpoint := range embedded.GetDecisionEndpoints() { + decisionEndpointName, decisionEndpointNameOk := decisionEndpoint.GetNameOk() + decisionEndpointId, decisionEndpointIdOk := decisionEndpoint.GetIdOk() + + if decisionEndpointNameOk && decisionEndpointIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Decision Endpoint Name": *decisionEndpointName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Decision Endpoint ID": *decisionEndpointId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *decisionEndpointName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *decisionEndpointId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeDecisionEndpointResource) ResourceType() string { + return "pingone_authorize_decision_endpoint" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint_test.go new file mode 100644 index 00000000..397e7fd7 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeDecisionEndpointExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeDecisionEndpoint(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_decision_endpoint", + ResourceName: "Test Authorize Decision Endpoint", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy_test.go new file mode 100644 index 00000000..6bd925c8 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizePolicyManagementPolicyExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizePolicyManagementPolicy(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_policy_management_policy", + ResourceName: "Test Authorize Policy Management Policy", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule_test.go new file mode 100644 index 00000000..7c72ba79 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizePolicyManagementRuleExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizePolicyManagementRule(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_policy_management_rule", + ResourceName: "Test Authorize Policy Management Rule", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement_test.go new file mode 100644 index 00000000..dc856e26 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizePolicyManagementStatementExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizePolicyManagementStatement(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_policy_management_statement", + ResourceName: "Test Authorize Policy Management Statement", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute_test.go new file mode 100644 index 00000000..cae121df --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeTrustFrameworkAttributeExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeTrustFrameworkAttribute(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_trust_framework_attribute", + ResourceName: "Test Authorize Trust Framework Attribute", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition_test.go new file mode 100644 index 00000000..ccecfa19 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeTrustFrameworkConditionExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeTrustFrameworkCondition(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_trust_framework_condition", + ResourceName: "Test Authorize Trust Framework Condition", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor_test.go new file mode 100644 index 00000000..08e58005 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeTrustFrameworkProcessorExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeTrustFrameworkProcessor(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_trust_framework_processor", + ResourceName: "Test Authorize Trust Framework Processor", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service_test.go new file mode 100644 index 00000000..2502c24d --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service_test.go @@ -0,0 +1,27 @@ +package resources_test + +import ( + "fmt" + "testing" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingctl/internal/testing/testutils" +) + +func TestAuthorizeTrustFrameworkServiceExport(t *testing.T) { + // Get initialized apiClient and resource + PingOneClientInfo := testutils.GetPingOneClientInfo(t) + resource := resources.AuthorizeTrustFrameworkService(PingOneClientInfo) + + // Defined the expected ImportBlocks for the resource + expectedImportBlocks := []connector.ImportBlock{ + { + ResourceType: "pingone_authorize_trust_framework_service", + ResourceName: "Test Authorize Trust Framework Service", + ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), + }, + } + + testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +} From b5b0357cfba288019013fe8862f090d54dd10ed8 Mon Sep 17 00:00:00 2001 From: Patrick Cowland Date: Fri, 11 Oct 2024 10:51:44 +0100 Subject: [PATCH 3/8] full authorize draft (pre-testing) --- ...gone_authorize_policy_management_policy.go | 70 +++++++++++++++ ...ingone_authorize_policy_management_rule.go | 70 +++++++++++++++ ...e_authorize_policy_management_statement.go | 70 +++++++++++++++ ...one_authorize_trust_framework_attribute.go | 70 +++++++++++++++ ...one_authorize_trust_framework_condition.go | 70 +++++++++++++++ ...one_authorize_trust_framework_processor.go | 70 +++++++++++++++ ...ngone_authorize_trust_framework_service.go | 90 +++++++++++++++++++ 7 files changed, 510 insertions(+) create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go create mode 100644 internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go new file mode 100644 index 00000000..b4d75ae5 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go @@ -0,0 +1,70 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizePolicyManagementPolicyResource{} +) + +type PingoneAuthorizePolicyManagementPolicyResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizePolicyManagementPolicyResource +func AuthorizePolicyManagementPolicy(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizePolicyManagementPolicyResource { + return &PingoneAuthorizePolicyManagementPolicyResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizePolicyManagementPolicyResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorPoliciesApi.ListRootPolicies(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ListRootPolicies" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, authorizationPolicy := range embedded.GetAuthorizationPolicies() { + authorizationPolicyName, authorizationPolicyNameOk := authorizationPolicy.GetNameOk() + authorizationPolicyId, authorizationPolicyIdOk := authorizationPolicy.GetIdOk() + + if authorizationPolicyNameOk && authorizationPolicyIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Policy Management Authorization Policy Name": *authorizationPolicyName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Policy Management Authorization Policy ID": *authorizationPolicyId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *authorizationPolicyName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationPolicyId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizePolicyManagementPolicyResource) ResourceType() string { + return "pingone_authorize_policy_management_policy" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go new file mode 100644 index 00000000..c940c665 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go @@ -0,0 +1,70 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizePolicyManagementRuleResource{} +) + +type PingoneAuthorizePolicyManagementRuleResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizePolicyManagementRuleResource +func AuthorizePolicyManagementRule(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizePolicyManagementRuleResource { + return &PingoneAuthorizePolicyManagementRuleResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizePolicyManagementRuleResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorRulesApi.ListRules(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ListRules" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, authorizationRule := range embedded.GetAuthorizationRules() { + authorizationRuleName, authorizationRuleNameOk := authorizationRule.GetNameOk() + authorizationRuleId, authorizationRuleIdOk := authorizationRule.GetIdOk() + + if authorizationRuleNameOk && authorizationRuleIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Policy Management Authorization Rule Name": *authorizationRuleName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Policy Management Authorization Rule ID": *authorizationRuleId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *authorizationRuleName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationRuleId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizePolicyManagementRuleResource) ResourceType() string { + return "pingone_authorize_policy_management_rule" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go new file mode 100644 index 00000000..72314e0a --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go @@ -0,0 +1,70 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizePolicyManagementStatementResource{} +) + +type PingoneAuthorizePolicyManagementStatementResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizePolicyManagementStatementResource +func AuthorizePolicyManagementStatement(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizePolicyManagementStatementResource { + return &PingoneAuthorizePolicyManagementStatementResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizePolicyManagementStatementResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorStatementsApi.ListStatements(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ListStatements" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, authorizationStatement := range embedded.GetAuthorizationStatements() { + authorizationStatementName, authorizationStatementNameOk := authorizationStatement.GetNameOk() + authorizationStatementId, authorizationStatementIdOk := authorizationStatement.GetIdOk() + + if authorizationStatementNameOk && authorizationStatementIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Policy Management Authorization Statement Name": *authorizationStatementName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Policy Management Authorization Statement ID": *authorizationStatementId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *authorizationStatementName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationStatementId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizePolicyManagementStatementResource) ResourceType() string { + return "pingone_authorize_policy_management_statement" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go new file mode 100644 index 00000000..a29c9712 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go @@ -0,0 +1,70 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeTrustFrameworkAttributeResource{} +) + +type PingoneAuthorizeTrustFrameworkAttributeResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeTrustFrameworkAttributeResource +func AuthorizeTrustFrameworkAttribute(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeTrustFrameworkAttributeResource { + return &PingoneAuthorizeTrustFrameworkAttributeResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeTrustFrameworkAttributeResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorAttributesApi.ListAttributes(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ListAttributes" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, authorizationAttribute := range embedded.GetAuthorizationAttributes() { + authorizationAttributeName, authorizationAttributeNameOk := authorizationAttribute.GetNameOk() + authorizationAttributeId, authorizationAttributeIdOk := authorizationAttribute.GetIdOk() + + if authorizationAttributeNameOk && authorizationAttributeIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Trust Framework Attribute Name": *authorizationAttributeName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Trust Framework Attribute ID": *authorizationAttributeId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *authorizationAttributeName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationAttributeId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeTrustFrameworkAttributeResource) ResourceType() string { + return "pingone_authorize_trust_framework_attribute" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go new file mode 100644 index 00000000..18dee829 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go @@ -0,0 +1,70 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeTrustFrameworkConditionResource{} +) + +type PingoneAuthorizeTrustFrameworkConditionResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeTrustFrameworkConditionResource +func AuthorizeTrustFrameworkCondition(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeTrustFrameworkConditionResource { + return &PingoneAuthorizeTrustFrameworkConditionResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeTrustFrameworkConditionResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorConditionsApi.ListConditions(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ListConditions" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, authorizationCondition := range embedded.GetAuthorizationConditions() { + authorizationConditionName, authorizationConditionNameOk := authorizationCondition.GetNameOk() + authorizationConditionId, authorizationConditionIdOk := authorizationCondition.GetIdOk() + + if authorizationConditionNameOk && authorizationConditionIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Trust Framework Condition Name": *authorizationConditionName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Trust Framework Condition ID": *authorizationConditionId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *authorizationConditionName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationConditionId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeTrustFrameworkConditionResource) ResourceType() string { + return "pingone_authorize_trust_framework_condition" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go new file mode 100644 index 00000000..90f6ec5f --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go @@ -0,0 +1,70 @@ +package resources + +import ( + "fmt" + + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeTrustFrameworkProcessorResource{} +) + +type PingoneAuthorizeTrustFrameworkProcessorResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeTrustFrameworkProcessorResource +func AuthorizeTrustFrameworkProcessor(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeTrustFrameworkProcessorResource { + return &PingoneAuthorizeTrustFrameworkProcessorResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeTrustFrameworkProcessorResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorProcessorsApi.ListProcessors(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ListProcessors" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, authorizationProcessor := range embedded.GetAuthorizationProcessors() { + authorizationProcessorName, authorizationProcessorNameOk := authorizationProcessor.GetNameOk() + authorizationProcessorId, authorizationProcessorIdOk := authorizationProcessor.GetIdOk() + + if authorizationProcessorNameOk && authorizationProcessorIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Trust Framework Processor Name": *authorizationProcessorName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Trust Framework Processor ID": *authorizationProcessorId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *authorizationProcessorName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationProcessorId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeTrustFrameworkProcessorResource) ResourceType() string { + return "pingone_authorize_trust_framework_processor" +} diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go new file mode 100644 index 00000000..e7a3d31e --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go @@ -0,0 +1,90 @@ +package resources + +import ( + "fmt" + + "github.com/patrickcping/pingone-go-sdk-v2/authorize" + "github.com/pingidentity/pingctl/internal/connector" + "github.com/pingidentity/pingctl/internal/connector/common" + "github.com/pingidentity/pingctl/internal/logger" +) + +// Verify that the resource satisfies the exportable resource interface +var ( + _ connector.ExportableResource = &PingoneAuthorizeTrustFrameworkServiceResource{} +) + +type PingoneAuthorizeTrustFrameworkServiceResource struct { + clientInfo *connector.PingOneClientInfo +} + +// Utility method for creating a PingoneAuthorizeTrustFrameworkServiceResource +func AuthorizeTrustFrameworkService(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeTrustFrameworkServiceResource { + return &PingoneAuthorizeTrustFrameworkServiceResource{ + clientInfo: clientInfo, + } +} + +func (r *PingoneAuthorizeTrustFrameworkServiceResource) ExportAll() (*[]connector.ImportBlock, error) { + l := logger.Get() + + l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + + apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorServicesApi.ListServices(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute + apiFunctionName := "ListServices" + + embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + if err != nil { + return nil, err + } + + importBlocks := []connector.ImportBlock{} + + l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + + for _, authorizationService := range embedded.GetAuthorizationServices() { + + var ( + authorizationServiceId *string + authorizationServiceIdOk bool + authorizationServiceName *string + authorizationServiceNameOk bool + ) + + switch t := authorizationService.GetActualInstance().(type) { + case *authorize.AuthorizeEditorDataServicesConnectorServiceDefinitionDTO: + authorizationServiceId, authorizationServiceIdOk = t.GetIdOk() + authorizationServiceName, authorizationServiceNameOk = t.GetNameOk() + case *authorize.AuthorizeEditorDataServicesHttpServiceDefinitionDTO: + authorizationServiceId, authorizationServiceIdOk = t.GetIdOk() + authorizationServiceName, authorizationServiceNameOk = t.GetNameOk() + case *authorize.AuthorizeEditorDataServicesNoneServiceDefinitionDTO: + authorizationServiceId, authorizationServiceIdOk = t.GetIdOk() + authorizationServiceName, authorizationServiceNameOk = t.GetNameOk() + default: + continue + } + + if authorizationServiceNameOk && authorizationServiceIdOk { + commentData := map[string]string{ + "Resource Type": r.ResourceType(), + "Authorize Trust Framework Service Name": *authorizationServiceName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Authorize Trust Framework Service ID": *authorizationServiceId, + } + + importBlocks = append(importBlocks, connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: *authorizationServiceName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationServiceId), + CommentInformation: common.GenerateCommentInformation(commentData), + }) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeTrustFrameworkServiceResource) ResourceType() string { + return "pingone_authorize_trust_framework_service" +} From 64ae3195fff1df7fb4d7615f86efff39446c67b8 Mon Sep 17 00:00:00 2001 From: Patrick Cowland Date: Tue, 15 Oct 2024 18:52:25 +0100 Subject: [PATCH 4/8] update imports --- .../pingone/authorize/pingone_authorize_connector.go | 8 ++++---- .../pingone/authorize/pingone_authorize_connector_test.go | 8 ++++---- .../authorize/resources/pingone_authorize_api_service.go | 6 +++--- .../resources/pingone_authorize_api_service_deployment.go | 6 +++--- .../pingone_authorize_api_service_deployment_test.go | 6 +++--- .../resources/pingone_authorize_api_service_operation.go | 6 +++--- .../pingone_authorize_api_service_operation_test.go | 6 +++--- .../resources/pingone_authorize_api_service_test.go | 6 +++--- .../resources/pingone_authorize_application_role.go | 6 +++--- .../pingone_authorize_application_role_permission.go | 6 +++--- .../pingone_authorize_application_role_permission_test.go | 6 +++--- .../resources/pingone_authorize_application_role_test.go | 6 +++--- .../resources/pingone_authorize_decision_endpoint.go | 6 +++--- .../resources/pingone_authorize_decision_endpoint_test.go | 6 +++--- .../pingone_authorize_policy_management_policy.go | 6 +++--- .../pingone_authorize_policy_management_policy_test.go | 6 +++--- .../resources/pingone_authorize_policy_management_rule.go | 6 +++--- .../pingone_authorize_policy_management_rule_test.go | 6 +++--- .../pingone_authorize_policy_management_statement.go | 6 +++--- .../pingone_authorize_policy_management_statement_test.go | 6 +++--- .../pingone_authorize_trust_framework_attribute.go | 6 +++--- .../pingone_authorize_trust_framework_attribute_test.go | 6 +++--- .../pingone_authorize_trust_framework_condition.go | 6 +++--- .../pingone_authorize_trust_framework_condition_test.go | 6 +++--- .../pingone_authorize_trust_framework_processor.go | 6 +++--- .../pingone_authorize_trust_framework_processor_test.go | 6 +++--- .../pingone_authorize_trust_framework_service.go | 6 +++--- .../pingone_authorize_trust_framework_service_test.go | 6 +++--- 28 files changed, 86 insertions(+), 86 deletions(-) diff --git a/internal/connector/pingone/authorize/pingone_authorize_connector.go b/internal/connector/pingone/authorize/pingone_authorize_connector.go index e4829bf2..55f7bf69 100644 --- a/internal/connector/pingone/authorize/pingone_authorize_connector.go +++ b/internal/connector/pingone/authorize/pingone_authorize_connector.go @@ -4,10 +4,10 @@ import ( "context" pingoneGoClient "github.com/patrickcping/pingone-go-sdk-v2/pingone" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/logger" ) const ( diff --git a/internal/connector/pingone/authorize/pingone_authorize_connector_test.go b/internal/connector/pingone/authorize/pingone_authorize_connector_test.go index 922ed50e..42f518df 100644 --- a/internal/connector/pingone/authorize/pingone_authorize_connector_test.go +++ b/internal/connector/pingone/authorize/pingone_authorize_connector_test.go @@ -3,10 +3,10 @@ package authorize_test import ( "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" - "github.com/pingidentity/pingctl/internal/testing/testutils_terraform" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/testing/testutils_terraform" ) func TestAuthorizeTerraformPlan(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go index 725da4e3..1fbeb55b 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go index e06a6fec..2a2eb30e 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go index d5e28a5a..cc31d9f6 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeAPIServiceDeploymentExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go index 084cded5..5c0008b2 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation_test.go index 49337619..b982f63c 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeAPIServiceOperationExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_test.go index c71e636f..b28a2fd1 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeAPIServiceExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go index 5bc3a964..d0107a7b 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go index 2d4cf55a..0c5d0948 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission_test.go index 770a2420..36f12ca1 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeApplicationRolePermissionExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_test.go index eed239e1..640c8d88 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeApplicationRoleExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go index be1df95c..295f5d74 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint_test.go index 397e7fd7..bb02d7ce 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeDecisionEndpointExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go index b4d75ae5..88ba6526 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy_test.go index 6bd925c8..98845816 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizePolicyManagementPolicyExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go index c940c665..ce45b34a 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule_test.go index 7c72ba79..1e7744f3 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizePolicyManagementRuleExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go index 72314e0a..0f5d53a7 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement_test.go index dc856e26..392be624 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizePolicyManagementStatementExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go index a29c9712..e4c3dc85 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute_test.go index cae121df..1bb70756 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeTrustFrameworkAttributeExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go index 18dee829..0ef7ec0a 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition_test.go index ccecfa19..9e7f6f1a 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeTrustFrameworkConditionExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go index 90f6ec5f..ccf990f7 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go @@ -3,9 +3,9 @@ package resources import ( "fmt" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor_test.go index 08e58005..c2f96c5c 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeTrustFrameworkProcessorExport(t *testing.T) { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go index e7a3d31e..1bbc3370 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go @@ -4,9 +4,9 @@ import ( "fmt" "github.com/patrickcping/pingone-go-sdk-v2/authorize" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/common" - "github.com/pingidentity/pingctl/internal/logger" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/logger" ) // Verify that the resource satisfies the exportable resource interface diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service_test.go index 2502c24d..639bdd43 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service_test.go @@ -4,9 +4,9 @@ import ( "fmt" "testing" - "github.com/pingidentity/pingctl/internal/connector" - "github.com/pingidentity/pingctl/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingctl/internal/testing/testutils" + "github.com/pingidentity/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/internal/testing/testutils" ) func TestAuthorizeTrustFrameworkServiceExport(t *testing.T) { From 512695f62071e40491386ba3b629406e87f66341 Mon Sep 17 00:00:00 2001 From: Patrick Cowland Date: Thu, 7 Nov 2024 17:04:12 +0000 Subject: [PATCH 5/8] add authorize to available exportable services --- internal/commands/platform/export_internal.go | 3 +++ internal/customtypes/export_services.go | 13 ++++++++----- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/internal/commands/platform/export_internal.go b/internal/commands/platform/export_internal.go index 67ddae83..6f7c8d5f 100644 --- a/internal/commands/platform/export_internal.go +++ b/internal/commands/platform/export_internal.go @@ -17,6 +17,7 @@ import ( "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" "github.com/pingidentity/pingcli/internal/connector/pingfederate" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize" "github.com/pingidentity/pingcli/internal/connector/pingone/mfa" "github.com/pingidentity/pingcli/internal/connector/pingone/platform" "github.com/pingidentity/pingcli/internal/connector/pingone/protect" @@ -465,6 +466,8 @@ func getExportableConnectors(exportServices *customtypes.ExportServices) (export switch service { case customtypes.ENUM_EXPORT_SERVICE_PINGONE_PLATFORM: connectors = append(connectors, platform.PlatformConnector(pingoneContext, pingoneApiClient, &pingoneApiClientId, pingoneExportEnvID)) + case customtypes.ENUM_EXPORT_SERVICE_PINGONE_AUTHORIZE: + connectors = append(connectors, authorize.AuthorizeConnector(pingoneContext, pingoneApiClient, &pingoneApiClientId, pingoneExportEnvID)) case customtypes.ENUM_EXPORT_SERVICE_PINGONE_SSO: connectors = append(connectors, sso.SSOConnector(pingoneContext, pingoneApiClient, &pingoneApiClientId, pingoneExportEnvID)) case customtypes.ENUM_EXPORT_SERVICE_PINGONE_MFA: diff --git a/internal/customtypes/export_services.go b/internal/customtypes/export_services.go index b5f1badc..41be1159 100644 --- a/internal/customtypes/export_services.go +++ b/internal/customtypes/export_services.go @@ -9,11 +9,12 @@ import ( ) const ( - ENUM_EXPORT_SERVICE_PINGONE_PLATFORM string = "pingone-platform" - ENUM_EXPORT_SERVICE_PINGONE_SSO string = "pingone-sso" - ENUM_EXPORT_SERVICE_PINGONE_MFA string = "pingone-mfa" - ENUM_EXPORT_SERVICE_PINGONE_PROTECT string = "pingone-protect" - ENUM_EXPORT_SERVICE_PINGFEDERATE string = "pingfederate" + ENUM_EXPORT_SERVICE_PINGONE_PLATFORM string = "pingone-platform" + ENUM_EXPORT_SERVICE_PINGONE_AUTHORIZE string = "pingone-authorize" + ENUM_EXPORT_SERVICE_PINGONE_SSO string = "pingone-sso" + ENUM_EXPORT_SERVICE_PINGONE_MFA string = "pingone-mfa" + ENUM_EXPORT_SERVICE_PINGONE_PROTECT string = "pingone-protect" + ENUM_EXPORT_SERVICE_PINGFEDERATE string = "pingfederate" ) type ExportServices []string @@ -64,6 +65,7 @@ func (es ExportServices) ContainsPingOneService() bool { pingoneServices := []string{ ENUM_EXPORT_SERVICE_PINGONE_PLATFORM, + ENUM_EXPORT_SERVICE_PINGONE_AUTHORIZE, ENUM_EXPORT_SERVICE_PINGONE_SSO, ENUM_EXPORT_SERVICE_PINGONE_MFA, ENUM_EXPORT_SERVICE_PINGONE_PROTECT, @@ -100,6 +102,7 @@ func ExportServicesValidValues() []string { allServices := []string{ ENUM_EXPORT_SERVICE_PINGFEDERATE, ENUM_EXPORT_SERVICE_PINGONE_PLATFORM, + ENUM_EXPORT_SERVICE_PINGONE_AUTHORIZE, ENUM_EXPORT_SERVICE_PINGONE_SSO, ENUM_EXPORT_SERVICE_PINGONE_MFA, ENUM_EXPORT_SERVICE_PINGONE_PROTECT, From ac7f66d08fe53d0e1b62ae32bfceac72a70a20e2 Mon Sep 17 00:00:00 2001 From: Patrick Cowland Date: Thu, 7 Nov 2024 17:04:39 +0000 Subject: [PATCH 6/8] change name to full name, filter on managed entity --- .../pingone_authorize_policy_management_policy.go | 12 +++++++++++- .../pingone_authorize_trust_framework_attribute.go | 14 ++++++++++++-- .../pingone_authorize_trust_framework_condition.go | 2 +- .../pingone_authorize_trust_framework_processor.go | 2 +- .../pingone_authorize_trust_framework_service.go | 6 +++--- 5 files changed, 28 insertions(+), 8 deletions(-) diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go index 88ba6526..4cf644b4 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go @@ -45,7 +45,17 @@ func (r *PingoneAuthorizePolicyManagementPolicyResource) ExportAll() (*[]connect authorizationPolicyName, authorizationPolicyNameOk := authorizationPolicy.GetNameOk() authorizationPolicyId, authorizationPolicyIdOk := authorizationPolicy.GetIdOk() - if authorizationPolicyNameOk && authorizationPolicyIdOk { + exportableEntity := true + + if managedEntity, ok := authorizationPolicy.GetManagedEntityOk(); ok { + if restrictions, ok := managedEntity.GetRestrictionsOk(); ok { + if restrictions.GetReadOnly() { + exportableEntity = false + } + } + } + + if authorizationPolicyNameOk && authorizationPolicyIdOk && exportableEntity { commentData := map[string]string{ "Resource Type": r.ResourceType(), "Authorize Policy Management Authorization Policy Name": *authorizationPolicyName, diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go index e4c3dc85..a9d9e6ea 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go @@ -42,10 +42,20 @@ func (r *PingoneAuthorizeTrustFrameworkAttributeResource) ExportAll() (*[]connec l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) for _, authorizationAttribute := range embedded.GetAuthorizationAttributes() { - authorizationAttributeName, authorizationAttributeNameOk := authorizationAttribute.GetNameOk() + authorizationAttributeName, authorizationAttributeNameOk := authorizationAttribute.GetFullNameOk() authorizationAttributeId, authorizationAttributeIdOk := authorizationAttribute.GetIdOk() - if authorizationAttributeNameOk && authorizationAttributeIdOk { + exportableEntity := true + + if managedEntity, ok := authorizationAttribute.GetManagedEntityOk(); ok { + if restrictions, ok := managedEntity.GetRestrictionsOk(); ok { + if restrictions.GetReadOnly() { + exportableEntity = false + } + } + } + + if authorizationAttributeNameOk && authorizationAttributeIdOk && exportableEntity { commentData := map[string]string{ "Resource Type": r.ResourceType(), "Authorize Trust Framework Attribute Name": *authorizationAttributeName, diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go index 0ef7ec0a..4fc3af4c 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go @@ -42,7 +42,7 @@ func (r *PingoneAuthorizeTrustFrameworkConditionResource) ExportAll() (*[]connec l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) for _, authorizationCondition := range embedded.GetAuthorizationConditions() { - authorizationConditionName, authorizationConditionNameOk := authorizationCondition.GetNameOk() + authorizationConditionName, authorizationConditionNameOk := authorizationCondition.GetFullNameOk() authorizationConditionId, authorizationConditionIdOk := authorizationCondition.GetIdOk() if authorizationConditionNameOk && authorizationConditionIdOk { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go index ccf990f7..01325ca3 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go @@ -42,7 +42,7 @@ func (r *PingoneAuthorizeTrustFrameworkProcessorResource) ExportAll() (*[]connec l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) for _, authorizationProcessor := range embedded.GetAuthorizationProcessors() { - authorizationProcessorName, authorizationProcessorNameOk := authorizationProcessor.GetNameOk() + authorizationProcessorName, authorizationProcessorNameOk := authorizationProcessor.GetFullNameOk() authorizationProcessorId, authorizationProcessorIdOk := authorizationProcessor.GetIdOk() if authorizationProcessorNameOk && authorizationProcessorIdOk { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go index 1bbc3370..38458aa5 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go @@ -54,13 +54,13 @@ func (r *PingoneAuthorizeTrustFrameworkServiceResource) ExportAll() (*[]connecto switch t := authorizationService.GetActualInstance().(type) { case *authorize.AuthorizeEditorDataServicesConnectorServiceDefinitionDTO: authorizationServiceId, authorizationServiceIdOk = t.GetIdOk() - authorizationServiceName, authorizationServiceNameOk = t.GetNameOk() + authorizationServiceName, authorizationServiceNameOk = t.GetFullNameOk() case *authorize.AuthorizeEditorDataServicesHttpServiceDefinitionDTO: authorizationServiceId, authorizationServiceIdOk = t.GetIdOk() - authorizationServiceName, authorizationServiceNameOk = t.GetNameOk() + authorizationServiceName, authorizationServiceNameOk = t.GetFullNameOk() case *authorize.AuthorizeEditorDataServicesNoneServiceDefinitionDTO: authorizationServiceId, authorizationServiceIdOk = t.GetIdOk() - authorizationServiceName, authorizationServiceNameOk = t.GetNameOk() + authorizationServiceName, authorizationServiceNameOk = t.GetFullNameOk() default: continue } From 506994e8e33d6dd8adf9739527d21ee8d828e5ca Mon Sep 17 00:00:00 2001 From: Patrick Cowland Date: Wed, 26 Feb 2025 15:07:47 +0000 Subject: [PATCH 7/8] update authorize for EA --- go.mod | 4 +- go.sum | 4 +- .../authorize/pingone_authorize_connector.go | 2 +- .../pingone_authorize_connector_test.go | 10 +- .../pingone_authorize_api_service.go | 62 ++++-- ...ingone_authorize_api_service_deployment.go | 205 ++++++++++-------- ...e_authorize_api_service_deployment_test.go | 42 ++-- ...pingone_authorize_api_service_operation.go | 112 ++++++---- .../pingone_authorize_application_role.go | 66 +++--- ...e_authorize_application_role_permission.go | 111 ++++++---- .../pingone_authorize_decision_endpoint.go | 62 ++++-- ...gone_authorize_policy_management_policy.go | 75 ++++--- ...ingone_authorize_policy_management_rule.go | 67 +++--- ...e_authorize_policy_management_statement.go | 66 +++--- ...one_authorize_trust_framework_attribute.go | 73 ++++--- ...one_authorize_trust_framework_condition.go | 67 +++--- ...one_authorize_trust_framework_processor.go | 67 +++--- ...ngone_authorize_trust_framework_service.go | 81 ++++--- internal/connector/pingone/common.go | 36 +++ 19 files changed, 724 insertions(+), 488 deletions(-) diff --git a/go.mod b/go.mod index d76aef6d..3a27d438 100644 --- a/go.mod +++ b/go.mod @@ -7,11 +7,14 @@ tool ( github.com/pavius/impi ) +replace github.com/patrickcping/pingone-go-sdk-v2/authorize => github.com/patrickcping/pingone-go-sdk-v2/authorize v0.8.1-0.20250218183914-e9ec95e476b9 + require ( github.com/fatih/color v1.18.0 github.com/hashicorp/go-uuid v1.0.3 github.com/manifoldco/promptui v0.9.0 github.com/patrickcping/pingone-go-sdk-v2 v0.12.9 + github.com/patrickcping/pingone-go-sdk-v2/authorize v0.8.0 github.com/patrickcping/pingone-go-sdk-v2/management v0.49.0 github.com/patrickcping/pingone-go-sdk-v2/mfa v0.23.0 github.com/patrickcping/pingone-go-sdk-v2/risk v0.19.0 @@ -137,7 +140,6 @@ require ( github.com/nishanths/predeclared v0.2.2 // indirect github.com/nunnatsa/ginkgolinter v0.19.0 // indirect github.com/olekukonko/tablewriter v0.0.5 // indirect - github.com/patrickcping/pingone-go-sdk-v2/authorize v0.8.0 // indirect github.com/patrickcping/pingone-go-sdk-v2/credentials v0.11.0 // indirect github.com/patrickcping/pingone-go-sdk-v2/verify v0.9.0 // indirect github.com/pavius/impi v0.0.3 // indirect diff --git a/go.sum b/go.sum index 24d08f5c..6f81aad9 100644 --- a/go.sum +++ b/go.sum @@ -431,8 +431,8 @@ github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT9 github.com/otiai10/mint v1.3.1/go.mod h1:/yxELlJQ0ufhjUwhshSj+wFjZ78CnZ48/1wtmBH1OTc= github.com/patrickcping/pingone-go-sdk-v2 v0.12.9 h1:EznRTRLzpgHeqkBtXHBrwjIMlfLamqOurODgIKNyoBY= github.com/patrickcping/pingone-go-sdk-v2 v0.12.9/go.mod h1:ZA09d5Rw6Mp7MBT7iJageVfzU1k6yjEjsQCLpIlFyRQ= -github.com/patrickcping/pingone-go-sdk-v2/authorize v0.8.0 h1:gEPzZToJlBcJh2Ft12dP1GCSGzsNFQFEHS7Bql86RQk= -github.com/patrickcping/pingone-go-sdk-v2/authorize v0.8.0/go.mod h1:2PDrgC1ufXk2IDIk4JQHx6r34r2xpkbnzKIpXFv8gYs= +github.com/patrickcping/pingone-go-sdk-v2/authorize v0.8.1-0.20250218183914-e9ec95e476b9 h1:O+LMmb6pH7VKVRV3nZbWadMuBoAq7FhEAi/9s09dhEw= +github.com/patrickcping/pingone-go-sdk-v2/authorize v0.8.1-0.20250218183914-e9ec95e476b9/go.mod h1:2PDrgC1ufXk2IDIk4JQHx6r34r2xpkbnzKIpXFv8gYs= github.com/patrickcping/pingone-go-sdk-v2/credentials v0.11.0 h1:pLiiBkROks/40vhFWJEcr/tiIEqqYdP4FWsHtfCLdIs= github.com/patrickcping/pingone-go-sdk-v2/credentials v0.11.0/go.mod h1:yRGf7+tsB3/AQYsNjIIs4ScJhR885mvDYMgwHiQeMl0= github.com/patrickcping/pingone-go-sdk-v2/management v0.49.0 h1:F1zE2PhxgZCu08TObPylcnXzKqdbaAXkDODWegTE7WM= diff --git a/internal/connector/pingone/authorize/pingone_authorize_connector.go b/internal/connector/pingone/authorize/pingone_authorize_connector.go index 55f7bf69..f2de6344 100644 --- a/internal/connector/pingone/authorize/pingone_authorize_connector.go +++ b/internal/connector/pingone/authorize/pingone_authorize_connector.go @@ -43,7 +43,7 @@ func (c *PingoneAuthorizeConnector) Export(format, outputDir string, overwriteEx exportableResources := []connector.ExportableResource{ resources.AuthorizeAPIService(&c.clientInfo), - resources.AuthorizeAPIServiceDeployment(&c.clientInfo), + // resources.AuthorizeAPIServiceDeployment(&c.clientInfo), resources.AuthorizeAPIServiceOperation(&c.clientInfo), resources.AuthorizeApplicationRole(&c.clientInfo), resources.AuthorizeApplicationRolePermission(&c.clientInfo), diff --git a/internal/connector/pingone/authorize/pingone_authorize_connector_test.go b/internal/connector/pingone/authorize/pingone_authorize_connector_test.go index 42f518df..8c2216e9 100644 --- a/internal/connector/pingone/authorize/pingone_authorize_connector_test.go +++ b/internal/connector/pingone/authorize/pingone_authorize_connector_test.go @@ -24,11 +24,11 @@ func TestAuthorizeTerraformPlan(t *testing.T) { resource: resources.AuthorizeAPIService(PingOneClientInfo), ignoredErrors: nil, }, - { - name: "AuthorizeAPIServiceDeployment", - resource: resources.AuthorizeAPIServiceDeployment(PingOneClientInfo), - ignoredErrors: nil, - }, + // { + // name: "AuthorizeAPIServiceDeployment", + // resource: resources.AuthorizeAPIServiceDeployment(PingOneClientInfo), + // ignoredErrors: nil, + // }, { name: "AuthorizeAPIServiceOperation", resource: resources.AuthorizeAPIServiceOperation(PingOneClientInfo), diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go index 1fbeb55b..3af7aab0 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,43 +28,55 @@ func AuthorizeAPIService(clientInfo *connector.PingOneClientInfo) *PingoneAuthor func (r *PingoneAuthorizeAPIServiceResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServersApi.ReadAllAPIServers(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ReadAllAPIServers" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + APIServerData, err := r.getAPIServerData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for apiServerId, apiServerName := range APIServerData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "API Server ID": apiServerId, + "API Server Name": apiServerName, + "Resource Type": r.ResourceType(), + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: apiServerName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, apiServerId), + CommentInformation: common.GenerateCommentInformation(commentData), + } - for _, apiServer := range embedded.GetApiServers() { - apiServerName, apiServerNameOk := apiServer.GetNameOk() + importBlocks = append(importBlocks, importBlock) + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeAPIServiceResource) getAPIServerData() (map[string]string, error) { + apiServerData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServersApi.ReadAllAPIServers(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + apiServers, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.APIServer](iter, "ReadAllAPIServers", "GetApiServers", r.ResourceType()) + if err != nil { + return nil, err + } + + for _, apiServer := range apiServers { apiServerId, apiServerIdOk := apiServer.GetIdOk() + apiServerName, apiServerNameOk := apiServer.GetNameOk() - if apiServerNameOk && apiServerIdOk { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize API Service Name": *apiServerName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize API Service ID": *apiServerId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *apiServerName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *apiServerId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + if apiServerIdOk && apiServerNameOk { + apiServerData[*apiServerId] = *apiServerName } } - return &importBlocks, nil + return apiServerData, nil } func (r *PingoneAuthorizeAPIServiceResource) ResourceType() string { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go index 2a2eb30e..1e7af6f8 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment.go @@ -1,95 +1,114 @@ package resources -import ( - "fmt" - - "github.com/pingidentity/pingcli/internal/connector" - "github.com/pingidentity/pingcli/internal/connector/common" - "github.com/pingidentity/pingcli/internal/logger" -) - -// Verify that the resource satisfies the exportable resource interface -var ( - _ connector.ExportableResource = &PingoneAuthorizeAPIServiceDeploymentResource{} -) - -type PingoneAuthorizeAPIServiceDeploymentResource struct { - clientInfo *connector.PingOneClientInfo -} - -// Utility method for creating a PingoneAuthorizeAPIServiceDeploymentResource -func AuthorizeAPIServiceDeployment(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeAPIServiceDeploymentResource { - return &PingoneAuthorizeAPIServiceDeploymentResource{ - clientInfo: clientInfo, - } -} - -func (r *PingoneAuthorizeAPIServiceDeploymentResource) ExportAll() (*[]connector.ImportBlock, error) { - l := logger.Get() - - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServersApi.ReadAllAPIServers(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ReadAllAPIServers" - - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) - if err != nil { - return nil, err - } - - importBlocks := []connector.ImportBlock{} - - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) - - for _, apiServer := range embedded.GetApiServers() { - var ( - apiServerId *string - apiServerIdOk bool - apiServerName *string - apiServerNameOk bool - ) - - apiServerId, apiServerIdOk = apiServer.GetIdOk() - apiServerName, apiServerNameOk = apiServer.GetNameOk() - - if apiServerIdOk && apiServerNameOk { - - _, response, err := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServerDeploymentApi.ReadDeploymentStatus(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID, *apiServerId).Execute() - err = common.HandleClientResponse(response, err, "ReadDeploymentStatus", r.ResourceType()) - if err != nil { - return nil, err - } - - importBlocks := []connector.ImportBlock{} - - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) - - if response.StatusCode == 204 { - l.Debug().Msgf("No exportable %s resource found", r.ResourceType()) - return &importBlocks, nil - } - - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize API Service Name": *apiServerName, - "Authorize API Service ID": *apiServerId, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *apiServerName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *apiServerId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) - - return &importBlocks, nil - } - } - - return &importBlocks, nil -} - -func (r *PingoneAuthorizeAPIServiceDeploymentResource) ResourceType() string { - return "pingone_authorize_api_service_deployment" -} +// import ( +// "fmt" + +// "github.com/patrickcping/pingone-go-sdk-v2/authorize" +// "github.com/pingidentity/pingcli/internal/connector" +// "github.com/pingidentity/pingcli/internal/connector/common" +// "github.com/pingidentity/pingcli/internal/connector/pingone" +// "github.com/pingidentity/pingcli/internal/logger" +// ) + +// // Verify that the resource satisfies the exportable resource interface +// var ( +// _ connector.ExportableResource = &PingoneAuthorizeAPIServiceDeploymentResource{} +// ) + +// type PingoneAuthorizeAPIServiceDeploymentResource struct { +// clientInfo *connector.PingOneClientInfo +// } + +// // Utility method for creating a PingoneAuthorizeAPIServiceDeploymentResource +// func AuthorizeAPIServiceDeployment(clientInfo *connector.PingOneClientInfo) *PingoneAuthorizeAPIServiceDeploymentResource { +// return &PingoneAuthorizeAPIServiceDeploymentResource{ +// clientInfo: clientInfo, +// } +// } + +// func (r *PingoneAuthorizeAPIServiceDeploymentResource) ExportAll() (*[]connector.ImportBlock, error) { +// l := logger.Get() +// l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) + +// importBlocks := []connector.ImportBlock{} + +// apiServiceData, err := r.getAPIServiceData() +// if err != nil { +// return nil, err +// } + +// for apiServiceId, apiServiceName := range apiServiceData { +// apiServiceDeploymentData, err := r.getAPIServiceDeploymentData(apiServiceId) +// if err != nil { +// return nil, err +// } + +// for apiServiceDeploymentId, apiServiceDeploymentName := range apiServiceDeploymentData { +// commentData := map[string]string{ +// "API Service ID": apiServiceId, +// "API Service Name": apiServiceName, +// "API Service Deployment ID": apiServiceDeploymentId, +// "API Service Deployment Name": apiServiceDeploymentName, +// "Export Environment ID": r.clientInfo.ExportEnvironmentID, +// "Resource Type": r.ResourceType(), +// } + +// importBlock := connector.ImportBlock{ +// ResourceType: r.ResourceType(), +// ResourceName: fmt.Sprintf("%s_%s", apiServiceName, apiServiceDeploymentId), +// ResourceID: fmt.Sprintf("%s/%s/%s", r.clientInfo.ExportEnvironmentID, apiServiceId, apiServiceDeploymentId), +// CommentInformation: common.GenerateCommentInformation(commentData), +// } + +// importBlocks = append(importBlocks, importBlock) +// } +// } + +// return &importBlocks, nil +// } + +// func (r *PingoneAuthorizeAPIServiceDeploymentResource) getAPIServiceData() (map[string]string, error) { +// apiServiceData := make(map[string]string) + +// iter := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServersApi.ReadAllAPIServers(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() +// apiServices, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.APIServer](iter, "ReadAllAPIServers", "GetAPIServers", r.ResourceType()) +// if err != nil { +// return nil, err +// } + +// for _, apiService := range apiServices { +// apiServiceId, apiServiceIdOk := apiService.GetIdOk() +// apiServiceName, apiServiceNameOk := apiService.GetNameOk() + +// if apiServiceIdOk && apiServiceNameOk { +// apiServiceData[*apiServiceId] = *apiServiceName +// } +// } + +// return apiServiceData, nil +// } + +// func (r *PingoneAuthorizeAPIServiceDeploymentResource) getAPIServiceDeploymentData(apiServiceId string) (map[string]string, error) { +// apiServiceDeploymentData := make(map[string]string) + +// iter := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServerDeploymentApi.ReadDeploymentStatus(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID, apiServiceId).Execute() +// apiServiceDeployments, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.APIServerDeployment](iter, "ReadAPIServiceDeployments", "GetRolePermissions", r.ResourceType()) +// if err != nil { +// return nil, err +// } + +// for _, apiServiceDeployment := range apiServiceDeployments { +// apiServiceDeploymentId, apiServiceDeploymentIdOk := apiServiceDeployment.GetIdOk() +// apiServiceDeploymentName, apiServiceDeploymentNameOk := apiServiceDeployment.GetNameOk() + +// if apiServiceDeploymentIdOk && apiServiceDeploymentNameOk { +// apiServiceDeploymentData[*apiServiceDeploymentId] = *apiServiceDeploymentName +// } +// } + +// return apiServiceDeploymentData, nil +// } + +// func (r *PingoneAuthorizeAPIServiceDeploymentResource) ResourceType() string { +// return "pingone_authorize_api_service_deployment" +// } diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go index cc31d9f6..bd05f4f7 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_deployment_test.go @@ -1,27 +1,27 @@ package resources_test -import ( - "fmt" - "testing" +// import ( +// "fmt" +// "testing" - "github.com/pingidentity/pingcli/internal/connector" - "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" - "github.com/pingidentity/pingcli/internal/testing/testutils" -) +// "github.com/pingidentity/pingcli/internal/connector" +// "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" +// "github.com/pingidentity/pingcli/internal/testing/testutils" +// ) -func TestAuthorizeAPIServiceDeploymentExport(t *testing.T) { - // Get initialized apiClient and resource - PingOneClientInfo := testutils.GetPingOneClientInfo(t) - resource := resources.AuthorizeAPIServiceDeployment(PingOneClientInfo) +// func TestAuthorizeAPIServiceDeploymentExport(t *testing.T) { +// // Get initialized apiClient and resource +// PingOneClientInfo := testutils.GetPingOneClientInfo(t) +// resource := resources.AuthorizeAPIServiceDeployment(PingOneClientInfo) - // Defined the expected ImportBlocks for the resource - expectedImportBlocks := []connector.ImportBlock{ - { - ResourceType: "pingone_authorize_api_service_deployment", - ResourceName: "Test Authorize API Service Deployment", - ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), - }, - } +// // Defined the expected ImportBlocks for the resource +// expectedImportBlocks := []connector.ImportBlock{ +// { +// ResourceType: "pingone_authorize_api_service_deployment", +// ResourceName: "Test Authorize API Service Deployment", +// ResourceID: fmt.Sprintf("%s/5ae2227f-cb5b-47c3-bb40-440db09a98e6", testutils.GetEnvironmentID()), +// }, +// } - testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) -} +// testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks) +// } diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go index 5c0008b2..242ceb16 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_api_service_operation.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,69 +28,85 @@ func AuthorizeAPIServiceOperation(clientInfo *connector.PingOneClientInfo) *Ping func (r *PingoneAuthorizeAPIServiceOperationResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) + importBlocks := []connector.ImportBlock{} + + apiServiceData, err := r.getAPIServiceData() + if err != nil { + return nil, err + } + + for apiServiceId, apiServiceName := range apiServiceData { + apiServiceOperationData, err := r.getAPIServiceOperationData(apiServiceId) + if err != nil { + return nil, err + } - apiExecuteAPIServersFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServersApi.ReadAllAPIServers(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiAPIServersFunctionName := "ReadAllAPIServers" + for apiServiceOperationId, apiServiceOperationName := range apiServiceOperationData { + commentData := map[string]string{ + "API Service ID": apiServiceId, + "API Service Name": apiServiceName, + "API Service Operation ID": apiServiceOperationId, + "API Service Operation Name": apiServiceOperationName, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Resource Type": r.ResourceType(), + } + + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: fmt.Sprintf("%s_%s", apiServiceName, apiServiceOperationName), + ResourceID: fmt.Sprintf("%s/%s/%s", r.clientInfo.ExportEnvironmentID, apiServiceId, apiServiceOperationId), + CommentInformation: common.GenerateCommentInformation(commentData), + } - embedded, err := common.GetAuthorizeEmbedded(apiExecuteAPIServersFunc, apiAPIServersFunctionName, r.ResourceType()) + importBlocks = append(importBlocks, importBlock) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeAPIServiceOperationResource) getAPIServiceData() (map[string]string, error) { + apiServiceData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServersApi.ReadAllAPIServers(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + apiServices, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.APIServer](iter, "ReadAllAPIServers", "GetApiServers", r.ResourceType()) if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for _, apiService := range apiServices { + apiServiceId, apiServiceIdOk := apiService.GetIdOk() + apiServiceName, apiServiceNameOk := apiService.GetNameOk() - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + if apiServiceIdOk && apiServiceNameOk { + apiServiceData[*apiServiceId] = *apiServiceName + } + } - for _, apiServer := range embedded.GetApiServers() { - var ( - apiServerId *string - apiServerIdOk bool - apiServerName *string - apiServerNameOk bool - ) + return apiServiceData, nil +} - apiServerId, apiServerIdOk = apiServer.GetIdOk() - apiServerName, apiServerNameOk = apiServer.GetNameOk() +func (r *PingoneAuthorizeAPIServiceOperationResource) getAPIServiceOperationData(apiServiceId string) (map[string]string, error) { + apiServiceOperationData := make(map[string]string) - if apiServerIdOk && apiServerNameOk { - apiExecuteOperationsFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServerOperationsApi.ReadAllAPIServerOperations(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID, *apiServerId).Execute - apiOperationsFunctionName := "ReadAllAPIServerOperations" + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.APIServerOperationsApi.ReadAllAPIServerOperations(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID, apiServiceId).Execute() + apiServiceOperations, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.APIServerOperation](iter, "ReadAllAPIServerOperations", "GetOperations", r.ResourceType()) + if err != nil { + return nil, err + } - operationsEmbedded, err := common.GetAuthorizeEmbedded(apiExecuteOperationsFunc, apiOperationsFunctionName, r.ResourceType()) - if err != nil { - return nil, err - } + for _, apiServiceOperation := range apiServiceOperations { + apiServiceOperationId, apiServiceOperationIdOk := apiServiceOperation.GetIdOk() + apiServiceOperationName, apiServiceOperationNameOk := apiServiceOperation.GetNameOk() - for _, apiServerOperation := range operationsEmbedded.GetOperations() { - apiServerOperationId, apiServerOperationIdOk := apiServerOperation.GetIdOk() - apiServerOperationName, apiServerOperationNameOk := apiServerOperation.GetNameOk() - - if apiServerOperationNameOk && apiServerOperationIdOk { - - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize API Service Name": *apiServerName, - "Authorize API Service ID": *apiServerId, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize API Service Operation Name": *apiServerOperationName, - "Authorize API Service Operation ID": *apiServerOperationId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: fmt.Sprintf("%s_%s", *apiServerName, *apiServerOperationName), - ResourceID: fmt.Sprintf("%s/%s/%s", r.clientInfo.ExportEnvironmentID, *apiServerId, *apiServerOperationId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) - - } - } + if apiServiceOperationIdOk && apiServiceOperationNameOk { + apiServiceOperationData[*apiServiceOperationId] = *apiServiceOperationName } } - return &importBlocks, nil + return apiServiceOperationData, nil } func (r *PingoneAuthorizeAPIServiceOperationResource) ResourceType() string { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go index d0107a7b..46a700d3 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,45 +28,57 @@ func AuthorizeApplicationRole(clientInfo *connector.PingOneClientInfo) *PingoneA func (r *PingoneAuthorizeApplicationRoleResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.ApplicationRolesApi.ReadApplicationRoles(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ReadApplicationRoles" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + ApplicationRoleData, err := r.getApplicationRoleData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for applicationRoleId, applicationRoleName := range ApplicationRoleData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Application Role ID": applicationRoleId, + "Application Role Name": applicationRoleName, + "Resource Type": r.ResourceType(), + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) - - for _, appRole := range embedded.GetRoles() { - appRoleName, appRoleNameOk := appRole.GetNameOk() - appRoleId, appRoleIdOk := appRole.GetIdOk() - - if appRoleNameOk && appRoleIdOk { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Application Role Name": *appRoleName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Application Role ID": *appRoleId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *appRoleName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *appRoleId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: applicationRoleName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, applicationRoleId), + CommentInformation: common.GenerateCommentInformation(commentData), } + + importBlocks = append(importBlocks, importBlock) } return &importBlocks, nil } +func (r *PingoneAuthorizeApplicationRoleResource) getApplicationRoleData() (map[string]string, error) { + applicationRoleData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.ApplicationRolesApi.ReadApplicationRoles(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + applicationRoles, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.ApplicationRole](iter, "ApplicationRolesApi", "GetRoles", r.ResourceType()) + if err != nil { + return nil, err + } + + for _, applicationRole := range applicationRoles { + applicationRoleId, applicationRoleIdOk := applicationRole.GetIdOk() + applicationRoleName, applicationRoleNameOk := applicationRole.GetNameOk() + + if applicationRoleIdOk && applicationRoleNameOk { + applicationRoleData[*applicationRoleId] = *applicationRoleName + } + } + + return applicationRoleData, nil +} + func (r *PingoneAuthorizeApplicationRoleResource) ResourceType() string { return "pingone_authorize_application_role" } diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go index 0c5d0948..dba9f34e 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_application_role_permission.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,70 +28,85 @@ func AuthorizeApplicationRolePermission(clientInfo *connector.PingOneClientInfo) func (r *PingoneAuthorizeApplicationRolePermissionResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteApplicationRoleFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.ApplicationRolesApi.ReadApplicationRoles(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiApplicationRoleFunctionName := "ReadApplicationRoles" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteApplicationRoleFunc, apiApplicationRoleFunctionName, r.ResourceType()) + applicationRoleData, err := r.getApplicationRoleData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for appRoleId, appRoleName := range applicationRoleData { + appRolePermissionData, err := r.getApplicationRolePermissionData(appRoleId) + if err != nil { + return nil, err + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + for appRolePermissionId, _ := range appRolePermissionData { + commentData := map[string]string{ + "Application Role ID": appRoleId, + "Application Role Name": appRoleName, + "Application Role Permission ID": appRolePermissionId, + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Resource Type": r.ResourceType(), + } - for _, applicationRole := range embedded.GetRoles() { - var ( - applicationRoleId *string - applicationRoleIdOk bool - applicationRoleName *string - applicationRoleNameOk bool - ) + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: fmt.Sprintf("%s_%s", appRoleName, appRolePermissionId), + ResourceID: fmt.Sprintf("%s/%s/%s", r.clientInfo.ExportEnvironmentID, appRoleId, appRolePermissionId), + CommentInformation: common.GenerateCommentInformation(commentData), + } - applicationRoleId, applicationRoleIdOk = applicationRole.GetIdOk() - applicationRoleName, applicationRoleNameOk = applicationRole.GetNameOk() + importBlocks = append(importBlocks, importBlock) + } + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeApplicationRolePermissionResource) getApplicationRoleData() (map[string]string, error) { + applicationRoleData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.ApplicationRolesApi.ReadApplicationRoles(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + applicationRoles, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.ApplicationRole](iter, "ApplicationRolesApi", "GetRoles", r.ResourceType()) + if err != nil { + return nil, err + } + + for _, applicationRole := range applicationRoles { + applicationRoleId, applicationRoleIdOk := applicationRole.GetIdOk() + applicationRoleName, applicationRoleNameOk := applicationRole.GetNameOk() if applicationRoleIdOk && applicationRoleNameOk { - apiExecutePermissionsFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.ApplicationResourcePermissionsApi.ReadApplicationPermissions(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID, *applicationRoleId).Execute - apiPermissionsFunctionName := "ReadApplicationPermissions" + applicationRoleData[*applicationRoleId] = *applicationRoleName + } + } - permissionsEmbedded, err := common.GetAuthorizeEmbedded(apiExecutePermissionsFunc, apiPermissionsFunctionName, r.ResourceType()) - if err != nil { - return nil, err - } + return applicationRoleData, nil +} - for _, applicationRolePermission := range permissionsEmbedded.GetPermissions() { - if v := applicationRolePermission.ApplicationRolePermission; v != nil { - applicationRolePermissionId, applicationRolePermissionIdOk := v.GetIdOk() - - if applicationRolePermissionIdOk { - - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Application Role Name": *applicationRoleName, - "Authorize Application Role ID": *applicationRoleId, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Application Role Permission ID": *applicationRolePermissionId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: fmt.Sprintf("%s_%s", *applicationRoleName, *applicationRolePermissionId), - ResourceID: fmt.Sprintf("%s/%s/%s", r.clientInfo.ExportEnvironmentID, *applicationRoleId, *applicationRolePermissionId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) - } - } - } +func (r *PingoneAuthorizeApplicationRolePermissionResource) getApplicationRolePermissionData(appRoleId string) (map[string]string, error) { + applicationRolePermissionData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.ApplicationRolePermissionsApi.ReadApplicationRolePermissions(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID, appRoleId).Execute() + applicationRolePermissions, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.ApplicationRolePermission](iter, "ReadApplicationRolePermissions", "GetRolePermissions", r.ResourceType()) + if err != nil { + return nil, err + } + + for _, applicationRolePermission := range applicationRolePermissions { + applicationRolePermissionId, applicationRolePermissionIdOk := applicationRolePermission.GetIdOk() + + if applicationRolePermissionIdOk { + applicationRolePermissionData[*applicationRolePermissionId] = *applicationRolePermissionId } } - return &importBlocks, nil + return applicationRolePermissionData, nil } func (r *PingoneAuthorizeApplicationRolePermissionResource) ResourceType() string { - return "pingone_authorize_api_service_operation" + return "pingone_authorize_application_role_permission" } diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go index 295f5d74..4902a636 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_decision_endpoint.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,43 +28,55 @@ func AuthorizeDecisionEndpoint(clientInfo *connector.PingOneClientInfo) *Pingone func (r *PingoneAuthorizeDecisionEndpointResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.PolicyDecisionManagementApi.ReadAllDecisionEndpoints(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ReadAllDecisionEndpoints" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + DecisionEndpointData, err := r.getDecisionEndpointData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for decisionEndpointId, decisionEndpointName := range DecisionEndpointData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Decision Endpoint ID": decisionEndpointId, + "Decision Endpoint Name": decisionEndpointName, + "Resource Type": r.ResourceType(), + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: decisionEndpointName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, decisionEndpointId), + CommentInformation: common.GenerateCommentInformation(commentData), + } - for _, decisionEndpoint := range embedded.GetDecisionEndpoints() { - decisionEndpointName, decisionEndpointNameOk := decisionEndpoint.GetNameOk() + importBlocks = append(importBlocks, importBlock) + } + + return &importBlocks, nil +} + +func (r *PingoneAuthorizeDecisionEndpointResource) getDecisionEndpointData() (map[string]string, error) { + decisionEndpointData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.PolicyDecisionManagementApi.ReadAllDecisionEndpoints(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + decisionEndpoints, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.DecisionEndpoint](iter, "ReadAllDecisionEndpoints", "GetDecisionEndpoints", r.ResourceType()) + if err != nil { + return nil, err + } + + for _, decisionEndpoint := range decisionEndpoints { decisionEndpointId, decisionEndpointIdOk := decisionEndpoint.GetIdOk() + decisionEndpointName, decisionEndpointNameOk := decisionEndpoint.GetNameOk() - if decisionEndpointNameOk && decisionEndpointIdOk { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Decision Endpoint Name": *decisionEndpointName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Decision Endpoint ID": *decisionEndpointId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *decisionEndpointName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *decisionEndpointId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + if decisionEndpointIdOk && decisionEndpointNameOk { + decisionEndpointData[*decisionEndpointId] = *decisionEndpointName } } - return &importBlocks, nil + return decisionEndpointData, nil } func (r *PingoneAuthorizeDecisionEndpointResource) ResourceType() string { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go index 4cf644b4..8655baa5 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,55 +28,68 @@ func AuthorizePolicyManagementPolicy(clientInfo *connector.PingOneClientInfo) *P func (r *PingoneAuthorizePolicyManagementPolicyResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorPoliciesApi.ListRootPolicies(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ListRootPolicies" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + editorPolicyData, err := r.getEditorPolicyData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for editorPolicyId, editorPolicyName := range editorPolicyData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Editor Policy ID": editorPolicyId, + "Editor Policy Name": editorPolicyName, + "Resource Type": r.ResourceType(), + } + + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: editorPolicyName, + ResourceID: fmt.Sprintf("%s", r.clientInfo.ExportEnvironmentID), + CommentInformation: common.GenerateCommentInformation(commentData), + } + + importBlocks = append(importBlocks, importBlock) + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + return &importBlocks, nil +} - for _, authorizationPolicy := range embedded.GetAuthorizationPolicies() { - authorizationPolicyName, authorizationPolicyNameOk := authorizationPolicy.GetNameOk() - authorizationPolicyId, authorizationPolicyIdOk := authorizationPolicy.GetIdOk() +func (r *PingoneAuthorizePolicyManagementPolicyResource) getEditorPolicyData() (map[string]string, error) { + editorPolicyData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorPoliciesApi.ListRootPolicies(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + editorPolicys, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.AuthorizeEditorDataPoliciesReferenceablePolicyDTO](iter, "ListRootPolicies", "GetAuthorizationPolicies", r.ResourceType()) + if err != nil { + return nil, err + } - exportableEntity := true + for _, editorPolicy := range editorPolicys { - if managedEntity, ok := authorizationPolicy.GetManagedEntityOk(); ok { - if restrictions, ok := managedEntity.GetRestrictionsOk(); ok { - if restrictions.GetReadOnly() { - exportableEntity = false + if me, ok := editorPolicy.GetManagedEntityOk(); ok { + if restrictions, ok := me.GetRestrictionsOk(); ok { + if readOnly, ok := restrictions.GetReadOnlyOk(); ok { + if *readOnly { + continue + } } } } - if authorizationPolicyNameOk && authorizationPolicyIdOk && exportableEntity { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Policy Management Authorization Policy Name": *authorizationPolicyName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Policy Management Authorization Policy ID": *authorizationPolicyId, - } + editorPolicyId, editorPolicyIdOk := editorPolicy.GetIdOk() + editorPolicyName, editorPolicyNameOk := editorPolicy.GetNameOk() - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *authorizationPolicyName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationPolicyId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + if editorPolicyIdOk && editorPolicyNameOk { + editorPolicyData[*editorPolicyId] = *editorPolicyName } } - return &importBlocks, nil + return editorPolicyData, nil } func (r *PingoneAuthorizePolicyManagementPolicyResource) ResourceType() string { - return "pingone_authorize_policy_management_policy" + return "pingone_authorize_policy_management_root_policy" } diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go index ce45b34a..525e7018 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,45 +28,58 @@ func AuthorizePolicyManagementRule(clientInfo *connector.PingOneClientInfo) *Pin func (r *PingoneAuthorizePolicyManagementRuleResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorRulesApi.ListRules(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ListRules" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + editorRuleData, err := r.getEditorRuleData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for editorRuleId, editorRuleName := range editorRuleData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Editor Rule ID": editorRuleId, + "Editor Rule Name": editorRuleName, + "Resource Type": r.ResourceType(), + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) - - for _, authorizationRule := range embedded.GetAuthorizationRules() { - authorizationRuleName, authorizationRuleNameOk := authorizationRule.GetNameOk() - authorizationRuleId, authorizationRuleIdOk := authorizationRule.GetIdOk() - - if authorizationRuleNameOk && authorizationRuleIdOk { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Policy Management Authorization Rule Name": *authorizationRuleName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Policy Management Authorization Rule ID": *authorizationRuleId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *authorizationRuleName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationRuleId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: editorRuleName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, editorRuleId), + CommentInformation: common.GenerateCommentInformation(commentData), } + + importBlocks = append(importBlocks, importBlock) } return &importBlocks, nil } +func (r *PingoneAuthorizePolicyManagementRuleResource) getEditorRuleData() (map[string]string, error) { + editorRuleData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorRulesApi.ListRules(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + editorRules, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.AuthorizeEditorDataRulesReferenceableRuleDTO](iter, "ListRules", "GetAuthorizationRules", r.ResourceType()) + if err != nil { + return nil, err + } + + for _, editorRule := range editorRules { + + editorRuleId, editorRuleIdOk := editorRule.GetIdOk() + editorRuleName, editorRuleNameOk := editorRule.GetNameOk() + + if editorRuleIdOk && editorRuleNameOk { + editorRuleData[*editorRuleId] = *editorRuleName + } + } + + return editorRuleData, nil +} + func (r *PingoneAuthorizePolicyManagementRuleResource) ResourceType() string { return "pingone_authorize_policy_management_rule" } diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go index 0f5d53a7..fe591d1d 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,45 +28,57 @@ func AuthorizePolicyManagementStatement(clientInfo *connector.PingOneClientInfo) func (r *PingoneAuthorizePolicyManagementStatementResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorStatementsApi.ListStatements(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ListStatements" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + editorStatementData, err := r.getEditorStatementData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for editorStatementId, editorStatementName := range editorStatementData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Editor Statement ID": editorStatementId, + "Editor Statement Name": editorStatementName, + "Resource Type": r.ResourceType(), + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) - - for _, authorizationStatement := range embedded.GetAuthorizationStatements() { - authorizationStatementName, authorizationStatementNameOk := authorizationStatement.GetNameOk() - authorizationStatementId, authorizationStatementIdOk := authorizationStatement.GetIdOk() - - if authorizationStatementNameOk && authorizationStatementIdOk { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Policy Management Authorization Statement Name": *authorizationStatementName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Policy Management Authorization Statement ID": *authorizationStatementId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *authorizationStatementName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationStatementId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: editorStatementName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, editorStatementId), + CommentInformation: common.GenerateCommentInformation(commentData), } + + importBlocks = append(importBlocks, importBlock) } return &importBlocks, nil } +func (r *PingoneAuthorizePolicyManagementStatementResource) getEditorStatementData() (map[string]string, error) { + editorStatementData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorStatementsApi.ListStatements(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + editorStatements, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.AuthorizeEditorDataStatementsReferenceableStatementDTO](iter, "ListStatements", "GetAuthorizationStatements", r.ResourceType()) + if err != nil { + return nil, err + } + + for _, editorStatement := range editorStatements { + editorStatementId, editorStatementIdOk := editorStatement.GetIdOk() + editorStatementName, editorStatementNameOk := editorStatement.GetNameOk() + + if editorStatementIdOk && editorStatementNameOk { + editorStatementData[*editorStatementId] = *editorStatementName + } + } + + return editorStatementData, nil +} + func (r *PingoneAuthorizePolicyManagementStatementResource) ResourceType() string { return "pingone_authorize_policy_management_statement" } diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go index a9d9e6ea..deaedaa2 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,53 +28,66 @@ func AuthorizeTrustFrameworkAttribute(clientInfo *connector.PingOneClientInfo) * func (r *PingoneAuthorizeTrustFrameworkAttributeResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorAttributesApi.ListAttributes(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ListAttributes" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + editorAttributeData, err := r.getEditorAttributeData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for editorAttributeId, editorAttributeName := range editorAttributeData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Editor Attribute ID": editorAttributeId, + "Editor Attribute Name": editorAttributeName, + "Resource Type": r.ResourceType(), + } + + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: editorAttributeName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, editorAttributeId), + CommentInformation: common.GenerateCommentInformation(commentData), + } + + importBlocks = append(importBlocks, importBlock) + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + return &importBlocks, nil +} - for _, authorizationAttribute := range embedded.GetAuthorizationAttributes() { - authorizationAttributeName, authorizationAttributeNameOk := authorizationAttribute.GetFullNameOk() - authorizationAttributeId, authorizationAttributeIdOk := authorizationAttribute.GetIdOk() +func (r *PingoneAuthorizeTrustFrameworkAttributeResource) getEditorAttributeData() (map[string]string, error) { + editorAttributeData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorAttributesApi.ListAttributes(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + editorAttributes, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.AuthorizeEditorDataDefinitionsAttributeDefinitionDTO](iter, "ListAttributes", "GetAuthorizationAttributes", r.ResourceType()) + if err != nil { + return nil, err + } - exportableEntity := true + for _, editorAttribute := range editorAttributes { - if managedEntity, ok := authorizationAttribute.GetManagedEntityOk(); ok { - if restrictions, ok := managedEntity.GetRestrictionsOk(); ok { - if restrictions.GetReadOnly() { - exportableEntity = false + if me, ok := editorAttribute.GetManagedEntityOk(); ok { + if restrictions, ok := me.GetRestrictionsOk(); ok { + if readOnly, ok := restrictions.GetReadOnlyOk(); ok { + if *readOnly { + continue + } } } } - if authorizationAttributeNameOk && authorizationAttributeIdOk && exportableEntity { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Trust Framework Attribute Name": *authorizationAttributeName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Trust Framework Attribute ID": *authorizationAttributeId, - } + editorAttributeId, editorAttributeIdOk := editorAttribute.GetIdOk() + editorAttributeName, editorAttributeNameOk := editorAttribute.GetFullNameOk() - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *authorizationAttributeName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationAttributeId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + if editorAttributeIdOk && editorAttributeNameOk { + editorAttributeData[*editorAttributeId] = *editorAttributeName } } - return &importBlocks, nil + return editorAttributeData, nil } func (r *PingoneAuthorizeTrustFrameworkAttributeResource) ResourceType() string { diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go index 4fc3af4c..78a02170 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,45 +28,58 @@ func AuthorizeTrustFrameworkCondition(clientInfo *connector.PingOneClientInfo) * func (r *PingoneAuthorizeTrustFrameworkConditionResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorConditionsApi.ListConditions(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ListConditions" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + editorConditionData, err := r.getEditorConditionData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for editorConditionId, editorConditionName := range editorConditionData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Editor Condition ID": editorConditionId, + "Editor Condition Name": editorConditionName, + "Resource Type": r.ResourceType(), + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) - - for _, authorizationCondition := range embedded.GetAuthorizationConditions() { - authorizationConditionName, authorizationConditionNameOk := authorizationCondition.GetFullNameOk() - authorizationConditionId, authorizationConditionIdOk := authorizationCondition.GetIdOk() - - if authorizationConditionNameOk && authorizationConditionIdOk { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Trust Framework Condition Name": *authorizationConditionName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Trust Framework Condition ID": *authorizationConditionId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *authorizationConditionName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationConditionId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: editorConditionName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, editorConditionId), + CommentInformation: common.GenerateCommentInformation(commentData), } + + importBlocks = append(importBlocks, importBlock) } return &importBlocks, nil } +func (r *PingoneAuthorizeTrustFrameworkConditionResource) getEditorConditionData() (map[string]string, error) { + editorConditionData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorConditionsApi.ListConditions(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + editorConditions, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.AuthorizeEditorDataDefinitionsConditionDefinitionDTO](iter, "ListConditions", "GetAuthorizationConditions", r.ResourceType()) + if err != nil { + return nil, err + } + + for _, editorCondition := range editorConditions { + + editorConditionId, editorConditionIdOk := editorCondition.GetIdOk() + editorConditionName, editorConditionNameOk := editorCondition.GetFullNameOk() + + if editorConditionIdOk && editorConditionNameOk { + editorConditionData[*editorConditionId] = *editorConditionName + } + } + + return editorConditionData, nil +} + func (r *PingoneAuthorizeTrustFrameworkConditionResource) ResourceType() string { return "pingone_authorize_trust_framework_condition" } diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go index 01325ca3..2e01bd52 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go @@ -3,8 +3,10 @@ package resources import ( "fmt" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -26,45 +28,58 @@ func AuthorizeTrustFrameworkProcessor(clientInfo *connector.PingOneClientInfo) * func (r *PingoneAuthorizeTrustFrameworkProcessorResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorProcessorsApi.ListProcessors(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ListProcessors" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + editorProcessorData, err := r.getEditorProcessorData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for editorProcessorId, editorProcessorName := range editorProcessorData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Editor Processor ID": editorProcessorId, + "Editor Processor Name": editorProcessorName, + "Resource Type": r.ResourceType(), + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) - - for _, authorizationProcessor := range embedded.GetAuthorizationProcessors() { - authorizationProcessorName, authorizationProcessorNameOk := authorizationProcessor.GetFullNameOk() - authorizationProcessorId, authorizationProcessorIdOk := authorizationProcessor.GetIdOk() - - if authorizationProcessorNameOk && authorizationProcessorIdOk { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Trust Framework Processor Name": *authorizationProcessorName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Trust Framework Processor ID": *authorizationProcessorId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *authorizationProcessorName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationProcessorId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: editorProcessorName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, editorProcessorId), + CommentInformation: common.GenerateCommentInformation(commentData), } + + importBlocks = append(importBlocks, importBlock) } return &importBlocks, nil } +func (r *PingoneAuthorizeTrustFrameworkProcessorResource) getEditorProcessorData() (map[string]string, error) { + editorProcessorData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorProcessorsApi.ListProcessors(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + editorProcessors, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.AuthorizeEditorDataDefinitionsProcessorDefinitionDTO](iter, "ListProcessors", "GetAuthorizationProcessors", r.ResourceType()) + if err != nil { + return nil, err + } + + for _, editorProcessor := range editorProcessors { + + editorProcessorId, editorProcessorIdOk := editorProcessor.GetIdOk() + editorProcessorName, editorProcessorNameOk := editorProcessor.GetFullNameOk() + + if editorProcessorIdOk && editorProcessorNameOk { + editorProcessorData[*editorProcessorId] = *editorProcessorName + } + } + + return editorProcessorData, nil +} + func (r *PingoneAuthorizeTrustFrameworkProcessorResource) ResourceType() string { return "pingone_authorize_trust_framework_processor" } diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go index 38458aa5..dfa73199 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go @@ -6,6 +6,7 @@ import ( "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" + "github.com/pingidentity/pingcli/internal/connector/pingone" "github.com/pingidentity/pingcli/internal/logger" ) @@ -27,62 +28,74 @@ func AuthorizeTrustFrameworkService(clientInfo *connector.PingOneClientInfo) *Pi func (r *PingoneAuthorizeTrustFrameworkServiceResource) ExportAll() (*[]connector.ImportBlock, error) { l := logger.Get() + l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType()) - l.Debug().Msgf("Fetching all %s resources...", r.ResourceType()) - - apiExecuteFunc := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorServicesApi.ListServices(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute - apiFunctionName := "ListServices" + importBlocks := []connector.ImportBlock{} - embedded, err := common.GetAuthorizeEmbedded(apiExecuteFunc, apiFunctionName, r.ResourceType()) + editorServiceData, err := r.getEditorServiceData() if err != nil { return nil, err } - importBlocks := []connector.ImportBlock{} + for editorServiceId, editorServiceName := range editorServiceData { + commentData := map[string]string{ + "Export Environment ID": r.clientInfo.ExportEnvironmentID, + "Editor Service ID": editorServiceId, + "Editor Service Name": editorServiceName, + "Resource Type": r.ResourceType(), + } + + importBlock := connector.ImportBlock{ + ResourceType: r.ResourceType(), + ResourceName: editorServiceName, + ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, editorServiceId), + CommentInformation: common.GenerateCommentInformation(commentData), + } + + importBlocks = append(importBlocks, importBlock) + } - l.Debug().Msgf("Generating Import Blocks for all %s resources...", r.ResourceType()) + return &importBlocks, nil +} + +func (r *PingoneAuthorizeTrustFrameworkServiceResource) getEditorServiceData() (map[string]string, error) { + editorServiceData := make(map[string]string) + + iter := r.clientInfo.ApiClient.AuthorizeAPIClient.AuthorizeEditorServicesApi.ListServices(r.clientInfo.Context, r.clientInfo.ExportEnvironmentID).Execute() + editorServices, err := pingone.GetAuthorizeAPIObjectsFromIterator[authorize.AuthorizeEditorDataDefinitionsServiceDefinitionDTO](iter, "ListServices", "GetAuthorizationServices", r.ResourceType()) + if err != nil { + return nil, err + } - for _, authorizationService := range embedded.GetAuthorizationServices() { + for _, editorService := range editorServices { var ( - authorizationServiceId *string - authorizationServiceIdOk bool - authorizationServiceName *string - authorizationServiceNameOk bool + editorServiceId *string + editorServiceIdOk bool + editorServiceName *string + editorServiceNameOk bool ) - switch t := authorizationService.GetActualInstance().(type) { + switch t := editorService.GetActualInstance().(type) { case *authorize.AuthorizeEditorDataServicesConnectorServiceDefinitionDTO: - authorizationServiceId, authorizationServiceIdOk = t.GetIdOk() - authorizationServiceName, authorizationServiceNameOk = t.GetFullNameOk() + editorServiceId, editorServiceIdOk = t.GetIdOk() + editorServiceName, editorServiceNameOk = t.GetFullNameOk() case *authorize.AuthorizeEditorDataServicesHttpServiceDefinitionDTO: - authorizationServiceId, authorizationServiceIdOk = t.GetIdOk() - authorizationServiceName, authorizationServiceNameOk = t.GetFullNameOk() + editorServiceId, editorServiceIdOk = t.GetIdOk() + editorServiceName, editorServiceNameOk = t.GetFullNameOk() case *authorize.AuthorizeEditorDataServicesNoneServiceDefinitionDTO: - authorizationServiceId, authorizationServiceIdOk = t.GetIdOk() - authorizationServiceName, authorizationServiceNameOk = t.GetFullNameOk() + editorServiceId, editorServiceIdOk = t.GetIdOk() + editorServiceName, editorServiceNameOk = t.GetFullNameOk() default: continue } - if authorizationServiceNameOk && authorizationServiceIdOk { - commentData := map[string]string{ - "Resource Type": r.ResourceType(), - "Authorize Trust Framework Service Name": *authorizationServiceName, - "Export Environment ID": r.clientInfo.ExportEnvironmentID, - "Authorize Trust Framework Service ID": *authorizationServiceId, - } - - importBlocks = append(importBlocks, connector.ImportBlock{ - ResourceType: r.ResourceType(), - ResourceName: *authorizationServiceName, - ResourceID: fmt.Sprintf("%s/%s", r.clientInfo.ExportEnvironmentID, *authorizationServiceId), - CommentInformation: common.GenerateCommentInformation(commentData), - }) + if editorServiceIdOk && editorServiceNameOk { + editorServiceData[*editorServiceId] = *editorServiceName } } - return &importBlocks, nil + return editorServiceData, nil } func (r *PingoneAuthorizeTrustFrameworkServiceResource) ResourceType() string { diff --git a/internal/connector/pingone/common.go b/internal/connector/pingone/common.go index 122a7e63..1456cd08 100644 --- a/internal/connector/pingone/common.go +++ b/internal/connector/pingone/common.go @@ -5,6 +5,7 @@ import ( "net/http" "reflect" + "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/patrickcping/pingone-go-sdk-v2/management" "github.com/patrickcping/pingone-go-sdk-v2/mfa" "github.com/patrickcping/pingone-go-sdk-v2/risk" @@ -34,6 +35,41 @@ func CheckSingletonResource(response *http.Response, err error, apiFuncName, res return true, nil } +func GetAuthorizeAPIObjectsFromIterator[T any](iter authorize.EntityArrayPagedIterator, clientFuncName, extractionFuncName, resourceType string) ([]T, error) { + apiObjects := []T{} + + for cursor, err := range iter { + ok, err := common.HandleClientResponse(cursor.HTTPResponse, err, clientFuncName, resourceType) + if err != nil { + return nil, err + } + // A warning was given when handling the client response. Return nil apiObjects to skip export of resource + if !ok { + return nil, nil + } + + nilErr := common.DataNilError(resourceType, cursor.HTTPResponse) + + if cursor.EntityArray == nil { + return nil, nilErr + } + + embedded, embeddedOk := cursor.EntityArray.GetEmbeddedOk() + if !embeddedOk { + return nil, nilErr + } + + apiObject, err := getAPIObjectFromEmbedded[T](reflect.ValueOf(embedded), extractionFuncName, resourceType) + if err != nil { + output.SystemError(err.Error(), nil) + } + + apiObjects = append(apiObjects, apiObject...) + } + + return apiObjects, nil +} + func GetManagementAPIObjectsFromIterator[T any](iter management.EntityArrayPagedIterator, clientFuncName, extractionFuncName, resourceType string) ([]T, error) { apiObjects := []T{} From 3760b9589be3facc00f0c2fe43cb022ed5391b3c Mon Sep 17 00:00:00 2001 From: Patrick Cowland Date: Tue, 4 Mar 2025 14:09:53 +0000 Subject: [PATCH 8/8] correct lint issue --- .../resources/pingone_authorize_policy_management_policy.go | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go index 8655baa5..c2a7d36f 100644 --- a/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go @@ -1,8 +1,6 @@ package resources import ( - "fmt" - "github.com/patrickcping/pingone-go-sdk-v2/authorize" "github.com/pingidentity/pingcli/internal/connector" "github.com/pingidentity/pingcli/internal/connector/common" @@ -48,7 +46,7 @@ func (r *PingoneAuthorizePolicyManagementPolicyResource) ExportAll() (*[]connect importBlock := connector.ImportBlock{ ResourceType: r.ResourceType(), ResourceName: editorPolicyName, - ResourceID: fmt.Sprintf("%s", r.clientInfo.ExportEnvironmentID), + ResourceID: r.clientInfo.ExportEnvironmentID, CommentInformation: common.GenerateCommentInformation(commentData), }