// Copyright 2020 The Gitea Authors. All rights reserved. // SPDX-License-Identifier: MIT package project import ( "context" "fmt" "code.gitea.io/gitea/models/db" "code.gitea.io/gitea/modules/log" "code.gitea.io/gitea/modules/util" ) // ProjectIssue saves relation from issue to a project type ProjectIssue struct { //revive:disable-line:exported ID int64 `xorm:"pk autoincr"` IssueID int64 `xorm:"INDEX"` ProjectID int64 `xorm:"INDEX"` Project *Project `xorm:"-"` // ProjectColumnID should not be zero since 1.22. If it's zero, the issue will not be displayed on UI and it might result in errors. ProjectColumnID int64 `xorm:"'project_board_id' INDEX"` ProjectColumn *Column `xorm:"-"` // the sorting order on the column Sorting int64 `xorm:"NOT NULL DEFAULT 0"` } func init() { db.RegisterModel(new(ProjectIssue)) } func deleteProjectIssuesByProjectID(ctx context.Context, projectID int64) error { _, err := db.GetEngine(ctx).Where("project_id=?", projectID).Delete(&ProjectIssue{}) return err } type ErrProjectIssueNotExist struct { IssueID int64 } func (e ErrProjectIssueNotExist) Error() string { return fmt.Sprintf("can't find project issue [issue_id: %d]", e.IssueID) } func IsErrProjectIssueNotExist(e error) bool { _, ok := e.(ErrProjectIssueNotExist) return ok } func GetProjectIssueByIssueID(ctx context.Context, issueID int64) (*ProjectIssue, error) { issue := &ProjectIssue{} has, err := db.GetEngine(ctx).Where("issue_id = ?", issueID).Get(issue) if err != nil { return nil, err } if !has { return nil, ErrProjectIssueNotExist{IssueID: issueID} } return issue, nil } func (issue *ProjectIssue) LoadProjectColumn(ctx context.Context) error { if issue.ProjectColumn != nil { return nil } var err error if issue.ProjectColumnID == 0 { issue.ProjectColumn, err = issue.Project.GetDefaultColumn(ctx) return err } issue.ProjectColumn, err = GetColumn(ctx, issue.ProjectColumnID) return err } // NumIssues return counter of all issues assigned to a project func (p *Project) NumIssues(ctx context.Context) int { c, err := db.GetEngine(ctx).Table("project_issue"). Where("project_id=?", p.ID). GroupBy("issue_id"). Cols("issue_id"). Count() if err != nil { log.Error("NumIssues: %v", err) return 0 } return int(c) } // NumClosedIssues return counter of closed issues assigned to a project func (p *Project) NumClosedIssues(ctx context.Context) int { c, err := db.GetEngine(ctx).Table("project_issue"). Join("INNER", "issue", "project_issue.issue_id=issue.id"). Where("project_issue.project_id=? AND issue.is_closed=?", p.ID, true). Cols("issue_id"). Count() if err != nil { log.Error("NumClosedIssues: %v", err) return 0 } return int(c) } // NumOpenIssues return counter of open issues assigned to a project func (p *Project) NumOpenIssues(ctx context.Context) int { c, err := db.GetEngine(ctx).Table("project_issue"). Join("INNER", "issue", "project_issue.issue_id=issue.id"). Where("project_issue.project_id=? AND issue.is_closed=?", p.ID, false). Cols("issue_id"). Count() if err != nil { log.Error("NumOpenIssues: %v", err) return 0 } return int(c) } // MoveIssuesOnProjectColumn moves or keeps issues in a column and sorts them inside that column func MoveIssuesOnProjectColumn(ctx context.Context, column *Column, sortedIssueIDs map[int64]int64) error { return db.WithTx(ctx, func(ctx context.Context) error { sess := db.GetEngine(ctx) issueIDs := util.ValuesOfMap(sortedIssueIDs) count, err := sess.Table(new(ProjectIssue)).Where("project_id=?", column.ProjectID).In("issue_id", issueIDs).Count() if err != nil { return err } if int(count) != len(sortedIssueIDs) { return fmt.Errorf("all issues have to be added to a project first") } for sorting, issueID := range sortedIssueIDs { _, err = sess.Exec("UPDATE `project_issue` SET project_board_id=?, sorting=? WHERE issue_id=?", column.ID, sorting, issueID) if err != nil { return err } } return nil }) } func MoveIssueToColumnTail(ctx context.Context, issue *ProjectIssue, toColumn *Column) error { nextSorting, err := toColumn.getNextSorting(ctx) if err != nil { return err } return db.WithTx(ctx, func(ctx context.Context) error { _, err = db.GetEngine(ctx).Exec("UPDATE `project_issue` SET project_board_id=?, sorting=? WHERE issue_id=?", toColumn.ID, nextSorting, issue.IssueID) return err }) } func (c *Column) getNextSorting(ctx context.Context) (int64, error) { res := struct { MaxSorting int64 IssueCount int64 }{} if _, err := db.GetEngine(ctx).Select("max(sorting) as max_sorting, count(*) as issue_count"). Table("project_issue"). Where("project_id=?", c.ProjectID). And("project_board_id=?", c.ID). Get(&res); err != nil { return 0, err } if res.IssueCount > 0 { return res.MaxSorting + 1, nil } return 0, nil } func (c *Column) moveIssuesToAnotherColumn(ctx context.Context, newColumn *Column) error { if c.ProjectID != newColumn.ProjectID { return fmt.Errorf("columns have to be in the same project") } if c.ID == newColumn.ID { return nil } nextSorting, err := newColumn.getNextSorting(ctx) if err != nil { return err } issues, err := c.GetIssues(ctx) if err != nil { return err } if len(issues) == 0 { return nil } return db.WithTx(ctx, func(ctx context.Context) error { for i, issue := range issues { issue.ProjectColumnID = newColumn.ID issue.Sorting = nextSorting + int64(i) if _, err := db.GetEngine(ctx).ID(issue.ID).Cols("project_board_id", "sorting").Update(issue); err != nil { return err } } return nil }) }