diff --git a/go.mod b/go.mod index d6231954..3a27d438 100644 --- a/go.mod +++ b/go.mod @@ -7,6 +7,8 @@ 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 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 af2d312b..dbf9f7a9 100644 --- a/internal/connector/pingone/authorize/pingone_authorize_connector.go +++ b/internal/connector/pingone/authorize/pingone_authorize_connector.go @@ -42,14 +42,21 @@ func (c *PingoneAuthorizeConnector) Export(format, outputDir string, overwriteEx l.Debug().Msgf("Exporting all PingOne Authorize Resources...") exportableResources := []connector.ExportableResource{ + resources.ApplicationResource(&c.clientInfo), resources.AuthorizeAPIService(&c.clientInfo), resources.AuthorizeAPIServiceDeployment(&c.clientInfo), resources.AuthorizeAPIServiceOperation(&c.clientInfo), - resources.ApplicationResource(&c.clientInfo), resources.AuthorizeApplicationResourcePermission(&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) diff --git a/internal/connector/pingone/authorize/pingone_authorize_connector_test.go b/internal/connector/pingone/authorize/pingone_authorize_connector_test.go index 0cc8923b..42f518df 100644 --- a/internal/connector/pingone/authorize/pingone_authorize_connector_test.go +++ b/internal/connector/pingone/authorize/pingone_authorize_connector_test.go @@ -49,6 +49,41 @@ func TestAuthorizeTerraformPlan(t *testing.T) { 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 { 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..c2a7d36f --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_policy.go @@ -0,0 +1,93 @@ +package resources + +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" +) + +// 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("Exporting all '%s' Resources...", r.ResourceType()) + + importBlocks := []connector.ImportBlock{} + + editorPolicyData, err := r.getEditorPolicyData() + if err != nil { + return nil, err + } + + 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: r.clientInfo.ExportEnvironmentID, + CommentInformation: common.GenerateCommentInformation(commentData), + } + + importBlocks = append(importBlocks, importBlock) + } + + return &importBlocks, nil +} + +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 + } + + for _, editorPolicy := range editorPolicys { + + if me, ok := editorPolicy.GetManagedEntityOk(); ok { + if restrictions, ok := me.GetRestrictionsOk(); ok { + if readOnly, ok := restrictions.GetReadOnlyOk(); ok { + if *readOnly { + continue + } + } + } + } + + editorPolicyId, editorPolicyIdOk := editorPolicy.GetIdOk() + editorPolicyName, editorPolicyNameOk := editorPolicy.GetNameOk() + + if editorPolicyIdOk && editorPolicyNameOk { + editorPolicyData[*editorPolicyId] = *editorPolicyName + } + } + + return editorPolicyData, nil +} + +func (r *PingoneAuthorizePolicyManagementPolicyResource) ResourceType() string { + return "pingone_authorize_policy_management_root_policy" +} 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..98845816 --- /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/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/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.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go new file mode 100644 index 00000000..525e7018 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule.go @@ -0,0 +1,85 @@ +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" +) + +// 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("Exporting all '%s' Resources...", r.ResourceType()) + + importBlocks := []connector.ImportBlock{} + + editorRuleData, err := r.getEditorRuleData() + if err != nil { + return nil, err + } + + 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(), + } + + 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_rule_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_rule_test.go new file mode 100644 index 00000000..1e7744f3 --- /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/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/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.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go new file mode 100644 index 00000000..fe591d1d --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement.go @@ -0,0 +1,84 @@ +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" +) + +// 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("Exporting all '%s' Resources...", r.ResourceType()) + + importBlocks := []connector.ImportBlock{} + + editorStatementData, err := r.getEditorStatementData() + if err != nil { + return nil, err + } + + 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(), + } + + 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_policy_management_statement_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_policy_management_statement_test.go new file mode 100644 index 00000000..392be624 --- /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/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/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.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go new file mode 100644 index 00000000..deaedaa2 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_attribute.go @@ -0,0 +1,95 @@ +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" +) + +// 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("Exporting all '%s' Resources...", r.ResourceType()) + + importBlocks := []connector.ImportBlock{} + + editorAttributeData, err := r.getEditorAttributeData() + if err != nil { + return nil, err + } + + 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) + } + + return &importBlocks, nil +} + +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 + } + + for _, editorAttribute := range editorAttributes { + + if me, ok := editorAttribute.GetManagedEntityOk(); ok { + if restrictions, ok := me.GetRestrictionsOk(); ok { + if readOnly, ok := restrictions.GetReadOnlyOk(); ok { + if *readOnly { + continue + } + } + } + } + + editorAttributeId, editorAttributeIdOk := editorAttribute.GetIdOk() + editorAttributeName, editorAttributeNameOk := editorAttribute.GetFullNameOk() + + if editorAttributeIdOk && editorAttributeNameOk { + editorAttributeData[*editorAttributeId] = *editorAttributeName + } + } + + return editorAttributeData, nil +} + +func (r *PingoneAuthorizeTrustFrameworkAttributeResource) ResourceType() string { + return "pingone_authorize_trust_framework_attribute" +} 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..1bb70756 --- /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/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/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.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go new file mode 100644 index 00000000..78a02170 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition.go @@ -0,0 +1,85 @@ +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" +) + +// 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("Exporting all '%s' Resources...", r.ResourceType()) + + importBlocks := []connector.ImportBlock{} + + editorConditionData, err := r.getEditorConditionData() + if err != nil { + return nil, err + } + + 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(), + } + + 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_condition_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_condition_test.go new file mode 100644 index 00000000..9e7f6f1a --- /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/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/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.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go new file mode 100644 index 00000000..2e01bd52 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor.go @@ -0,0 +1,85 @@ +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" +) + +// 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("Exporting all '%s' Resources...", r.ResourceType()) + + importBlocks := []connector.ImportBlock{} + + editorProcessorData, err := r.getEditorProcessorData() + if err != nil { + return nil, err + } + + 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(), + } + + 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_processor_test.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_processor_test.go new file mode 100644 index 00000000..c2f96c5c --- /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/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/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.go b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go new file mode 100644 index 00000000..dfa73199 --- /dev/null +++ b/internal/connector/pingone/authorize/resources/pingone_authorize_trust_framework_service.go @@ -0,0 +1,103 @@ +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" +) + +// 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("Exporting all '%s' Resources...", r.ResourceType()) + + importBlocks := []connector.ImportBlock{} + + editorServiceData, err := r.getEditorServiceData() + if err != nil { + return nil, err + } + + 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) + } + + 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 _, editorService := range editorServices { + + var ( + editorServiceId *string + editorServiceIdOk bool + editorServiceName *string + editorServiceNameOk bool + ) + + switch t := editorService.GetActualInstance().(type) { + case *authorize.AuthorizeEditorDataServicesConnectorServiceDefinitionDTO: + editorServiceId, editorServiceIdOk = t.GetIdOk() + editorServiceName, editorServiceNameOk = t.GetFullNameOk() + case *authorize.AuthorizeEditorDataServicesHttpServiceDefinitionDTO: + editorServiceId, editorServiceIdOk = t.GetIdOk() + editorServiceName, editorServiceNameOk = t.GetFullNameOk() + case *authorize.AuthorizeEditorDataServicesNoneServiceDefinitionDTO: + editorServiceId, editorServiceIdOk = t.GetIdOk() + editorServiceName, editorServiceNameOk = t.GetFullNameOk() + default: + continue + } + + if editorServiceIdOk && editorServiceNameOk { + editorServiceData[*editorServiceId] = *editorServiceName + } + } + + return editorServiceData, nil +} + +func (r *PingoneAuthorizeTrustFrameworkServiceResource) ResourceType() string { + return "pingone_authorize_trust_framework_service" +} 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..639bdd43 --- /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/pingcli/internal/connector" + "github.com/pingidentity/pingcli/internal/connector/pingone/authorize/resources" + "github.com/pingidentity/pingcli/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) +}