ocdp-go/backend/internal/adapter/input/http/dto/converter.go

package dto

import (
	"time"

	"github.com/ocdp/cluster-service/internal/domain/entity"
	"github.com/ocdp/cluster-service/internal/pkg/crypto"
)

// ToRegistryResponse 转换 Registry 实体为响应 DTO（脱敏）
func ToRegistryResponse(registry *entity.Registry) *RegistryResponse {
	response := &RegistryResponse{
		ID:           registry.ID,
		WorkspaceID:  registry.WorkspaceID,
		OwnerID:      registry.OwnerID,
		Name:         registry.Name,
		URL:          registry.URL,
		Description:  registry.Description,
		Username:     registry.Username,
		Insecure:     registry.Insecure,
		IsShared:     registry.IsShared,
		CreatedAt:    registry.CreatedAt.Format("2006-01-02T15:04:05Z07:00"),
		UpdatedAt:    registry.UpdatedAt.Format("2006-01-02T15:04:05Z07:00"),
	}

	// 脱敏处理密码
	if registry.Password != "" {
		response.HasPassword = true
		response.Password = crypto.MaskSensitiveData(registry.Password)
	}

	return response
}

// ToClusterResponse 转换 Cluster 实体为响应 DTO（脱敏）
func ToClusterResponse(cluster *entity.Cluster) *ClusterResponse {
	response := &ClusterResponse{
		ID:               cluster.ID,
		WorkspaceID:      cluster.WorkspaceID,
		OwnerID:          cluster.OwnerID,
		Name:             cluster.Name,
		Host:             cluster.Host,
		Description:      cluster.Description,
		IsolationMode:    string(cluster.IsolationMode),
		DefaultNamespace: cluster.DefaultNamespace,
		IsShared:         cluster.IsShared,
		CreatedAt:        cluster.CreatedAt.Format("2006-01-02T15:04:05Z07:00"),
		UpdatedAt:        cluster.UpdatedAt.Format("2006-01-02T15:04:05Z07:00"),
	}

	// 设置认证配置状态标志
	response.HasCAData = cluster.CAData != ""
	response.HasCertData = cluster.CertData != ""
	response.HasKeyData = cluster.KeyData != ""
	response.HasToken = cluster.Token != ""

	// 脱敏处理敏感数据（仅显示掩码）
	if cluster.CAData != "" {
		response.CAData = crypto.MaskSensitiveData(cluster.CAData)
	}
	if cluster.CertData != "" {
		response.CertData = crypto.MaskSensitiveData(cluster.CertData)
	}
	if cluster.KeyData != "" {
		response.KeyData = crypto.MaskSensitiveData(cluster.KeyData)
	}
	if cluster.Token != "" {
		response.Token = crypto.MaskSensitiveData(cluster.Token)
	}

	return response
}

// WorkspaceDTOFromEntity 转换 Workspace 实体为 DTO
func WorkspaceDTOFromEntity(workspace *entity.Workspace) *WorkspaceDTO {
	return &WorkspaceDTO{
		ID:          workspace.ID,
		Name:        workspace.Name,
		ClusterIDs:  workspace.ClusterIDs,
		Description: workspace.Description,
		CreatedBy:   workspace.CreatedBy,
		CreatedAt:   workspace.CreatedAt,
		UpdatedAt:   workspace.UpdatedAt,
	}
}

// WorkspaceDTOsFromEntities 批量转换
func WorkspaceDTOsFromEntities(workspaces []*entity.Workspace) []*WorkspaceDTO {
	result := make([]*WorkspaceDTO, len(workspaces))
	for i, w := range workspaces {
		result[i] = WorkspaceDTOFromEntity(w)
	}
	return result
}

// QuotaDTOFromEntity 转换 Quota 实体为 DTO
func QuotaDTOFromEntity(quota *entity.WorkspaceQuota) *QuotaDTO {
	return &QuotaDTO{
		ID:           quota.ID,
		WorkspaceID:  quota.WorkspaceID,
		ResourceType: string(quota.ResourceType),
		HardLimit:    quota.HardLimit,
		SoftLimit:    quota.SoftLimit,
		Used:         quota.Used,
	}
}

// QuotaDTOsFromEntities 批量转换
func QuotaDTOsFromEntities(quotas []*entity.WorkspaceQuota) []*QuotaDTO {
	result := make([]*QuotaDTO, len(quotas))
	for i, q := range quotas {
		result[i] = QuotaDTOFromEntity(q)
	}
	return result
}

// UserDTOFromEntity 转换 User 实体为 DTO
func UserDTOFromEntity(user *entity.User, workspaceName string) *UserDTO {
	return &UserDTO{
		ID:                 user.ID,
		Username:           user.Username,
		Email:              user.Email,
		Role:               string(user.Role),
		WorkspaceID:        user.WorkspaceID,
		WorkspaceName:      workspaceName,
		IsActive:           user.IsActive,
		MustChangePassword: user.MustChangePassword,
		CreatedAt:          user.CreatedAt,
		UpdatedAt:          user.UpdatedAt,
	}
}

// UserDTOsFromEntities 批量转换
func UserDTOsFromEntities(users []*entity.User, workspaceNames map[string]string) []*UserDTO {
	result := make([]*UserDTO, len(users))
	for i, u := range users {
		workspaceName := ""
		if u.WorkspaceID != "" {
			workspaceName = workspaceNames[u.WorkspaceID]
		}
		result[i] = UserDTOFromEntity(u, workspaceName)
	}
	return result
}

// TimeToString 转换时间
func TimeToString(t time.Time) string {
	if t.IsZero() {
		return ""
	}
	return t.Format("2006-01-02T15:04:05Z07:00")
}