PDI-1814: Add PingFederate Resource Exports

internal/connector/pingfederate/pingfederate_connector.go

@@ -61,8 +61,13 @@ func (c *PingFederateConnector) Export(format, outputDir string, overwriteExport
 		resources.IDPAdapter(&c.clientInfo),
 		resources.IDPSPConnection(&c.clientInfo),
 		resources.IdpStsRequestParametersContract(&c.clientInfo),
+		resources.IdpTokenProcessor(&c.clientInfo),
+		resources.IdpToSpAdapterMapping(&c.clientInfo),
 		resources.IncomingProxySettings(&c.clientInfo),
 		resources.KerberosRealm(&c.clientInfo),
+		resources.KerberosRealmSettings(&c.clientInfo),
+		resources.KeypairsOauthOpenidConnect(&c.clientInfo),
+		resources.KeypairsOauthOpenidConnectAdditionalKeySet(&c.clientInfo),
 		resources.LocalIdentityProfile(&c.clientInfo),
 		resources.NotificationPublisherSettings(&c.clientInfo),
 		resources.OAuthAccessTokenManager(&c.clientInfo),

internal/connector/pingfederate/pingfederate_connector_test.go

@@ -130,6 +130,16 @@ func TestPingFederateTerraformPlan(t *testing.T) {
 			resource:      resources.IdpStsRequestParametersContract(PingFederateClientInfo),
 			ignoredErrors: nil,
 		},
+		{
+			name:          "PingFederateIdpTokenProcessor",
+			resource:      resources.IdpTokenProcessor(PingFederateClientInfo),
+			ignoredErrors: nil,
+		},
+		{
+			name:          "PingFederateIdpToSpAdapterMapping",
+			resource:      resources.IdpToSpAdapterMapping(PingFederateClientInfo),
+			ignoredErrors: nil,
+		},
 		{
 			name:          "PingFederateIncomingProxySettings",
 			resource:      resources.IncomingProxySettings(PingFederateClientInfo),
@@ -140,6 +150,21 @@ func TestPingFederateTerraformPlan(t *testing.T) {
 			resource:      resources.KerberosRealm(PingFederateClientInfo),
 			ignoredErrors: nil,
 		},
+		{
+			name:          "PingFederateKerberosRealmSettings",
+			resource:      resources.KerberosRealmSettings(PingFederateClientInfo),
+			ignoredErrors: nil,
+		},
+		{
+			name:          "PingFederateKeypairsOauthOpenidConnect",
+			resource:      resources.KeypairsOauthOpenidConnect(PingFederateClientInfo),
+			ignoredErrors: nil,
+		},
+		{
+			name:          "PingFederateKeypairsOauthOpenidConnectAdditionalKeySet",
+			resource:      resources.KeypairsOauthOpenidConnectAdditionalKeySet(PingFederateClientInfo),
+			ignoredErrors: nil,
+		},
 		{
 			name:          "PingFederateLocalIdentityProfile",
 			resource:      resources.LocalIdentityProfile(PingFederateClientInfo),

internal/connector/pingfederate/resources/pingfederate_idp_to_sp_adapter_mapping.go

@@ -0,0 +1,90 @@
+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 = &PingFederateIdpToSpAdapterMappingResource{}
+)
+
+type PingFederateIdpToSpAdapterMappingResource struct {
+	clientInfo *connector.PingFederateClientInfo
+}
+
+// Utility method for creating a PingFederateIdpToSpAdapterMappingResource
+func IdpToSpAdapterMapping(clientInfo *connector.PingFederateClientInfo) *PingFederateIdpToSpAdapterMappingResource {
+	return &PingFederateIdpToSpAdapterMappingResource{
+		clientInfo: clientInfo,
+	}
+}
+
+func (r *PingFederateIdpToSpAdapterMappingResource) ResourceType() string {
+	return "pingfederate_idp_to_sp_adapter_mapping"
+}
+
+func (r *PingFederateIdpToSpAdapterMappingResource) ExportAll() (*[]connector.ImportBlock, error) {
+	l := logger.Get()
+	l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType())
+
+	importBlocks := []connector.ImportBlock{}
+
+	idpToSpAdapterMappingData, err := r.getIdpToSpAdapterMappingData()
+	if err != nil {
+		return nil, err
+	}
+
+	for idpToSpAdapterMappingSourceId, idpToSpAdapterMappingTargetId := range *idpToSpAdapterMappingData {
+		commentData := map[string]string{
+			"IDP To SP Adapter Mapping IDP ID": idpToSpAdapterMappingSourceId,
+			"IDP To SP Adapter Mapping SP ID":  idpToSpAdapterMappingTargetId,
+			"Resource Type":                    r.ResourceType(),
+		}
+
+		importBlock := connector.ImportBlock{
+			ResourceType:       r.ResourceType(),
+			ResourceName:       fmt.Sprintf("%s_to_%s", idpToSpAdapterMappingSourceId, idpToSpAdapterMappingTargetId),
+			ResourceID:         fmt.Sprintf("%s|%s", idpToSpAdapterMappingSourceId, idpToSpAdapterMappingTargetId),
+			CommentInformation: common.GenerateCommentInformation(commentData),
+		}
+
+		importBlocks = append(importBlocks, importBlock)
+	}
+
+	return &importBlocks, nil
+}
+
+func (r *PingFederateIdpToSpAdapterMappingResource) getIdpToSpAdapterMappingData() (*map[string]string, error) {
+	idpToSpAdapterMappingData := make(map[string]string)
+
+	idpToSpAdapterMappings, response, err := r.clientInfo.ApiClient.IdpToSpAdapterMappingAPI.GetIdpToSpAdapterMappings(r.clientInfo.Context).Execute()
+	err = common.HandleClientResponse(response, err, "GetIdpToSpAdapterMappings", r.ResourceType())
+	if err != nil {
+		return nil, err
+	}
+
+	if idpToSpAdapterMappings == nil {
+		return nil, common.DataNilError(r.ResourceType(), response)
+	}
+
+	idpToSpAdapterMappingsItems, idpToSpAdapterMappingsItemsOk := idpToSpAdapterMappings.GetItemsOk()
+	if !idpToSpAdapterMappingsItemsOk {
+		return nil, common.DataNilError(r.ResourceType(), response)
+	}
+
+	for _, idpToSpAdapterMapping := range idpToSpAdapterMappingsItems {
+		idpToSpAdapterMappingSourceId, idpToSpAdapterMappingSourceIdOk := idpToSpAdapterMapping.GetSourceIdOk()
+		idpToSpAdapterMappingTargetId, idpToSpAdapterMappingTargetIdOk := idpToSpAdapterMapping.GetTargetIdOk()
+
+		if idpToSpAdapterMappingSourceIdOk && idpToSpAdapterMappingTargetIdOk {
+			idpToSpAdapterMappingData[*idpToSpAdapterMappingSourceId] = *idpToSpAdapterMappingTargetId
+		}
+	}
+
+	return &idpToSpAdapterMappingData, nil
+}

internal/connector/pingfederate/resources/pingfederate_idp_to_sp_adapter_mapping_test.go

@@ -0,0 +1,26 @@
+package resources_test
+
+import (
+	"testing"
+
+	"github.com/pingidentity/pingcli/internal/connector"
+	"github.com/pingidentity/pingcli/internal/connector/pingfederate/resources"
+	"github.com/pingidentity/pingcli/internal/testing/testutils"
+)
+
+func TestPingFederateIdpToSpAdapterMappingExport(t *testing.T) {
+	// Get initialized apiClient and resource
+	PingFederateClientInfo := testutils.GetPingFederateClientInfo(t)
+	resource := resources.IdpToSpAdapterMapping(PingFederateClientInfo)
+
+	// Defined the expected ImportBlocks for the resource
+	expectedImportBlocks := []connector.ImportBlock{
+		{
+			ResourceType: "pingfederate_idp_to_sp_adapter_mapping",
+			ResourceName: "ciamHtmlForm_to_spadapter",
+			ResourceID:   "ciamHtmlForm|spadapter",
+		},
+	}
+
+	testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks)
+}

internal/connector/pingfederate/resources/pingfederate_idp_token_processor.go

@@ -0,0 +1,88 @@
+package resources
+
+import (
+	"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 = &PingFederateIdpTokenProcessorResource{}
+)
+
+type PingFederateIdpTokenProcessorResource struct {
+	clientInfo *connector.PingFederateClientInfo
+}
+
+// Utility method for creating a PingFederateIdpTokenProcessorResource
+func IdpTokenProcessor(clientInfo *connector.PingFederateClientInfo) *PingFederateIdpTokenProcessorResource {
+	return &PingFederateIdpTokenProcessorResource{
+		clientInfo: clientInfo,
+	}
+}
+
+func (r *PingFederateIdpTokenProcessorResource) ResourceType() string {
+	return "pingfederate_idp_token_processor"
+}
+
+func (r *PingFederateIdpTokenProcessorResource) ExportAll() (*[]connector.ImportBlock, error) {
+	l := logger.Get()
+	l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType())
+
+	importBlocks := []connector.ImportBlock{}
+
+	tokenProcessorData, err := r.getTokenProcessorData()
+	if err != nil {
+		return nil, err
+	}
+
+	for tokenProcessorId, tokenProcessorName := range *tokenProcessorData {
+		commentData := map[string]string{
+			"IDP Token Processor ID":   tokenProcessorId,
+			"IDP Token Processor Name": tokenProcessorName,
+			"Resource Type":            r.ResourceType(),
+		}
+
+		importBlock := connector.ImportBlock{
+			ResourceType:       r.ResourceType(),
+			ResourceName:       tokenProcessorName,
+			ResourceID:         tokenProcessorId,
+			CommentInformation: common.GenerateCommentInformation(commentData),
+		}
+
+		importBlocks = append(importBlocks, importBlock)
+	}
+
+	return &importBlocks, nil
+}
+
+func (r *PingFederateIdpTokenProcessorResource) getTokenProcessorData() (*map[string]string, error) {
+	tokenProcessorData := make(map[string]string)
+
+	tokenProcessors, response, err := r.clientInfo.ApiClient.IdpTokenProcessorsAPI.GetTokenProcessors(r.clientInfo.Context).Execute()
+	err = common.HandleClientResponse(response, err, "GetTokenProcessors", r.ResourceType())
+	if err != nil {
+		return nil, err
+	}
+
+	if tokenProcessors == nil {
+		return nil, common.DataNilError(r.ResourceType(), response)
+	}
+
+	tokenProcessorsItems, tokenProcessorsItemsOk := tokenProcessors.GetItemsOk()
+	if !tokenProcessorsItemsOk {
+		return nil, common.DataNilError(r.ResourceType(), response)
+	}
+
+	for _, tokenProcessor := range tokenProcessorsItems {
+		tokenProcessorId, tokenProcessorIdOk := tokenProcessor.GetIdOk()
+		tokenProcessorName, tokenProcessorNameOk := tokenProcessor.GetNameOk()
+
+		if tokenProcessorIdOk && tokenProcessorNameOk {
+			tokenProcessorData[*tokenProcessorId] = *tokenProcessorName
+		}
+	}
+
+	return &tokenProcessorData, nil
+}

internal/connector/pingfederate/resources/pingfederate_idp_token_processor_test.go

@@ -0,0 +1,31 @@
+package resources_test
+
+import (
+	"testing"
+
+	"github.com/pingidentity/pingcli/internal/connector"
+	"github.com/pingidentity/pingcli/internal/connector/pingfederate/resources"
+	"github.com/pingidentity/pingcli/internal/testing/testutils"
+)
+
+func TestPingFederateIdpTokenProcessorExport(t *testing.T) {
+	// Get initialized apiClient and resource
+	PingFederateClientInfo := testutils.GetPingFederateClientInfo(t)
+	resource := resources.IdpTokenProcessor(PingFederateClientInfo)
+
+	// Defined the expected ImportBlocks for the resource
+	expectedImportBlocks := []connector.ImportBlock{
+		{
+			ResourceType: "pingfederate_idp_token_processor",
+			ResourceName: "UsernameTokenProcessor",
+			ResourceID:   "UsernameTokenProcessor",
+		},
+		{
+			ResourceType: "pingfederate_idp_token_processor",
+			ResourceName: "token processor",
+			ResourceID:   "tokenprocessor",
+		},
+	}
+
+	testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks)
+}

internal/connector/pingfederate/resources/pingfederate_kerberos_realm_settings.go

@@ -0,0 +1,53 @@
+package resources
+
+import (
+	"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 = &PingFederateKerberosRealmSettingsResource{}
+)
+
+type PingFederateKerberosRealmSettingsResource struct {
+	clientInfo *connector.PingFederateClientInfo
+}
+
+// Utility method for creating a PingFederateKerberosRealmSettingsResource
+func KerberosRealmSettings(clientInfo *connector.PingFederateClientInfo) *PingFederateKerberosRealmSettingsResource {
+	return &PingFederateKerberosRealmSettingsResource{
+		clientInfo: clientInfo,
+	}
+}
+
+func (r *PingFederateKerberosRealmSettingsResource) ResourceType() string {
+	return "pingfederate_kerberos_realm_settings"
+}
+
+func (r *PingFederateKerberosRealmSettingsResource) ExportAll() (*[]connector.ImportBlock, error) {
+	l := logger.Get()
+	l.Debug().Msgf("Exporting all '%s' Resources...", r.ResourceType())
+
+	importBlocks := []connector.ImportBlock{}
+
+	kerberosRealmSettingsId := "kerberos_realm_settings_singleton_id"
+	kerberosRealmSettingsName := "Kerberos Realm Settings"
+
+	commentData := map[string]string{
+		"Resource Type": r.ResourceType(),
+		"Singleton ID":  common.SINGLETON_ID_COMMENT_DATA,
+	}
+
+	importBlock := connector.ImportBlock{
+		ResourceType:       r.ResourceType(),
+		ResourceName:       kerberosRealmSettingsName,
+		ResourceID:         kerberosRealmSettingsId,
+		CommentInformation: common.GenerateCommentInformation(commentData),
+	}
+
+	importBlocks = append(importBlocks, importBlock)
+
+	return &importBlocks, nil
+}

internal/connector/pingfederate/resources/pingfederate_kerberos_realm_settings_test.go

@@ -0,0 +1,26 @@
+package resources_test
+
+import (
+	"testing"
+
+	"github.com/pingidentity/pingcli/internal/connector"
+	"github.com/pingidentity/pingcli/internal/connector/pingfederate/resources"
+	"github.com/pingidentity/pingcli/internal/testing/testutils"
+)
+
+func TestPingFederateKerberosRealmSettingsExport(t *testing.T) {
+	// Get initialized apiClient and resource
+	PingFederateClientInfo := testutils.GetPingFederateClientInfo(t)
+	resource := resources.KerberosRealmSettings(PingFederateClientInfo)
+
+	// Defined the expected ImportBlocks for the resource
+	expectedImportBlocks := []connector.ImportBlock{
+		{
+			ResourceType: "pingfederate_kerberos_realm_settings",
+			ResourceName: "Kerberos Realm Settings",
+			ResourceID:   "kerberos_realm_settings_singleton_id",
+		},
+	}
+
+	testutils.ValidateImportBlocks(t, resource, &expectedImportBlocks)
+}