forgejo-federation/models/issue_assignees.go

196 lines
5 KiB
Go
Raw Normal View History

2018-05-09 21:59:04 +05:30
// 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 (
"fmt"
2019-10-17 14:56:49 +05:30
"xorm.io/xorm"
2018-05-09 21:59:04 +05:30
)
// IssueAssignees saves all issue assignees
type IssueAssignees struct {
ID int64 `xorm:"pk autoincr"`
AssigneeID int64 `xorm:"INDEX"`
IssueID int64 `xorm:"INDEX"`
}
// This loads all assignees of an issue
func (issue *Issue) loadAssignees(e Engine) (err error) {
// Reset maybe preexisting assignees
issue.Assignees = []*User{}
err = e.Table("`user`").
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
}
// GetAssigneesByIssue returns everyone assigned to that issue
func GetAssigneesByIssue(issue *Issue) (assignees []*User, err error) {
return getAssigneesByIssue(x, issue)
}
func getAssigneesByIssue(e Engine, issue *Issue) (assignees []*User, err error) {
err = issue.loadAssignees(e)
2018-05-09 21:59:04 +05:30
if err != nil {
return assignees, err
}
return issue.Assignees, nil
}
// IsUserAssignedToIssue returns true when the user is assigned to the issue
func IsUserAssignedToIssue(issue *Issue, user *User) (isAssigned bool, err error) {
return isUserAssignedToIssue(x, issue, user)
}
func isUserAssignedToIssue(e Engine, issue *Issue, user *User) (isAssigned bool, err error) {
return e.Get(&IssueAssignees{IssueID: issue.ID, AssigneeID: user.ID})
2018-05-09 21:59:04 +05:30
}
// MakeAssigneeList concats a string with all names of the assignees. Useful for logs.
func MakeAssigneeList(issue *Issue) (assigneeList string, err error) {
err = issue.loadAssignees(x)
if err != nil {
return "", err
}
for in, assignee := range issue.Assignees {
assigneeList += assignee.Name
if len(issue.Assignees) > (in + 1) {
assigneeList += ", "
}
}
return
}
// ClearAssigneeByUserID deletes all assignments of an user
func clearAssigneeByUserID(sess *xorm.Session, userID int64) (err error) {
_, err = sess.Delete(&IssueAssignees{AssigneeID: userID})
return
}
// ToggleAssignee changes a user between assigned and not assigned for this issue, and make issue comment for it.
func (issue *Issue) ToggleAssignee(doer *User, assigneeID int64) (removed bool, comment *Comment, err error) {
2018-05-09 21:59:04 +05:30
sess := x.NewSession()
defer sess.Close()
if err := sess.Begin(); err != nil {
return false, nil, err
2018-05-09 21:59:04 +05:30
}
removed, comment, err = issue.toggleAssignee(sess, doer, assigneeID, false)
if err != nil {
return false, nil, err
2018-05-09 21:59:04 +05:30
}
if err := sess.Commit(); err != nil {
return false, nil, err
}
return removed, comment, nil
2018-05-09 21:59:04 +05:30
}
func (issue *Issue) toggleAssignee(sess *xorm.Session, doer *User, assigneeID int64, isCreate bool) (removed bool, comment *Comment, err error) {
removed, err = toggleUserAssignee(sess, issue, assigneeID)
2018-05-09 21:59:04 +05:30
if err != nil {
return false, nil, fmt.Errorf("UpdateIssueUserByAssignee: %v", err)
2018-05-09 21:59:04 +05:30
}
// Repo infos
if err = issue.loadRepo(sess); err != nil {
return false, nil, fmt.Errorf("loadRepo: %v", err)
2018-05-09 21:59:04 +05:30
}
// Comment
comment, err = createAssigneeComment(sess, doer, issue.Repo, issue, assigneeID, removed)
if err != nil {
return false, nil, fmt.Errorf("createAssigneeComment: %v", err)
2018-05-09 21:59:04 +05:30
}
// 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 21:59:04 +05:30
}
// toggles user assignee state in database
func toggleUserAssignee(e *xorm.Session, issue *Issue, assigneeID int64) (removed bool, err error) {
2018-05-09 21:59:04 +05:30
// Check if the user exists
assignee, err := getUserByID(e, assigneeID)
if err != nil {
return false, err
2018-05-09 21:59:04 +05:30
}
// Check if the submitted user is already assigned, if yes delete him otherwise add him
var i int
for i = 0; i < len(issue.Assignees); i++ {
if issue.Assignees[i].ID == assigneeID {
break
2018-05-09 21:59:04 +05:30
}
}
assigneeIn := IssueAssignees{AssigneeID: assigneeID, IssueID: issue.ID}
2018-05-09 21:59:04 +05:30
toBeDeleted := i < len(issue.Assignees)
if toBeDeleted {
issue.Assignees = append(issue.Assignees[:i], issue.Assignees[i:]...)
_, err = e.Delete(assigneeIn)
2018-05-09 21:59:04 +05:30
if err != nil {
return toBeDeleted, err
}
} else {
issue.Assignees = append(issue.Assignees, assignee)
_, err = e.Insert(assigneeIn)
if err != nil {
return toBeDeleted, err
2018-05-09 21:59:04 +05:30
}
}
return toBeDeleted, nil
2018-05-09 21:59:04 +05:30
}
// MakeIDsFromAPIAssigneesToAdd returns an array with all assignee IDs
func MakeIDsFromAPIAssigneesToAdd(oneAssignee string, multipleAssignees []string) (assigneeIDs []int64, err error) {
// Keeping the old assigning method for compatibility reasons
if oneAssignee != "" {
// Prevent double adding assignees
var isDouble bool
for _, assignee := range multipleAssignees {
if assignee == oneAssignee {
isDouble = true
break
}
}
if !isDouble {
multipleAssignees = append(multipleAssignees, oneAssignee)
}
}
// Get the IDs of all assignees
assigneeIDs, err = GetUserIDsByNames(multipleAssignees, false)
2018-05-09 21:59:04 +05:30
return
}