0
0
mirror of https://github.com/go-gitea/gitea.git synced 2024-12-05 09:29:24 +01:00
gitea/models/issues/assignees.go

172 lines
4.9 KiB
Go
Raw Normal View History

2018-05-09 18:29:04 +02:00
// Copyright 2018 The Gitea Authors. All rights reserved.
// SPDX-License-Identifier: MIT
2018-05-09 18:29:04 +02:00
package issues
2018-05-09 18:29:04 +02:00
import (
"context"
2018-05-09 18:29:04 +02:00
"fmt"
"code.gitea.io/gitea/models/db"
user_model "code.gitea.io/gitea/models/user"
"code.gitea.io/gitea/modules/util"
2018-05-09 18:29:04 +02:00
)
// IssueAssignees saves all issue assignees
type IssueAssignees struct {
ID int64 `xorm:"pk autoincr"`
AssigneeID int64 `xorm:"INDEX"`
IssueID int64 `xorm:"INDEX"`
}
func init() {
db.RegisterModel(new(IssueAssignees))
}
// LoadAssignees load assignees of this issue.
func (issue *Issue) LoadAssignees(ctx context.Context) (err error) {
2018-05-09 18:29:04 +02:00
// Reset maybe preexisting assignees
issue.Assignees = []*user_model.User{}
issue.Assignee = nil
2018-05-09 18:29:04 +02:00
err = db.GetEngine(ctx).Table("`user`").
2018-05-09 18:29:04 +02:00
Join("INNER", "issue_assignees", "assignee_id = `user`.id").
Where("issue_assignees.issue_id = ?", issue.ID).
Find(&issue.Assignees)
if err != nil {
return err
}
// Check if we have at least one assignee and if yes put it in as `Assignee`
if len(issue.Assignees) > 0 {
issue.Assignee = issue.Assignees[0]
}
return err
2018-05-09 18:29:04 +02:00
}
// GetAssigneeIDsByIssue returns the IDs of users assigned to an issue
// but skips joining with `user` for performance reasons.
// User permissions must be verified elsewhere if required.
func GetAssigneeIDsByIssue(ctx context.Context, issueID int64) ([]int64, error) {
userIDs := make([]int64, 0, 5)
return userIDs, db.GetEngine(ctx).
Table("issue_assignees").
Cols("assignee_id").
Where("issue_id = ?", issueID).
Distinct("assignee_id").
Find(&userIDs)
}
2018-05-09 18:29:04 +02:00
// IsUserAssignedToIssue returns true when the user is assigned to the issue
func IsUserAssignedToIssue(ctx context.Context, issue *Issue, user *user_model.User) (isAssigned bool, err error) {
return db.GetByBean(ctx, &IssueAssignees{IssueID: issue.ID, AssigneeID: user.ID})
2018-05-09 18:29:04 +02:00
}
// ToggleIssueAssignee changes a user between assigned and not assigned for this issue, and make issue comment for it.
func ToggleIssueAssignee(ctx context.Context, issue *Issue, doer *user_model.User, assigneeID int64) (removed bool, comment *Comment, err error) {
ctx, committer, err := db.TxContext(ctx)
if err != nil {
return false, nil, err
2018-05-09 18:29:04 +02:00
}
defer committer.Close()
2018-05-09 18:29:04 +02:00
removed, comment, err = toggleIssueAssignee(ctx, issue, doer, assigneeID, false)
if err != nil {
return false, nil, err
2018-05-09 18:29:04 +02:00
}
if err := committer.Commit(); err != nil {
return false, nil, err
}
return removed, comment, nil
2018-05-09 18:29:04 +02:00
}
func toggleIssueAssignee(ctx context.Context, issue *Issue, doer *user_model.User, assigneeID int64, isCreate bool) (removed bool, comment *Comment, err error) {
removed, err = toggleUserAssignee(ctx, issue, assigneeID)
2018-05-09 18:29:04 +02:00
if err != nil {
return false, nil, fmt.Errorf("UpdateIssueUserByAssignee: %w", err)
2018-05-09 18:29:04 +02:00
}
// Repo infos
if err = issue.LoadRepo(ctx); err != nil {
return false, nil, fmt.Errorf("loadRepo: %w", err)
2018-05-09 18:29:04 +02:00
}
opts := &CreateCommentOptions{
Type: CommentTypeAssignees,
Doer: doer,
Repo: issue.Repo,
Issue: issue,
RemovedAssignee: removed,
AssigneeID: assigneeID,
}
// Comment
comment, err = CreateComment(ctx, opts)
if err != nil {
return false, nil, fmt.Errorf("createComment: %w", err)
2018-05-09 18:29:04 +02:00
}
// if pull request is in the middle of creation - don't call webhook
if isCreate {
return removed, comment, err
}
return removed, comment, nil
2018-05-09 18:29:04 +02:00
}
// toggles user assignee state in database
func toggleUserAssignee(ctx context.Context, issue *Issue, assigneeID int64) (removed bool, err error) {
// Check if the user exists
assignee, err := user_model.GetUserByID(ctx, assigneeID)
if err != nil {
return false, err
2018-05-09 18:29:04 +02:00
}
// Check if the submitted user is already assigned, if yes delete him otherwise add him
found := false
i := 0
for ; i < len(issue.Assignees); i++ {
if issue.Assignees[i].ID == assigneeID {
found = true
break
2018-05-09 18:29:04 +02:00
}
}
assigneeIn := IssueAssignees{AssigneeID: assigneeID, IssueID: issue.ID}
if found {
issue.Assignees = append(issue.Assignees[:i], issue.Assignees[i+1:]...)
_, err = db.DeleteByBean(ctx, &assigneeIn)
2018-05-09 18:29:04 +02:00
if err != nil {
return found, err
}
} else {
issue.Assignees = append(issue.Assignees, assignee)
if err = db.Insert(ctx, &assigneeIn); err != nil {
return found, err
2018-05-09 18:29:04 +02:00
}
}
return found, nil
2018-05-09 18:29:04 +02:00
}
// MakeIDsFromAPIAssigneesToAdd returns an array with all assignee IDs
func MakeIDsFromAPIAssigneesToAdd(ctx context.Context, oneAssignee string, multipleAssignees []string) (assigneeIDs []int64, err error) {
var requestAssignees []string
2018-05-09 18:29:04 +02:00
// Keeping the old assigning method for compatibility reasons
if oneAssignee != "" && !util.SliceContainsString(multipleAssignees, oneAssignee) {
requestAssignees = append(requestAssignees, oneAssignee)
}
2018-05-09 18:29:04 +02:00
// Prevent empty assignees
if len(multipleAssignees) > 0 && multipleAssignees[0] != "" {
requestAssignees = append(requestAssignees, multipleAssignees...)
2018-05-09 18:29:04 +02:00
}
// Get the IDs of all assignees
assigneeIDs, err = user_model.GetUserIDsByNames(ctx, requestAssignees, false)
2018-05-09 18:29:04 +02:00
return assigneeIDs, err
2018-05-09 18:29:04 +02:00
}