remove redundant handlers

api/server/handlers/policy/delete.go

@@ -1,58 +0,0 @@
-package policy
-
-import (
-	"net/http"
-
-	"github.com/porter-dev/porter/api/server/handlers"
-	"github.com/porter-dev/porter/api/server/shared"
-	"github.com/porter-dev/porter/api/server/shared/apierrors"
-	"github.com/porter-dev/porter/api/server/shared/config"
-	"github.com/porter-dev/porter/api/server/shared/requestutils"
-	"github.com/porter-dev/porter/api/types"
-	"github.com/porter-dev/porter/internal/models"
-)
-
-type PolicyDeleteHandler struct {
-	handlers.PorterHandlerReadWriter
-}
-
-func NewPolicyDeleteHandler(
-	config *config.Config,
-	decoderValidator shared.RequestDecoderValidator,
-	writer shared.ResultWriter,
-) *PolicyDeleteHandler {
-	return &PolicyDeleteHandler{
-		PorterHandlerReadWriter: handlers.NewDefaultPorterHandler(config, decoderValidator, writer),
-	}
-}
-
-func (p *PolicyDeleteHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	proj, _ := r.Context().Value(types.ProjectScope).(*models.Project)
-
-	policyID, reqErr := requestutils.GetURLParamString(r, types.URLParamPolicyID)
-
-	if reqErr != nil {
-		p.HandleAPIError(w, r, reqErr)
-		return
-	}
-
-	policy, err := p.Repo().Policy().ReadPolicy(proj.ID, policyID)
-
-	if err == nil {
-		policy, err = p.Repo().Policy().DeletePolicy(policy)
-
-		if err != nil {
-			p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
-			return
-		}
-	}
-
-	res, err := policy.ToAPIPolicyType()
-
-	if err != nil {
-		p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
-		return
-	}
-
-	p.WriteResult(w, r, res)
-}

api/server/handlers/policy/update.go

@@ -1,91 +0,0 @@
-package policy
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-
-	"github.com/porter-dev/porter/api/server/handlers"
-	"github.com/porter-dev/porter/api/server/shared"
-	"github.com/porter-dev/porter/api/server/shared/apierrors"
-	"github.com/porter-dev/porter/api/server/shared/config"
-	"github.com/porter-dev/porter/api/server/shared/requestutils"
-	"github.com/porter-dev/porter/api/types"
-	"github.com/porter-dev/porter/internal/models"
-	"gorm.io/gorm"
-)
-
-type PolicyUpdateHandler struct {
-	handlers.PorterHandlerReadWriter
-}
-
-func NewPolicyUpdateHandler(
-	config *config.Config,
-	decoderValidator shared.RequestDecoderValidator,
-	writer shared.ResultWriter,
-) *PolicyUpdateHandler {
-	return &PolicyUpdateHandler{
-		PorterHandlerReadWriter: handlers.NewDefaultPorterHandler(config, decoderValidator, writer),
-	}
-}
-
-func (p *PolicyUpdateHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	proj, _ := r.Context().Value(types.ProjectScope).(*models.Project)
-
-	policyID, reqErr := requestutils.GetURLParamString(r, types.URLParamPolicyID)
-
-	if reqErr != nil {
-		p.HandleAPIError(w, r, reqErr)
-		return
-	}
-
-	req := &types.UpdatePolicyRequest{}
-
-	if ok := p.DecodeAndValidate(w, r, req); !ok {
-		return
-	}
-
-	policy, err := p.Repo().Policy().ReadPolicy(proj.ID, policyID)
-
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			p.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(
-				fmt.Errorf("policy with id %s not found in project", policyID),
-				http.StatusNotFound,
-			))
-			return
-		}
-
-		p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
-		return
-	}
-
-	policyBytes, err := json.Marshal(req.Policy)
-
-	if err != nil {
-		p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
-		return
-	}
-
-	if !bytes.Equal(policyBytes, policy.PolicyBytes) {
-		policy.PolicyBytes = policyBytes
-
-		policy, err = p.Repo().Policy().UpdatePolicy(policy)
-
-		if err != nil {
-			p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
-			return
-		}
-	}
-
-	res, err := policy.ToAPIPolicyType()
-
-	if err != nil {
-		p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
-		return
-	}
-
-	p.WriteResult(w, r, res)
-}

api/server/router/project.go

@@ -1035,64 +1035,6 @@ func getProjectRoutes(
 		Router:   r,
 	})
 
-	// PATCH /api/projects/{project_id}/policies/{policy_id} -> policy.NewPolicyUpdateHandler
-	policyUpdateEndpoint := factory.NewAPIEndpoint(
-		&types.APIRequestMetadata{
-			Verb:   types.APIVerbUpdate,
-			Method: types.HTTPVerbPatch,
-			Path: &types.Path{
-				Parent:       basePath,
-				RelativePath: fmt.Sprintf("%s/policies/{%s}", relPath, types.URLParamPolicyID),
-			},
-			Scopes: []types.PermissionScope{
-				types.UserScope,
-				types.ProjectScope,
-				types.SettingsScope,
-			},
-		},
-	)
-
-	policyUpdateHandler := policy.NewPolicyUpdateHandler(
-		config,
-		factory.GetDecoderValidator(),
-		factory.GetResultWriter(),
-	)
-
-	routes = append(routes, &router.Route{
-		Endpoint: policyUpdateEndpoint,
-		Handler:  policyUpdateHandler,
-		Router:   r,
-	})
-
-	// DELETE /api/projects/{project_id}/policies/{policy_id} -> policy.NewPolicyDeleteHandler
-	policyDeleteEndpoint := factory.NewAPIEndpoint(
-		&types.APIRequestMetadata{
-			Verb:   types.APIVerbDelete,
-			Method: types.HTTPVerbDelete,
-			Path: &types.Path{
-				Parent:       basePath,
-				RelativePath: fmt.Sprintf("%s/policies/{%s}", relPath, types.URLParamPolicyID),
-			},
-			Scopes: []types.PermissionScope{
-				types.UserScope,
-				types.ProjectScope,
-				types.SettingsScope,
-			},
-		},
-	)
-
-	policyDeleteHandler := policy.NewPolicyDeleteHandler(
-		config,
-		factory.GetDecoderValidator(),
-		factory.GetResultWriter(),
-	)
-
-	routes = append(routes, &router.Route{
-		Endpoint: policyDeleteEndpoint,
-		Handler:  policyDeleteHandler,
-		Router:   r,
-	})
-
 	//  POST /api/projects/{project_id}/api_token -> api_token.NewAPITokenCreateHandler
 	apiTokenCreateEndpoint := factory.NewAPIEndpoint(
 		&types.APIRequestMetadata{

cmd/migrate/main.go

@@ -79,9 +79,9 @@ func main() {
 		}
 	}
 
-	if err := InstanceMigrate(db, envConf.DBConf); err != nil {
-		logger.Fatal().Err(err).Msg("vault migration failed")
-	}
+	// if err := InstanceMigrate(db, envConf.DBConf); err != nil {
+	// 	logger.Fatal().Err(err).Msg("vault migration failed")
+	// }
 }
 
 type RotateConf struct {

cmd/migrate/migrate_legacy_rbac/migrate.go

@@ -18,7 +18,7 @@ import (
 const stepSize = 100
 
 func MigrateFromLegacyRBAC(db *_gorm.DB, logger *lr.Logger) error {
-	logger.Info().Msg("Initiated migration from legacy RBAC")
+	logger.Info().Msg("initiated migration from legacy RBAC")
 
 	var count int64
 
@@ -30,6 +30,8 @@ func MigrateFromLegacyRBAC(db *_gorm.DB, logger *lr.Logger) error {
 	projectRoleRepo := gorm.NewProjectRoleRepository(db).(*gorm.ProjectRoleRepository)
 	policyRepo := gorm.NewPolicyRepository(db).(*gorm.PolicyRepository)
 
+	logger.Info().Msgf("found %d projects", count)
+
 	// iterate (count / stepSize) + 1 times using Limit and Offset
 	for i := 0; i < (int(count)/stepSize)+1; i++ {
 		projects := []*models.Project{}

internal/repository/gorm/policy.go

@@ -17,34 +17,21 @@ func NewPolicyRepository(db *gorm.DB) repository.PolicyRepository {
 	return &PolicyRepository{db}
 }
 
-func (repo *PolicyRepository) CreatePolicy(policy *models.Policy) (*models.Policy, error) {
-	var project models.Project
-
-	if err := repo.db.Where("id = ?", policy.ProjectID).First(&project).Error; err != nil {
-		return nil, err
-	}
-
-	assoc := repo.db.Model(&project).Association("ProjectPolicies")
-
-	if assoc.Error != nil {
-		return nil, assoc.Error
-	}
-
-	if err := assoc.Append(policy); err != nil {
+func (repo *PolicyRepository) CreatePolicy(a *models.Policy) (*models.Policy, error) {
+	if err := repo.db.Create(a).Error; err != nil {
 		return nil, err
 	}
-
-	return policy, nil
+	return a, nil
 }
 
 func (repo *PolicyRepository) ListPoliciesByProjectID(projectID uint) ([]*models.Policy, error) {
-	var policies []*models.Policy
+	policys := []*models.Policy{}
 
-	if err := repo.db.Where("project_id = ?", projectID).Find(&policies).Error; err != nil {
+	if err := repo.db.Where("project_id = ?", projectID).Find(&policys).Error; err != nil {
 		return nil, err
 	}
 
-	return policies, nil
+	return policys, nil
 }
 
 func (repo *PolicyRepository) ReadPolicy(projectID uint, uid string) (*models.Policy, error) {
@@ -70,25 +57,8 @@ func (repo *PolicyRepository) UpdatePolicy(
 func (repo *PolicyRepository) DeletePolicy(
 	policy *models.Policy,
 ) (*models.Policy, error) {
-	var project models.Project
-
-	if err := repo.db.Where("id = ?", policy.ProjectID).First(&project).Error; err != nil {
+	if err := repo.db.Delete(&policy).Error; err != nil {
 		return nil, err
 	}
-
-	assoc := repo.db.Model(&project).Association("ProjectPolicies")
-
-	if assoc.Error != nil {
-		return nil, assoc.Error
-	}
-
-	if err := assoc.Delete(policy); err != nil {
-		return nil, err
-	}
-
-	if err := repo.db.Delete(policy).Error; err != nil {
-		return nil, err
-	}
-
 	return policy, nil
 }