Add builds UI

models/bots/task.go

@@ -5,16 +5,26 @@
 package bots
 
 import (
+	"context"
 	"errors"
 	"fmt"
 
 	"code.gitea.io/gitea/models/db"
+	repo_model "code.gitea.io/gitea/models/repo"
+	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/models/webhook"
 	"code.gitea.io/gitea/modules/timeutil"
+	"code.gitea.io/gitea/modules/util"
 
 	"github.com/google/uuid"
+	"xorm.io/builder"
 )
 
+func init() {
+	db.RegisterModel(new(Task))
+	db.RegisterModel(new(BuildIndex))
+}
+
 // TaskStatus represents a task status
 type TaskStatus int
 
@@ -31,27 +41,70 @@ const (
 
 // Task represnets bot tasks
 type Task struct {
-	ID            int64
-	UUID          string `xorm:"CHAR(36)"`
-	RepoID        int64  `xorm:"index"`
-	TriggerUserID int64
-	Ref           string
-	CommitSHA     string
-	Event         webhook.HookEventType
-	Token         string             // token for this task
-	Grant         string             // permissions for this task
-	EventPayload  string             `xorm:"LONGTEXT"`
-	RunnerID      int64              `xorm:"index"`
-	Status        TaskStatus         `xorm:"index"`
-	Created       timeutil.TimeStamp `xorm:"created"`
-	StartTime     timeutil.TimeStamp
-	EndTime       timeutil.TimeStamp
-	Updated       timeutil.TimeStamp `xorm:"updated"`
+	ID                int64
+	Title             string
+	UUID              string `xorm:"CHAR(36)"`
+	Index             int64  `xorm:"index unique(repo_index)"`
+	RepoID            int64  `xorm:"index unique(repo_index)"`
+	TriggerUserID     int64
+	TriggerUser       *user_model.User `xorm:"-"`
+	Ref               string
+	CommitSHA         string
+	Event             webhook.HookEventType
+	Token             string                           // token for this task
+	Grant             string                           // permissions for this task
+	EventPayload      string                           `xorm:"LONGTEXT"`
+	RunnerID          int64                            `xorm:"index"`
+	Status            TaskStatus                       `xorm:"index"`
+	WorkflowsStatuses map[string]map[string]TaskStatus `xorm:"LONGTEXT"`
+	Created           timeutil.TimeStamp               `xorm:"created"`
+	StartTime         timeutil.TimeStamp
+	EndTime           timeutil.TimeStamp
+	Updated           timeutil.TimeStamp `xorm:"updated"`
+}
+
+func (t *Task) IsPending() bool {
+	return t.Status == TaskPending || t.Status == TaskAssigned
+}
+
+func (t *Task) IsRunning() bool {
+	return t.Status == TaskRunning
+}
+
+func (t *Task) IsFailed() bool {
+	return t.Status == TaskFailed || t.Status == TaskCanceled || t.Status == TaskTimeout
+}
+
+func (t *Task) IsSuccess() bool {
+	return t.Status == TaskFinished
 }
 
 // TableName represents a bot task
 func (Task) TableName() string {
-	return "actions_task"
+	return "bots_task"
+}
+
+func (t *Task) HTMLURL() string {
+	return fmt.Sprintf("")
+}
+
+func updateRepoBuildsNumbers(ctx context.Context, repo *repo_model.Repository) error {
+	_, err := db.GetEngine(ctx).ID(repo.ID).
+		SetExpr("num_builds",
+			builder.Select("count(*)").From("bots_task").
+				Where(builder.Eq{"repo_id": repo.ID}),
+		).
+		SetExpr("num_closed_builds",
+			builder.Select("count(*)").From("bots_task").
+				Where(builder.Eq{
+					"repo_id": repo.ID,
+				}.And(
+					builder.In("status", TaskFailed, TaskCanceled, TaskTimeout, TaskFinished),
+				),
+				),
+		).
+		Update(repo)
+	return err
 }
 
 // InsertTask inserts a bot task
@@ -59,7 +112,27 @@ func InsertTask(t *Task) error {
 	if t.UUID == "" {
 		t.UUID = uuid.New().String()
 	}
-	return db.Insert(db.DefaultContext, t)
+	index, err := db.GetNextResourceIndex("build_index", t.RepoID)
+	if err != nil {
+		return err
+	}
+	t.Index = index
+
+	ctx, commiter, err := db.TxContext()
+	if err != nil {
+		return err
+	}
+	defer commiter.Close()
+
+	if err := db.Insert(ctx, t); err != nil {
+		return err
+	}
+
+	if err := updateRepoBuildsNumbers(ctx, &repo_model.Repository{ID: t.RepoID}); err != nil {
+		return err
+	}
+
+	return commiter.Commit()
 }
 
 // UpdateTask updates bot task
@@ -70,7 +143,9 @@ func UpdateTask(t *Task, cols ...string) error {
 
 // ErrTaskNotExist represents an error for bot task not exist
 type ErrTaskNotExist struct {
-	UUID string
+	RepoID int64
+	Index  int64
+	UUID   string
 }
 
 func (err ErrTaskNotExist) Error() string {
@@ -91,8 +166,8 @@ func GetTaskByUUID(taskUUID string) (*Task, error) {
 	return &task, nil
 }
 
-// GetCurTask return the task for the bot
-func GetCurTask(runnerID int64) (*Task, error) {
+// GetCurTaskByID return the task for the bot
+func GetCurTaskByID(runnerID int64) (*Task, error) {
 	var tasks []Task
 	// FIXME: for test, just return all tasks
 	err := db.GetEngine(db.DefaultContext).Where("status=?", TaskPending).Find(&tasks)
@@ -108,6 +183,31 @@ func GetCurTask(runnerID int64) (*Task, error) {
 	return &tasks[0], err
 }
 
+// GetCurTaskByUUID return the task for the bot
+func GetCurTaskByUUID(runnerUUID string) (*Task, error) {
+	runner, err := GetRunnerByUUID(runnerUUID)
+	if err != nil {
+		return nil, err
+	}
+	return GetCurTaskByID(runner.ID)
+}
+
+func GetTaskByRepoAndIndex(repoID, index int64) (*Task, error) {
+	var task Task
+	has, err := db.GetEngine(db.DefaultContext).Where("repo_id=?", repoID).
+		And("`index` = ?", index).
+		Get(&task)
+	if err != nil {
+		return nil, err
+	} else if !has {
+		return nil, ErrTaskNotExist{
+			RepoID: repoID,
+			Index:  index,
+		}
+	}
+	return &task, nil
+}
+
 // AssignTaskToRunner assign a task to a runner
 func AssignTaskToRunner(taskID int64, runnerID int64) error {
 	cnt, err := db.GetEngine(db.DefaultContext).
@@ -126,6 +226,41 @@ func AssignTaskToRunner(taskID int64, runnerID int64) error {
 	return nil
 }
 
+type FindTaskOptions struct {
+	db.ListOptions
+	RepoID   int64
+	IsClosed util.OptionalBool
+}
+
+func (opts FindTaskOptions) toConds() builder.Cond {
+	cond := builder.NewCond()
+	if opts.RepoID > 0 {
+		cond = cond.And(builder.Eq{"repo_id": opts.RepoID})
+	}
+	if opts.IsClosed.IsTrue() {
+		cond = cond.And(builder.Expr("status IN (?,?,?,?)", TaskCanceled, TaskFailed, TaskTimeout, TaskFinished))
+	} else if opts.IsClosed.IsFalse() {
+		cond = cond.And(builder.Expr("status IN (?,?,?)", TaskPending, TaskAssigned, TaskRunning))
+	}
+	return cond
+}
+
+func FindTasks(opts FindTaskOptions) (TaskList, error) {
+	sess := db.GetEngine(db.DefaultContext).Where(opts.toConds())
+	if opts.ListOptions.PageSize > 0 {
+		skip, take := opts.GetSkipTake()
+		sess.Limit(take, skip)
+	}
+	var tasks []*Task
+	return tasks, sess.Find(&tasks)
+}
+
+func CountTasks(opts FindTaskOptions) (int64, error) {
+	return db.GetEngine(db.DefaultContext).Table("bots_task").Where(opts.toConds()).Count()
+}
+
 type TaskStage struct{}
 
 type StageStep struct{}
+
+type BuildIndex db.ResourceIndex