refactor: delete iterations and their sub items together

feat: initialize issueService

feat: add option to delete only iterations or all

feat: add BatchUpdateIssueIterationID

feat: batch deletion of functions and addition of transactions

internal/apps/dop/endpoints/endpoints.go

@@ -33,6 +33,7 @@ import (
 	"github.com/erda-project/erda/bundle"
 	"github.com/erda-project/erda/internal/apps/dop/dao"
 	"github.com/erda-project/erda/internal/apps/dop/event"
+	"github.com/erda-project/erda/internal/apps/dop/providers/issue/core"
 	issuequery "github.com/erda-project/erda/internal/apps/dop/providers/issue/core/query"
 	issuedao "github.com/erda-project/erda/internal/apps/dop/providers/issue/dao"
 	"github.com/erda-project/erda/internal/apps/dop/providers/projectpipeline"
@@ -462,7 +463,7 @@ func (e *Endpoints) Routes() []httpserver.Endpoint {
 
 		{Path: "/api/iterations", Method: http.MethodPost, Handler: e.CreateIteration},
 		{Path: "/api/iterations/{id}", Method: http.MethodPut, Handler: e.UpdateIteration},
-		{Path: "/api/iterations/{id}", Method: http.MethodDelete, Handler: e.DeleteIteration},
+		{Path: "/api/iterations/{id}/{onlyIteration}", Method: http.MethodDelete, Handler: e.DeleteIteration},
 		{Path: "/api/iterations/{id}", Method: http.MethodGet, Handler: e.GetIteration},
 		{Path: "/api/iterations", Method: http.MethodGet, Handler: e.PagingIterations},
 
@@ -630,6 +631,7 @@ type Endpoints struct {
 	namespace       *namespace.Namespace
 	envConfig       *environment.EnvConfig
 	issue           *issue.Issue
+	issueService    core.IssueService
 	issueState      *issuestate.IssueState
 	workBench       *workbench.Workbench
 	iteration       *iteration.Iteration
@@ -895,6 +897,13 @@ func WithIssue(issue *issue.Issue) Option {
 	}
 }
 
+// WithIssueService Configure issueService
+func WithIssueService(issueService *core.IssueService) Option {
+	return func(e *Endpoints) {
+		e.issueService = *issueService
+	}
+}
+
 func WithIssueState(state *issuestate.IssueState) Option {
 	return func(e *Endpoints) {
 		e.issueState = state

internal/apps/dop/endpoints/iteration.go

@@ -25,10 +25,12 @@ import (
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 
+	"github.com/erda-project/erda-proto-go/dop/issue/core/pb"
 	"github.com/erda-project/erda/apistructs"
 	"github.com/erda-project/erda/internal/apps/dop/dao"
 	"github.com/erda-project/erda/internal/apps/dop/services/apierrors"
 	"github.com/erda-project/erda/internal/pkg/user"
+	"github.com/erda-project/erda/pkg/common/apis"
 	"github.com/erda-project/erda/pkg/http/httpserver"
 	"github.com/erda-project/erda/pkg/http/httpserver/errorresp"
 	"github.com/erda-project/erda/pkg/strutil"
@@ -205,6 +207,7 @@ func (e *Endpoints) DeleteIteration(ctx context.Context, r *http.Request, vars m
 	}
 
 	iterationID, err := strconv.ParseUint(vars["id"], 10, 64)
+	onlyIteration, err := strconv.ParseBool(vars["onlyIteration"])
 	if err != nil {
 		return apierrors.ErrDeleteIteration.InvalidParameter("id").ToResp(), nil
 	}
@@ -235,6 +238,31 @@ func (e *Endpoints) DeleteIteration(ctx context.Context, r *http.Request, vars m
 		return errorresp.ErrResp(err)
 	}
 
+	itemIDs, err := e.issueService.DBClient().GetIssuesIDByIterationID(iterationID)
+	if err != nil {
+		return apierrors.ErrDeleteIteration.InternalError(err).ToResp(), nil
+	}
+
+	if len(itemIDs) > 0 {
+		if onlyIteration {
+			err = e.issueService.DBClient().BatchUpdateIssueIterationID(itemIDs, -1)
+			if err != nil {
+				return apierrors.ErrDeleteIteration.InternalError(err).ToResp(), nil
+			}
+			goto come
+		} else {
+			req := &pb.BatchDeleteIssueRequest{
+				Ids:       strutil.ToStrSlice(itemIDs),
+				ProjectID: iteration.ProjectID,
+			}
+			ctx = apis.WithUserIDContext(ctx, identityInfo.UserID)
+			_, err = e.issueService.BatchDeleteIssues(ctx, req)
+			if err != nil {
+				return apierrors.ErrDeleteIteration.InternalError(err).ToResp(), nil
+			}
+		}
+	}
+come:
 	// delete relation labels
 	if err = e.db.DeleteLabelRelations(apistructs.LabelTypeIteration, strconv.FormatUint(iterationID, 10), nil); err != nil {
 		return apierrors.ErrDeleteIteration.InternalError(err).ToResp(), nil

internal/apps/dop/initialize.go

@@ -674,6 +674,7 @@ func (p *provider) initEndpoints(db *dao.DBClient) (*endpoints.Endpoints, error)
 		endpoints.WithNamespace(ns),
 		endpoints.WithEnvConfig(env),
 		endpoints.WithIssue(issue),
+		endpoints.WithIssueService(p.IssueCoreSvc),
 		endpoints.WithIssueState(issueState),
 		endpoints.WithIteration(itr),
 		endpoints.WithPublisher(pub),

internal/apps/dop/providers/issue/core/service.go

@@ -554,16 +554,10 @@ func (i *IssueService) DeleteIssue(ctx context.Context, req *pb.DeleteIssueReque
 // BatchDeleteIssues 批量删除
 func (i *IssueService) BatchDeleteIssues(ctx context.Context, req *pb.BatchDeleteIssueRequest) (*pb.BatchDeleteIssueResponse, error) {
 	numSlice := make([]uint64, len(req.Ids))
-	for i, str := range req.Ids {
-		num, err := strconv.ParseUint(str, 10, 64)
-		if err != nil {
-			return nil, apierrors.ErrBatchDeleteIssue.InvalidParameter(err)
-		}
-		numSlice[i] = num
-	}
 	ids := make([]int64, len(req.Ids))
-	for k, v := range numSlice {
-		ids[k] = int64(v)
+	for i, str := range req.Ids {
+		numSlice[i], _ = strconv.ParseUint(str, 10, 64)
+		ids[i] = int64(numSlice[i])
 	}
 
 	identityInfo := apis.GetIdentityInfo(ctx)
@@ -572,11 +566,13 @@ func (i *IssueService) BatchDeleteIssues(ctx context.Context, req *pb.BatchDelet
 	}
 
 	issues, _, err := i.query.Paging(pb.PagingIssueRequest{IDs: ids, ProjectID: req.ProjectID})
-
 	if err != nil {
 		return nil, err
 	}
 
+	// start transaction
+	tx := i.db.Begin()
+
 	for k, issue := range issues {
 		rels, err := i.GetTestPlanCaseRels(uint64(issue.Id))
 		if err != nil {
@@ -616,25 +612,30 @@ func (i *IssueService) BatchDeleteIssues(ctx context.Context, req *pb.BatchDelet
 		// 删除测试计划用例关联
 		if issue.Type == pb.IssueTypeEnum_BUG {
 			if err := i.db.DeleteIssueTestCaseRelationsByIssueIDs([]uint64{numSlice[k]}); err != nil {
+				tx.Rollback()
 				return nil, apierrors.ErrBatchDeleteIssue.InternalError(err)
 			}
 		}
 	}
 
 	if err := i.db.BatchCleanIssueRelation(numSlice); err != nil {
+		tx.Rollback()
 		return nil, apierrors.ErrBatchDeleteIssue.InternalError(err)
 	}
 
 	if err := i.db.BatchDeletePropertyRelationByIssueID(ids); err != nil {
+		tx.Rollback()
 		return nil, apierrors.ErrBatchDeleteIssue.InternalError(err)
 	}
 
 	// delete issue state transition
 	if err = i.db.BatchDeleteIssuesStateTransition(numSlice); err != nil {
+		tx.Rollback()
 		return nil, apierrors.ErrBatchDeleteIssue.InternalError(err)
 	}
 
 	if err = i.db.BatchDeleteIssues(numSlice); err != nil {
+		tx.Rollback()
 		return nil, err
 	}
 
@@ -643,10 +644,11 @@ func (i *IssueService) BatchDeleteIssues(ctx context.Context, req *pb.BatchDelet
 			ProjectID:  issue.ProjectID,
 			ActiveTime: time.Now(),
 		}); err != nil {
+			tx.Rollback()
 			logrus.Errorf("update project active time err: %v", err)
 		}
 	}
-
+	tx.Commit()
 	return &pb.BatchDeleteIssueResponse{Data: issues}, nil
 }
 

internal/apps/dop/providers/issue/dao/core.go

@@ -161,6 +161,10 @@ func (client *DBClient) UpdateIssues(requirementID uint64, fields map[string]int
 		Updates(fields).Error
 }
 
+func (client *DBClient) BatchUpdateIssueIterationID(ids []uint64, iterationID int64) error {
+	return client.Model(Issue{}).Where("deleted = 0").Where("id IN (?)", ids).Updates(Issue{IterationID: iterationID}).Error
+}
+
 // UpdateIssueType 转换issueType
 func (client *DBClient) UpdateIssueType(issue *Issue) error {
 	return client.Model(Issue{}).Save(issue).Error
@@ -405,6 +409,15 @@ func (client *DBClient) GetIssueWithOutDelete(id int64) (Issue, error) {
 	return issue, err
 }
 
+func (client *DBClient) GetIssuesIDByIterationID(iterationID uint64) (ids []uint64, err error) {
+	var issues []Issue
+	err = client.Model(Issue{}).Where("deleted = 0").Where("iteration_id = ?", iterationID).Select("id").Find(&issues).Error
+	for _, v := range issues {
+		ids = append(ids, v.ID)
+	}
+	return ids, err
+}
+
 func (client *DBClient) ListIssueByIDs(issueIDs []int64) ([]Issue, error) {
 	var issues []Issue
 	if err := client.Where("`id` IN (?)", issueIDs).Find(&issues).Error; err != nil {

internal/apps/dop/services/iteration/iteration.go

@@ -18,7 +18,6 @@ package iteration
 import (
 	"github.com/jinzhu/gorm"
 
-	"github.com/erda-project/erda-proto-go/dop/issue/core/pb"
 	"github.com/erda-project/erda/apistructs"
 	"github.com/erda-project/erda/internal/apps/dop/dao"
 	"github.com/erda-project/erda/internal/apps/dop/providers/issue/core/query"
@@ -159,27 +158,6 @@ func (itr *Iteration) GetByTitle(projectID uint64, title string) (*dao.Iteration
 
 // Delete 删除 iteration
 func (itr *Iteration) Delete(id uint64) error {
-	iteration, err := itr.db.GetIteration(id)
-	if err != nil {
-		return err
-	}
-
-	// 检查 iteration 下是否有需求/任务/bug; 若有，不可删除
-	issueReq := pb.PagingIssueRequest{
-		ProjectID:   iteration.ProjectID,
-		IterationID: int64(id),
-		External:    true,
-		PageNo:      1,
-		PageSize:    1,
-	}
-	issues, _, err := itr.issue.Paging(issueReq)
-	if err != nil {
-		return err
-	}
-	if len(issues) > 0 {
-		return apierrors.ErrDeleteIteration.InvalidParameter("该迭代下存在事件，请先删除事件后再删除迭代")
-	}
-
 	if err := itr.db.DeleteIteration(id); err != nil {
 		return apierrors.ErrDeleteIteration.InternalError(err)
 	}

internal/pkg/extension/db/extension.go

@@ -331,3 +331,12 @@ func (client *Client) ListExtensionVersions(names []string, all bool) (map[strin
 
 	return extensions, err
 }
+
+func (client *Client) IsExtensionPublicVersionExist(name string) (bool, error) {
+	var count int64
+	err := client.Model(&ExtensionVersion{}).
+		Where("name = ? ", name).
+		Where("public = ?", true).
+		Count(&count).Error
+	return count > 0, err
+}

internal/pkg/extension/extension.service.go

@@ -311,11 +311,15 @@ func (s *provider) CreateExtensionVersionByRequest(req *pb.ExtensionVersionCreat
 		}
 		s.triggerPushEvent(specData, "update")
 		if req.All {
+			isPublic, err := s.isExtensionPublic(req.Name, req.Public)
+			if err != nil {
+				return nil, apierrors.ErrQueryExtension.InternalError(err)
+			}
 			extModel.Category = specData.Category
 			extModel.LogoUrl = specData.LogoUrl
 			extModel.DisplayName = specData.DisplayName
 			extModel.Desc = specData.Desc
-			extModel.Public = req.Public
+			extModel.Public = isPublic
 			extModel.Labels = labels
 			err = s.db.Save(&extModel).Error
 			if err != nil {
@@ -360,6 +364,15 @@ func (s *provider) CreateExtensionVersionByRequest(req *pb.ExtensionVersionCreat
 	}
 }
 
+func (s *provider) isExtensionPublic(name string, isPublic bool) (bool, error) {
+	isExist, err := s.db.IsExtensionPublicVersionExist(name)
+	if err != nil {
+		return false, fmt.Errorf("query extension public version error, %v", err)
+	}
+
+	return isExist || isPublic, nil
+}
+
 func (s *provider) DeleteExtensionVersion(name, version string) error {
 	if len(name) == 0 {
 		return apierrors.ErrDeleteExtensionVersion.MissingParameter("name")

internal/pkg/extension/extension.service_test.go

@@ -95,6 +95,12 @@ func mockClient() *db.Client {
 		}
 		return res, nil
 	})
+	monkey.PatchInstanceMethod(reflect.TypeOf(client), "IsExtensionPublicVersionExist", func(_ *db.Client, name string) (bool, error) {
+		if name == "deprecated-addon" {
+			return false, nil
+		}
+		return true, nil
+	})
 	monkey.PatchInstanceMethod(reflect.TypeOf(client.DB), "Save", func(_ *gorm.DB, value interface{}) *gorm.DB {
 		return &gorm.DB{
 			Error: nil,
@@ -643,3 +649,47 @@ func Test_extensionService_QueryExtensionVersions(t *testing.T) {
 		})
 	}
 }
+
+func Test_isExtensionPublic(t *testing.T) {
+	p := &provider{
+		db: cli,
+	}
+
+	type args struct {
+		name     string
+		isPublic bool
+	}
+
+	tests := []struct {
+		name   string
+		args   args
+		expect bool
+	}{
+		{
+			name: "update processing extension is private",
+			args: args{
+				name:     "mysql",
+				isPublic: false,
+			},
+			expect: true,
+		},
+		{
+			name: "all private",
+			args: args{
+				name:     "deprecated-addon",
+				isPublic: false,
+			},
+			expect: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := p.isExtensionPublic(tt.args.name, tt.args.isPublic)
+			assert.NoError(t, err)
+			if got != tt.expect {
+				t.Fatalf("expect: %v, got: %v", tt.expect, got)
+			}
+		})
+	}
+}