mirror of
https://github.com/simon987/task_tracker.git
synced 2025-04-10 05:56:42 +00:00
270 lines
7.3 KiB
Go
270 lines
7.3 KiB
Go
package storage
|
|
|
|
import (
|
|
"database/sql"
|
|
"github.com/sirupsen/logrus"
|
|
"golang.org/x/time/rate"
|
|
"strings"
|
|
)
|
|
|
|
type Project struct {
|
|
Id int64 `json:"id"`
|
|
Priority int64 `json:"priority"`
|
|
Name string `json:"name"`
|
|
CloneUrl string `json:"clone_url"`
|
|
GitRepo string `json:"git_repo"`
|
|
Version string `json:"version"`
|
|
Motd string `json:"motd"`
|
|
Public bool `json:"public"`
|
|
Hidden bool `json:"hidden"`
|
|
Chain int64 `json:"chain"`
|
|
Paused bool `json:"paused"`
|
|
AssignRate rate.Limit `json:"assign_rate"`
|
|
SubmitRate rate.Limit `json:"submit_rate"`
|
|
}
|
|
|
|
type AssignedTasks struct {
|
|
Assignee string `json:"assignee"`
|
|
TaskCount int64 `json:"task_count"`
|
|
}
|
|
|
|
func (database *Database) SaveProject(project *Project, webhookSecret string) (int64, error) {
|
|
db := database.getDB()
|
|
|
|
row := db.QueryRow(`INSERT INTO project (name, git_repo, clone_url, version, priority,
|
|
motd, public, hidden, chain, paused, webhook_secret, assign_rate, submit_rate)
|
|
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,NULLIF($9, 0),$10,$11,$12,$13) RETURNING id`,
|
|
project.Name, project.GitRepo, project.CloneUrl, project.Version, project.Priority, project.Motd,
|
|
project.Public, project.Hidden, project.Chain, project.Paused, webhookSecret, project.AssignRate,
|
|
project.SubmitRate)
|
|
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
|
|
if err != nil {
|
|
logrus.WithError(err).WithFields(logrus.Fields{
|
|
"project": project,
|
|
}).Warn("Database.saveProject INSERT project ERROR")
|
|
return -1, err
|
|
}
|
|
|
|
project.Id = id
|
|
|
|
logrus.WithFields(logrus.Fields{
|
|
"id": id,
|
|
"project": project,
|
|
}).Trace("Database.saveProject INSERT project")
|
|
|
|
database.projectCache[id] = project
|
|
|
|
return id, nil
|
|
}
|
|
|
|
func (database *Database) GetProject(id int64) *Project {
|
|
|
|
if database.projectCache[id] != nil {
|
|
return database.projectCache[id]
|
|
}
|
|
|
|
db := database.getDB()
|
|
row := db.QueryRow(`SELECT id, priority, name, clone_url, git_repo, version,
|
|
motd, public, hidden, COALESCE(chain, 0), paused, assign_rate, submit_rate
|
|
FROM project WHERE id=$1`, id)
|
|
|
|
project, err := scanProject(row)
|
|
if err != nil {
|
|
logrus.WithError(err).WithFields(logrus.Fields{
|
|
"id": id,
|
|
}).Warn("Database.getProject SELECT project NOT FOUND")
|
|
return nil
|
|
}
|
|
|
|
logrus.WithFields(logrus.Fields{
|
|
"id": id,
|
|
"project": project,
|
|
}).Trace("Database.getProject SELECT project")
|
|
|
|
database.projectCache[id] = project
|
|
|
|
return project
|
|
}
|
|
|
|
func scanProject(row *sql.Row) (*Project, error) {
|
|
|
|
p := &Project{}
|
|
err := row.Scan(&p.Id, &p.Priority, &p.Name, &p.CloneUrl, &p.GitRepo, &p.Version,
|
|
&p.Motd, &p.Public, &p.Hidden, &p.Chain, &p.Paused, &p.AssignRate, &p.SubmitRate)
|
|
|
|
return p, err
|
|
}
|
|
|
|
func (database *Database) GetProjectWithRepoName(repoName string) *Project {
|
|
|
|
db := database.getDB()
|
|
row := db.QueryRow(`SELECT id, priority, name, clone_url, git_repo, version,
|
|
motd, public, hidden, COALESCE(chain, 0), paused, assign_rate, submit_rate
|
|
FROM project WHERE LOWER(git_repo)=$1`,
|
|
strings.ToLower(repoName))
|
|
|
|
project, err := scanProject(row)
|
|
if err != nil {
|
|
logrus.WithError(err).WithFields(logrus.Fields{
|
|
"repoName": repoName,
|
|
}).Warn("Database.getProjectWithRepoName SELECT project NOT FOUND")
|
|
return nil
|
|
}
|
|
|
|
return project
|
|
}
|
|
|
|
func (database *Database) UpdateProject(project *Project) error {
|
|
|
|
db := database.getDB()
|
|
|
|
res, err := db.Exec(`UPDATE project
|
|
SET (priority, name, clone_url, git_repo, version, motd, public, hidden, chain, paused,
|
|
assign_rate, submit_rate) =
|
|
($1,$2,$3,$4,$5,$6,$7,$8,NULLIF($9, 0), $10,$11,$12)
|
|
WHERE id=$13`,
|
|
project.Priority, project.Name, project.CloneUrl, project.GitRepo, project.Version, project.Motd,
|
|
project.Public, project.Hidden, project.Chain, project.Paused, project.AssignRate, project.SubmitRate,
|
|
project.Id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
rowsAffected, _ := res.RowsAffected()
|
|
|
|
logrus.WithFields(logrus.Fields{
|
|
"project": project,
|
|
"rowsAffected": rowsAffected,
|
|
}).Trace("Database.updateProject UPDATE project")
|
|
|
|
database.projectCache[project.Id] = project
|
|
|
|
return nil
|
|
}
|
|
|
|
func (database Database) GetAllProjects(managerId int64) *[]Project {
|
|
projects := make([]Project, 0)
|
|
|
|
db := database.getDB()
|
|
var rows *sql.Rows
|
|
var err error
|
|
if managerId == 0 {
|
|
rows, err = db.Query(`SELECT
|
|
Id, priority, name, clone_url, git_repo, version, motd, public, hidden, COALESCE(chain,0), paused,
|
|
assign_rate, submit_rate
|
|
FROM project
|
|
WHERE NOT hidden
|
|
ORDER BY name`)
|
|
} else {
|
|
rows, err = db.Query(`SELECT
|
|
Id, priority, name, clone_url, git_repo, version, motd, public, hidden, COALESCE(chain,0), paused,
|
|
assign_rate, submit_rate
|
|
FROM project
|
|
LEFT JOIN manager_has_role_on_project mhrop ON mhrop.project = id AND mhrop.manager=$1
|
|
WHERE NOT hidden OR mhrop.role & 1 = 1 OR (SELECT tracker_admin FROM manager WHERE id=$1)
|
|
ORDER BY name`, managerId)
|
|
}
|
|
handleErr(err)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
for rows.Next() {
|
|
p := Project{}
|
|
err := rows.Scan(&p.Id, &p.Priority, &p.Name, &p.CloneUrl,
|
|
&p.GitRepo, &p.Version, &p.Motd, &p.Public, &p.Hidden,
|
|
&p.Chain, &p.Paused, &p.AssignRate, &p.SubmitRate)
|
|
handleErr(err)
|
|
projects = append(projects, p)
|
|
}
|
|
|
|
logrus.WithFields(logrus.Fields{
|
|
"projects": len(projects),
|
|
}).Trace("Get all projects stats")
|
|
|
|
return &projects
|
|
}
|
|
|
|
func (database *Database) GetAssigneeStats(pid int64, count int64) *[]AssignedTasks {
|
|
|
|
db := database.getDB()
|
|
assignees := make([]AssignedTasks, 0)
|
|
|
|
rows, err := db.Query(`SELECT worker.alias, COUNT(*) as wc FROM TASK
|
|
LEFT JOIN worker ON TASK.assignee = worker.id WHERE project=$1
|
|
GROUP BY worker.id ORDER BY wc LIMIT $2`, pid, count)
|
|
handleErr(err)
|
|
|
|
for rows.Next() {
|
|
assignee := AssignedTasks{}
|
|
var assigneeAlias sql.NullString
|
|
err = rows.Scan(&assigneeAlias, &assignee.TaskCount)
|
|
handleErr(err)
|
|
|
|
if assigneeAlias.Valid {
|
|
assignee.Assignee = assigneeAlias.String
|
|
} else {
|
|
assignee.Assignee = "unassigned"
|
|
}
|
|
|
|
assignees = append(assignees, assignee)
|
|
}
|
|
|
|
return &assignees
|
|
}
|
|
|
|
func (database *Database) GetSecret(pid int64, workerId int64) (secret string, err error) {
|
|
|
|
db := database.getDB()
|
|
|
|
var row *sql.Row
|
|
if workerId == 0 {
|
|
row = db.QueryRow(`SELECT secret FROM project WHERE id=$1`, pid)
|
|
} else {
|
|
row = db.QueryRow(`SELECT secret FROM project
|
|
WHERE id =$1 AND (
|
|
SELECT a.role_assign FROM worker_access a WHERE a.worker=$2 AND a.project=$1
|
|
)`, pid, workerId)
|
|
}
|
|
|
|
err = row.Scan(&secret)
|
|
return
|
|
}
|
|
|
|
func (database *Database) SetSecret(pid int64, secret string) {
|
|
|
|
db := database.getDB()
|
|
|
|
res, err := db.Exec(`UPDATE project SET secret=$1 WHERE id=$2`, secret, pid)
|
|
handleErr(err)
|
|
|
|
rowsAffected, _ := res.RowsAffected()
|
|
logrus.WithFields(logrus.Fields{
|
|
"rowsAffected": rowsAffected,
|
|
"project": pid,
|
|
}).Info("Set secret")
|
|
}
|
|
|
|
func (database *Database) GetWebhookSecret(pid int64) (secret string, err error) {
|
|
db := database.getDB()
|
|
row := db.QueryRow(`SELECT webhook_secret FROM project WHERE id=$1`, pid)
|
|
err = row.Scan(&secret)
|
|
return
|
|
}
|
|
|
|
func (database *Database) SetWebhookSecret(pid int64, secret string) (err error) {
|
|
db := database.getDB()
|
|
res, err := db.Exec(`UPDATE project SET webhook_secret=$1 WHERE id=$2`, secret, pid)
|
|
handleErr(err)
|
|
|
|
rowsAffected, _ := res.RowsAffected()
|
|
logrus.WithFields(logrus.Fields{
|
|
"project": pid,
|
|
"rowsAffected": rowsAffected,
|
|
}).Trace("Update webhook secret")
|
|
return
|
|
}
|