mirror of
https://github.com/go-gitea/gitea
synced 2024-08-20 14:21:21 +02:00
* display ui time with customize time location * fix lint * rename UILocation to DefaultUILocation * move time related functions to modules/timeutil * fix tests * fix tests * fix build * fix swagger
145 lines
3.9 KiB
Go
145 lines
3.9 KiB
Go
// Copyright 2018 The Gitea Authors. All rights reserved.
|
|
// Use of this source code is governed by a MIT-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package models
|
|
|
|
import (
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
"code.gitea.io/gitea/modules/timeutil"
|
|
)
|
|
|
|
// IssueDependency represents an issue dependency
|
|
type IssueDependency struct {
|
|
ID int64 `xorm:"pk autoincr"`
|
|
UserID int64 `xorm:"NOT NULL"`
|
|
IssueID int64 `xorm:"UNIQUE(issue_dependency) NOT NULL"`
|
|
DependencyID int64 `xorm:"UNIQUE(issue_dependency) NOT NULL"`
|
|
CreatedUnix timeutil.TimeStamp `xorm:"created"`
|
|
UpdatedUnix timeutil.TimeStamp `xorm:"updated"`
|
|
}
|
|
|
|
// DependencyType Defines Dependency Type Constants
|
|
type DependencyType int
|
|
|
|
// Define Dependency Types
|
|
const (
|
|
DependencyTypeBlockedBy DependencyType = iota
|
|
DependencyTypeBlocking
|
|
)
|
|
|
|
// CreateIssueDependency creates a new dependency for an issue
|
|
func CreateIssueDependency(user *User, issue, dep *Issue) error {
|
|
sess := x.NewSession()
|
|
defer sess.Close()
|
|
if err := sess.Begin(); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Check if it aleready exists
|
|
exists, err := issueDepExists(sess, issue.ID, dep.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if exists {
|
|
return ErrDependencyExists{issue.ID, dep.ID}
|
|
}
|
|
// And if it would be circular
|
|
circular, err := issueDepExists(sess, dep.ID, issue.ID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if circular {
|
|
return ErrCircularDependency{issue.ID, dep.ID}
|
|
}
|
|
|
|
if _, err := sess.Insert(&IssueDependency{
|
|
UserID: user.ID,
|
|
IssueID: issue.ID,
|
|
DependencyID: dep.ID,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Add comment referencing the new dependency
|
|
if err = createIssueDependencyComment(sess, user, issue, dep, true); err != nil {
|
|
return err
|
|
}
|
|
|
|
return sess.Commit()
|
|
}
|
|
|
|
// RemoveIssueDependency removes a dependency from an issue
|
|
func RemoveIssueDependency(user *User, issue *Issue, dep *Issue, depType DependencyType) (err error) {
|
|
sess := x.NewSession()
|
|
defer sess.Close()
|
|
if err = sess.Begin(); err != nil {
|
|
return err
|
|
}
|
|
|
|
var issueDepToDelete IssueDependency
|
|
|
|
switch depType {
|
|
case DependencyTypeBlockedBy:
|
|
issueDepToDelete = IssueDependency{IssueID: issue.ID, DependencyID: dep.ID}
|
|
case DependencyTypeBlocking:
|
|
issueDepToDelete = IssueDependency{IssueID: dep.ID, DependencyID: issue.ID}
|
|
default:
|
|
return ErrUnknownDependencyType{depType}
|
|
}
|
|
|
|
affected, err := sess.Delete(&issueDepToDelete)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// If we deleted nothing, the dependency did not exist
|
|
if affected <= 0 {
|
|
return ErrDependencyNotExists{issue.ID, dep.ID}
|
|
}
|
|
|
|
// Add comment referencing the removed dependency
|
|
if err = createIssueDependencyComment(sess, user, issue, dep, false); err != nil {
|
|
return err
|
|
}
|
|
return sess.Commit()
|
|
}
|
|
|
|
// Check if the dependency already exists
|
|
func issueDepExists(e Engine, issueID int64, depID int64) (bool, error) {
|
|
return e.Where("(issue_id = ? AND dependency_id = ?)", issueID, depID).Exist(&IssueDependency{})
|
|
}
|
|
|
|
// IssueNoDependenciesLeft checks if issue can be closed
|
|
func IssueNoDependenciesLeft(issue *Issue) (bool, error) {
|
|
return issueNoDependenciesLeft(x, issue)
|
|
}
|
|
|
|
func issueNoDependenciesLeft(e Engine, issue *Issue) (bool, error) {
|
|
exists, err := e.
|
|
Table("issue_dependency").
|
|
Select("issue.*").
|
|
Join("INNER", "issue", "issue.id = issue_dependency.dependency_id").
|
|
Where("issue_dependency.issue_id = ?", issue.ID).
|
|
And("issue.is_closed = ?", "0").
|
|
Exist(&Issue{})
|
|
|
|
return !exists, err
|
|
}
|
|
|
|
// IsDependenciesEnabled returns if dependecies are enabled and returns the default setting if not set.
|
|
func (repo *Repository) IsDependenciesEnabled() bool {
|
|
return repo.isDependenciesEnabled(x)
|
|
}
|
|
|
|
func (repo *Repository) isDependenciesEnabled(e Engine) bool {
|
|
var u *RepoUnit
|
|
var err error
|
|
if u, err = repo.getUnit(e, UnitTypeIssues); err != nil {
|
|
log.Trace("%s", err)
|
|
return setting.Service.DefaultEnableDependencies
|
|
}
|
|
return u.IssuesConfig().EnableDependencies
|
|
}
|