This is an automated email from the ASF dual-hosted git repository.

klesh pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-devlake.git


The following commit(s) were added to refs/heads/main by this push:
     new 8d7b9e844 [feat-4864]: Backend support for project deletion (#5289)
8d7b9e844 is described below

commit 8d7b9e844805500fe20478790e3da2e0bf3f8ef9
Author: Keon Amini <[email protected]>
AuthorDate: Fri May 26 04:54:46 2023 -0500

    [feat-4864]: Backend support for project deletion (#5289)
    
    * feat: Backend support for project deletion
    
    * refactor: remove get projs by bp API because it's unnecessary
    
    * refactor: restore bp manager
    
    * fix: remove associated blueprint after project is deleted
    
    * fix: added missing blueprint label deletion logic
---
 .../pluginhelper/api/scope_generic_helper.go       |  9 ++-
 backend/helpers/pluginhelper/api/scope_helper.go   |  6 --
 .../pluginhelper/services/blueprint_helper.go      | 32 +++++----
 backend/server/api/project/project.go              | 22 +++++-
 backend/server/api/router.go                       |  2 +-
 backend/server/services/project.go                 | 80 +++++++++++++++++++---
 6 files changed, 117 insertions(+), 34 deletions(-)

diff --git a/backend/helpers/pluginhelper/api/scope_generic_helper.go 
b/backend/helpers/pluginhelper/api/scope_generic_helper.go
index ede430882..6d094fca8 100644
--- a/backend/helpers/pluginhelper/api/scope_generic_helper.go
+++ b/backend/helpers/pluginhelper/api/scope_generic_helper.go
@@ -55,6 +55,11 @@ type (
                connHelper       *ConnectionApiHelper
                opts             *ScopeHelperOptions
        }
+       ScopeRes[T any] struct {
+               Scope                  T                   
`mapstructure:",squash"`
+               TransformationRuleName string              
`mapstructure:"transformationRuleName,omitempty"`
+               Blueprints             []*models.Blueprint 
`mapstructure:"blueprints,omitempty"`
+       }
        ReflectionParameters struct {
                ScopeIdFieldName  string
                ScopeIdColumnName string
@@ -256,17 +261,15 @@ func (c *GenericScopeApiHelper[Conn, Scope, Tr]) 
GetScope(input *plugin.ApiResou
                return nil, errors.Default.Wrap(err, fmt.Sprintf("error 
associating transformation with scope %s", params.scopeId))
        }
        scopeRes := apiScopes[0]
-       var blueprints []*models.Blueprint
        if params.loadBlueprints {
                blueprintMap, err := 
c.bpManager.GetBlueprintsByScopes(params.connectionId, params.scopeId)
                if err != nil {
                        return nil, errors.Default.Wrap(err, fmt.Sprintf("error 
getting blueprints for scope with scope ID %s", params.scopeId))
                }
                if len(blueprintMap) == 1 {
-                       blueprints = blueprintMap[params.scopeId]
+                       scopeRes.Blueprints = blueprintMap[params.scopeId]
                }
        }
-       scopeRes.Blueprints = blueprints
        return scopeRes, nil
 }
 
diff --git a/backend/helpers/pluginhelper/api/scope_helper.go 
b/backend/helpers/pluginhelper/api/scope_helper.go
index c95284dda..d5f79a7d5 100644
--- a/backend/helpers/pluginhelper/api/scope_helper.go
+++ b/backend/helpers/pluginhelper/api/scope_helper.go
@@ -20,7 +20,6 @@ package api
 import (
        "github.com/apache/incubator-devlake/core/context"
        "github.com/apache/incubator-devlake/core/errors"
-       "github.com/apache/incubator-devlake/core/models"
        "github.com/apache/incubator-devlake/core/plugin"
        "github.com/go-playground/validator/v10"
        "net/http"
@@ -31,11 +30,6 @@ type (
        ScopeApiHelper[Conn any, Scope any, Tr any] struct {
                *GenericScopeApiHelper[Conn, Scope, Tr]
        }
-       ScopeRes[T any] struct {
-               Scope                  T                   
`mapstructure:",squash"`
-               TransformationRuleName string              
`mapstructure:"transformationRuleName,omitempty"`
-               Blueprints             []*models.Blueprint 
`mapstructure:"blueprints,omitempty"`
-       }
        ScopeReq[T any] struct {
                Data []*T `json:"data"`
        }
diff --git a/backend/helpers/pluginhelper/services/blueprint_helper.go 
b/backend/helpers/pluginhelper/services/blueprint_helper.go
index 554bdc53d..e01b9354e 100644
--- a/backend/helpers/pluginhelper/services/blueprint_helper.go
+++ b/backend/helpers/pluginhelper/services/blueprint_helper.go
@@ -23,7 +23,7 @@ import (
        "github.com/apache/incubator-devlake/core/errors"
        "github.com/apache/incubator-devlake/core/models"
        "github.com/apache/incubator-devlake/core/models/common"
-       "github.com/apache/incubator-devlake/core/plugin"
+       "github.com/apache/incubator-devlake/impls/logruslog"
 )
 
 type BlueprintManager struct {
@@ -166,15 +166,6 @@ func (b *BlueprintManager) 
GetBlueprintsByScopes(connectionId uint64, scopeIds .
        return scopeMap, nil
 }
 
-// GetBlueprintConnections returns the connections associated with this 
blueprint Id
-func (b *BlueprintManager) GetBlueprintConnections(blueprintId uint64) 
([]*plugin.BlueprintConnectionV200, errors.Error) {
-       bp, err := b.GetDbBlueprint(blueprintId)
-       if err != nil {
-               return nil, err
-       }
-       return bp.GetConnections()
-}
-
 // GetDbBlueprintByProjectName returns the detail of a given projectName
 func (b *BlueprintManager) GetDbBlueprintByProjectName(projectName string) 
(*models.Blueprint, errors.Error) {
        dbBlueprint := &models.Blueprint{}
@@ -194,12 +185,29 @@ func (b *BlueprintManager) 
GetDbBlueprintByProjectName(projectName string) (*mod
 
 // DeleteBlueprint deletes a blueprint by its id
 func (b *BlueprintManager) DeleteBlueprint(id uint64) errors.Error {
-       dbBlueprint := &models.Blueprint{
+       var err errors.Error
+       tx := b.db.Begin()
+       defer func() {
+               if r := recover(); r != nil || err != nil {
+                       err = tx.Rollback()
+                       if err != nil {
+                               logruslog.Global.Error(err, "DeleteBlueprint: 
failed to rollback")
+                       }
+               }
+       }()
+       err = tx.Delete(&models.DbBlueprintLabel{}, dal.Where("blueprint_id = 
?", id))
+       if err != nil {
+               return err
+       }
+       err = tx.Delete(&models.Blueprint{
                Model: common.Model{
                        ID: id,
                },
+       })
+       if err != nil {
+               return err
        }
-       return b.db.Delete(&dbBlueprint)
+       return tx.Commit()
 }
 
 func (b *BlueprintManager) fillBlueprintDetail(blueprint *models.Blueprint) 
errors.Error {
diff --git a/backend/server/api/project/project.go 
b/backend/server/api/project/project.go
index c616ffcb0..a94c0d58d 100644
--- a/backend/server/api/project/project.go
+++ b/backend/server/api/project/project.go
@@ -99,7 +99,7 @@ func PostProject(c *gin.Context) {
 
        projectOutput, err := services.CreateProject(projectInput)
        if err != nil {
-               shared.ApiOutputError(c, errors.BadInput.Wrap(err, "error 
creating project"))
+               shared.ApiOutputError(c, errors.Default.Wrap(err, "error 
creating project"))
                return
        }
 
@@ -127,9 +127,27 @@ func PatchProject(c *gin.Context) {
 
        projectOutput, err := services.PatchProject(projectName, body)
        if err != nil {
-               shared.ApiOutputError(c, errors.BadInput.Wrap(err, "error patch 
project"))
+               shared.ApiOutputError(c, errors.Default.Wrap(err, "error patch 
project"))
                return
        }
 
        shared.ApiOutputSuccess(c, projectOutput, http.StatusCreated)
 }
+
+// @Summary Delete a project
+// @Description Delete a project
+// @Tags framework/projects
+// @Accept application/json
+// @Success 200
+// @Failure 400  {string} errcode.Error "Bad Request"
+// @Failure 500  {string} errcode.Error "Internal Error"
+// @Router /projects/:projectName [delete]
+func DeleteProject(c *gin.Context) {
+       projectName := c.Param("projectName")[1:]
+       err := services.DeleteProject(projectName)
+       if err != nil {
+               shared.ApiOutputError(c, errors.Default.Wrap(err, "error 
deleting project"))
+               return
+       }
+       shared.ApiOutputSuccess(c, nil, http.StatusOK)
+}
diff --git a/backend/server/api/router.go b/backend/server/api/router.go
index 217c7306b..55ccba612 100644
--- a/backend/server/api/router.go
+++ b/backend/server/api/router.go
@@ -67,7 +67,7 @@ func RegisterRouter(r *gin.Engine) {
        // project api
        r.GET("/projects/*projectName", project.GetProject)
        r.PATCH("/projects/*projectName", project.PatchProject)
-       //r.DELETE("/projects/:projectName", project.DeleteProject)
+       r.DELETE("/projects/*projectName", project.DeleteProject)
        r.POST("/projects", project.PostProject)
        r.GET("/projects", project.GetProjects)
 
diff --git a/backend/server/services/project.go 
b/backend/server/services/project.go
index 64188e7ca..5635464e2 100644
--- a/backend/server/services/project.go
+++ b/backend/server/services/project.go
@@ -113,17 +113,11 @@ func GetProject(name string) (*models.ApiOutputProject, 
errors.Error) {
        if name == "" {
                return nil, errors.BadInput.New("project name is missing")
        }
-
        // load project
-       project := &models.Project{}
-       err := db.First(project, dal.Where("name = ?", name))
+       project, err := getProjectByName(db, name)
        if err != nil {
-               if db.IsErrorNotFound(err) {
-                       return nil, errors.NotFound.Wrap(err, 
fmt.Sprintf("could not find project [%s] in DB", name))
-               }
-               return nil, errors.Default.Wrap(err, "error getting project 
from DB")
+               return nil, err
        }
-
        // convert to api output
        return makeProjectOutput(&project.BaseProject)
 }
@@ -149,8 +143,7 @@ func PatchProject(name string, body map[string]interface{}) 
(*models.ApiOutputPr
                }
        }()
 
-       project := &models.Project{}
-       err = tx.First(project, dal.Where("name = ?", name), dal.Lock(true, 
false))
+       project, err := getProjectByName(tx, name, dal.Lock(true, false))
        if err != nil {
                return nil, err
        }
@@ -254,6 +247,73 @@ func PatchProject(name string, body 
map[string]interface{}) (*models.ApiOutputPr
        return makeProjectOutput(&projectInput.BaseProject)
 }
 
+// DeleteProject FIXME ...
+func DeleteProject(name string) errors.Error {
+       // verify input
+       if name == "" {
+               return errors.BadInput.New("project name is missing")
+       }
+       var err errors.Error
+       tx := db.Begin()
+       defer func() {
+               if r := recover(); r != nil || err != nil {
+                       err = tx.Rollback()
+                       if err != nil {
+                               logger.Error(err, "DeleteProject: failed to 
rollback")
+                       }
+               }
+       }()
+       _, err = getProjectByName(tx, name)
+       if err != nil {
+               return err
+       }
+       err = tx.Delete(&models.Project{}, dal.Where("name = ?", name))
+       if err != nil {
+               return err
+       }
+       err = tx.Delete(&crossdomain.ProjectMapping{}, dal.Where("project_name 
= ?", name))
+       if err != nil {
+               return err
+       }
+       err = tx.Delete(&models.ProjectMetricSetting{}, dal.Where("project_name 
= ?", name))
+       if err != nil {
+               return err
+       }
+       err = tx.Delete(&crossdomain.ProjectPrMetric{}, dal.Where("project_name 
= ?", name))
+       if err != nil {
+               return err
+       }
+       err = tx.Delete(&crossdomain.ProjectIssueMetric{}, 
dal.Where("project_name = ?", name))
+       if err != nil {
+               return err
+       }
+       err = tx.Commit()
+       if err != nil {
+               return err
+       }
+       bp, err := bpManager.GetDbBlueprintByProjectName(name)
+       if err != nil {
+               return err
+       }
+       err = bpManager.DeleteBlueprint(bp.ID)
+       if err != nil {
+               return err
+       }
+       return nil
+}
+
+func getProjectByName(tx dal.Dal, name string, additionalClauses 
...dal.Clause) (*models.Project, errors.Error) {
+       project := &models.Project{}
+       err := tx.First(project, append([]dal.Clause{dal.Where("name = ?", 
name)}, additionalClauses...)...)
+       if err != nil {
+               if tx.IsErrorNotFound(err) {
+                       return nil, errors.NotFound.Wrap(err, 
fmt.Sprintf("could not find project [%s] in DB", name))
+               }
+               return nil, errors.Default.Wrap(err, "error getting project 
from DB")
+       }
+       return project, nil
+}
+
 func refreshProjectMetrics(tx dal.Transaction, projectInput 
*models.ApiInputProject) errors.Error {
        err := tx.Delete(&models.ProjectMetricSetting{}, 
dal.Where("project_name = ?", projectInput.Name))
        if err != nil {

Reply via email to