[API] Allow removing issues

models/issue.go

@@ -13,6 +13,7 @@ import (
 	"strconv"
 	"strings"
 
+	admin_model "code.gitea.io/gitea/models/admin"
 	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/models/issues"
 	"code.gitea.io/gitea/models/perm"
@@ -24,6 +25,7 @@ import (
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/references"
 	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/storage"
 	api "code.gitea.io/gitea/modules/structs"
 	"code.gitea.io/gitea/modules/timeutil"
 	"code.gitea.io/gitea/modules/util"
@@ -356,6 +358,108 @@ func (issue *Issue) GetIsRead(userID int64) error {
 	return nil
 }
 
+func (issue *Issue) AfterDelete() {
+	e := db.GetEngine(db.DefaultContext)
+	// Delete content histories
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&issues.ContentHistory{}); err != nil {
+		log.Info("Could not delete content history for issue %d: %s", issue.ID, err)
+	}
+
+	// Delete comments and attachments
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&Comment{}); err != nil {
+		log.Info("Could not delete comments for issue %d: %s", issue.ID, err)
+	}
+
+	// Delete label assignment
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&IssueLabel{}); err != nil {
+		log.Info("Could not delete issue labels for issue %d: %s", issue.ID, err)
+	}
+
+	// References to this issue in other issues
+	if _, err := e.In("ref_issue_id", issue.ID).
+		Delete(&Comment{}); err != nil {
+		log.Info("Could not delete referring comments for issue %d: %s", issue.ID, err)
+	}
+
+	// Dependencies for issues in this repository
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&IssueDependency{}); err != nil {
+		log.Info("Could not delete internal issue dependencies for issue %d: %s", issue.ID, err)
+	}
+
+	// Delete dependencies for issues in other repositories
+	if _, err := e.In("dependency_id", issue.ID).
+		Delete(&IssueDependency{}); err != nil {
+		log.Info("Could not delete external issue dependencies for issue %d: %s", issue.ID, err)
+	}
+
+	// delete from dependent issues
+	if _, err := e.In("dependent_issue_id", issue.ID).
+		Delete(&Comment{}); err != nil {
+		log.Info("Could not delete dependend issue for issue %d: %s", issue.ID, err)
+	}
+
+	// delete issue assignment
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&IssueAssignees{}); err != nil {
+		log.Info("Could not delete issue assignees for issue %d: %s", issue.ID, err)
+	}
+
+	// delete issue user state
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&IssueUser{}); err != nil {
+		log.Info("Could not delete IssueUser for issue %d: %s", issue.ID, err)
+	}
+
+	// delete reactions
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&Reaction{}); err != nil {
+		log.Info("Could not delete Reaction for issue %d: %s", issue.ID, err)
+	}
+
+	// delete user watches
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&IssueWatch{}); err != nil {
+		log.Info("Could not delete IssueWatch for issue %d: %s", issue.ID, err)
+	}
+
+	// delete stopwatches
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&Stopwatch{}); err != nil {
+		log.Info("Could not delete StopWatch for issue %d: %s", issue.ID, err)
+	}
+
+	// delete tracked time
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&TrackedTime{}); err != nil {
+		log.Info("Could not delete TrackedTime for issue %d: %s", issue.ID, err)
+	}
+
+	// delete from projects
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&ProjectIssue{}); err != nil {
+		log.Info("Could not delete ProjektIssue for issue %d: %s", issue.ID, err)
+	}
+
+	var attachments []*repo_model.Attachment
+	if err := e.In("issue_id", issue.ID).
+		Find(&attachments); err != nil {
+		log.Info("Could not find attachments for issue %d: %s", issue.ID, err)
+	}
+
+	for i := range attachments {
+		admin_model.RemoveStorageWithNotice(db.DefaultContext, storage.Attachments, "Delete issue attachment", attachments[i].RelativePath())
+	}
+
+	if _, err := e.In("issue_id", issue.ID).
+		Delete(&repo_model.Attachment{}); err != nil {
+		log.Info("Could not delete attachment for issue %d: %s", issue.ID, err)
+	}
+}
+
 // APIURL returns the absolute APIURL to this issue.
 func (issue *Issue) APIURL() string {
 	if issue.Repo == nil {
@@ -1990,6 +2094,51 @@ func UpdateIssueDeadline(issue *Issue, deadlineUnix timeutil.TimeStamp, doer *us
 	return committer.Commit()
 }
 
+// DeleteIssue deletes the issue
+func DeleteIssue(issue *Issue) error {
+	ctx, committer, err := db.TxContext()
+	if err != nil {
+		return err
+	}
+	defer committer.Close()
+
+	if err := deleteIssue(db.GetEngine(ctx), issue); err != nil {
+		return err
+	}
+
+	return committer.Commit()
+}
+
+func deleteIssue(e db.Engine, issue *Issue) error {
+	if _, err := e.Delete(&Issue{
+		ID: issue.ID,
+	}); err != nil {
+		return err
+	}
+
+	if issue.IsPull {
+		if _, err := e.Exec("UPDATE `repository` SET num_pulls = num_pulls - 1 WHERE id = ?", issue.RepoID); err != nil {
+			return err
+		}
+		if issue.IsClosed {
+			if _, err := e.Exec("UPDATE `repository` SET num_closed_pulls = num_closed_pulls -1 WHERE id = ?", issue.RepoID); err != nil {
+				return err
+			}
+		}
+	} else {
+		if _, err := e.Exec("UPDATE `repository` SET num_issues = num_issues - 1 WHERE id = ?", issue.RepoID); err != nil {
+			return err
+		}
+		if issue.IsClosed {
+			if _, err := e.Exec("UPDATE `repository` SET num_closed_issues = num_closed_issues -1 WHERE id = ?", issue.RepoID); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
 // DependencyInfo represents high level information about an issue which is a dependency of another issue.
 type DependencyInfo struct {
 	Issue                 `xorm:"extends"`

models/issue_test.go

@@ -397,6 +397,58 @@ func TestIssue_InsertIssue(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func TestIssue_DeleteIssue(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+
+	issueIDs, err := GetIssueIDsByRepoID(1)
+	assert.NoError(t, err)
+	assert.EqualValues(t, 5, len(issueIDs))
+
+	issue := &Issue{
+		RepoID: 1,
+		ID:     issueIDs[2],
+	}
+
+	err = DeleteIssue(issue)
+	assert.NoError(t, err)
+	issueIDs, err = GetIssueIDsByRepoID(1)
+	assert.NoError(t, err)
+	assert.EqualValues(t, 4, len(issueIDs))
+
+	// check attachment removal
+	attachments, err := repo_model.GetAttachmentsByIssueID(4)
+	assert.NoError(t, err)
+	issue, err = GetIssueByID(4)
+	assert.NoError(t, err)
+	err = DeleteIssue(issue)
+	assert.NoError(t, err)
+	assert.EqualValues(t, 2, len(attachments))
+	for i := range attachments {
+		attachment, err := repo_model.GetAttachmentByUUID(attachments[i].UUID)
+		assert.Error(t, err)
+		assert.True(t, repo_model.IsErrAttachmentNotExist(err))
+		assert.Nil(t, attachment)
+	}
+
+	// check issue dependencies
+	user, err := user_model.GetUserByID(1)
+	assert.NoError(t, err)
+	issue1, err := GetIssueByID(1)
+	assert.NoError(t, err)
+	issue2, err := GetIssueByID(2)
+	assert.NoError(t, err)
+	err = CreateIssueDependency(user, issue1, issue2)
+	assert.NoError(t, err)
+	left, err := IssueNoDependenciesLeft(issue1)
+	assert.NoError(t, err)
+	assert.False(t, left)
+	err = DeleteIssue(&Issue{ID: 2})
+	assert.NoError(t, err)
+	left, err = IssueNoDependenciesLeft(issue1)
+	assert.NoError(t, err)
+	assert.True(t, left)
+}
+
 func TestIssue_ResolveMentions(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 

routers/api/v1/api.go

@@ -835,7 +835,8 @@ func Routes(sessioner func(http.Handler) http.Handler) *web.Route {
 					})
 					m.Group("/{index}", func() {
 						m.Combo("").Get(repo.GetIssue).
-							Patch(reqToken(), bind(api.EditIssueOption{}), repo.EditIssue)
+							Patch(reqToken(), bind(api.EditIssueOption{}), repo.EditIssue).
+							Delete(reqToken(), repo.DeleteIssue)
 						m.Group("/comments", func() {
 							m.Combo("").Get(repo.ListIssueComments).
 								Post(reqToken(), mustNotBeArchived, bind(api.CreateIssueCommentOption{}), repo.CreateIssueComment)

routers/api/v1/repo/issue.go

@@ -14,6 +14,7 @@ import (
 
 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unit"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/context"
@@ -834,6 +835,70 @@ func EditIssue(ctx *context.APIContext) {
 	ctx.JSON(http.StatusCreated, convert.ToAPIIssue(issue))
 }
 
+func DeleteIssue(ctx *context.APIContext) {
+	// swagger:operation DELETE /repos/{owner}/{repo}/issues/{index} issue issueDelete
+	// ---
+	// summary: Delete an issue
+	// parameters:
+	// - name: owner
+	//   in: path
+	//   description: owner of the repo
+	//   type: string
+	//   required: true
+	// - name: repo
+	//   in: path
+	//   description: name of the repo
+	//   type: string
+	//   required: true
+	// - name: index
+	//   in: path
+	//   description: index of issue to delete
+	//   type: integer
+	//   format: int64
+	//   required: true
+	// responses:
+	//   "204":
+	//     "$ref": "#/responses/empty"
+	//   "403":
+	//     "$ref": "#/responses/forbidden"
+	//   "404":
+	//     "$ref": "#/responses/notFound"
+
+	deleteIssue(ctx)
+}
+
+func deleteIssue(ctx *context.APIContext) {
+	if !ctx.IsSigned || !ctx.Repo.IsAdmin() {
+		ctx.Status(http.StatusForbidden)
+		return
+	}
+
+	repo, err := repo_model.GetRepositoryByOwnerAndName(ctx.Params(":username"), ctx.Params(":reponame"))
+	if err != nil {
+		if repo_model.IsErrRepoNotExist(err) {
+			ctx.NotFound(err)
+		} else {
+			ctx.Error(http.StatusInternalServerError, "GetRepoByOwnerAndName", err)
+		}
+	}
+	issue, err := models.GetIssueByIndex(repo.ID, ctx.ParamsInt64(":index"))
+	if err != nil {
+		if models.IsErrIssueNotExist(err) {
+			ctx.NotFound(err)
+		} else {
+			ctx.Error(http.StatusInternalServerError, "GetIssueByID", err)
+		}
+		return
+	}
+
+	if err = issue_service.DeleteIssue(ctx.User, issue); err != nil {
+		ctx.Error(http.StatusInternalServerError, "DeleteIssueByID", err)
+		return
+	}
+
+	ctx.Status(http.StatusNoContent)
+}
+
 // UpdateIssueDeadline updates an issue deadline
 func UpdateIssueDeadline(ctx *context.APIContext) {
 	// swagger:operation POST /repos/{owner}/{repo}/issues/{index}/deadline issue issueEditIssueDeadline

services/issue/issue.go

@@ -125,6 +125,17 @@ func UpdateAssignees(issue *models.Issue, oneAssignee string, multipleAssignees
 	return
 }
 
+// DeleteIssue deletes an issue
+func DeleteIssue(doer *user_model.User, issue *models.Issue) error {
+	if err := models.DeleteIssue(issue); err != nil {
+		return err
+	}
+
+	// notification.NotifyDeleteIssue(doer, issue)
+
+	return nil
+}
+
 // AddAssigneeIfNotAssigned adds an assignee only if he isn't already assigned to the issue.
 // Also checks for access of assigned user
 func AddAssigneeIfNotAssigned(issue *models.Issue, doer *user_model.User, assigneeID int64) (err error) {

templates/swagger/v1_json.tmpl

@@ -4966,6 +4966,48 @@
           }
         }
       },
+      "delete": {
+        "tags": [
+          "issue"
+        ],
+        "summary": "Delete an issue",
+        "operationId": "issueDelete",
+        "parameters": [
+          {
+            "type": "string",
+            "description": "owner of the repo",
+            "name": "owner",
+            "in": "path",
+            "required": true
+          },
+          {
+            "type": "string",
+            "description": "name of the repo",
+            "name": "repo",
+            "in": "path",
+            "required": true
+          },
+          {
+            "type": "integer",
+            "format": "int64",
+            "description": "index of issue to delete",
+            "name": "index",
+            "in": "path",
+            "required": true
+          }
+        ],
+        "responses": {
+          "204": {
+            "$ref": "#/responses/empty"
+          },
+          "403": {
+            "$ref": "#/responses/forbidden"
+          },
+          "404": {
+            "$ref": "#/responses/notFound"
+          }
+        }
+      },
       "patch": {
         "consumes": [
           "application/json"