add issue tasks.

database/database.go

@@ -11,6 +11,7 @@ var ErrDriverNotSupported = errors.New("driver not found or supported")
 type Database interface {
 	Activities() repositories.ActivityRepository
 	Issues() repositories.IssueRepository
+	IssueTasks() repositories.IssueTaskRepository
 	Items() repositories.ItemRepository
 	Projects() repositories.ProjectRepository
 	Session() repositories.SessionRepository

database/drivers/mysqldriver/db.go

@@ -16,6 +16,7 @@ type DB struct {
 	db              *sqlx.DB
 	activities      *activityRepository
 	issues          *issueRepository
+	issueTasks      *issueTaskRepository
 	items           *itemRepository
 	projects        *projectRepository
 	sessions        *sessionRepository
@@ -31,6 +32,10 @@ func (db *DB) Issues() repositories.IssueRepository {
 	return db.issues
 }
 
+func (db *DB) IssueTasks() repositories.IssueTaskRepository {
+	return db.issueTasks
+}
+
 func (db *DB) Items() repositories.ItemRepository {
 	return db.items
 }
@@ -81,6 +86,7 @@ func Open(connectionString string) (*DB, error) {
 		return nil, err
 	}
 
+	// Setup repositories
 	activities := &activityRepository{db: db}
 	issues := &issueRepository{db: db}
 	items := &itemRepository{db: db}
@@ -88,11 +94,13 @@ func Open(connectionString string) (*DB, error) {
 	users := &userRepository{db: db}
 	sessions := &sessionRepository{db: db}
 	projectStatuses := &projectStatusRepository{db: db}
+	issueTasks := &issueTaskRepository{db: db}
 
 	return &DB{
 		db:              db,
 		activities:      activities,
 		issues:          issues,
+		issueTasks:      issueTasks,
 		items:           items,
 		projects:        projects,
 		users:           users,

database/drivers/mysqldriver/issetasks.go

@@ -0,0 +1,138 @@
+package mysqldriver
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"git.aiterp.net/stufflog/server/internal/xlerrors"
+	"git.aiterp.net/stufflog/server/models"
+	sq "github.com/Masterminds/squirrel"
+	"github.com/jmoiron/sqlx"
+	"time"
+)
+
+type issueTaskRepository struct {
+	db *sqlx.DB
+}
+
+func (r *issueTaskRepository) Find(ctx context.Context, id string) (*models.IssueTask, error) {
+	issueTask := models.IssueTask{}
+	err := r.db.GetContext(ctx, &issueTask, "SELECT * FROM issue_task WHERE issue_task_id=?", id)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return nil, xlerrors.NotFound("Issue task")
+		}
+
+		return nil, err
+	}
+
+	return &issueTask, nil
+}
+
+func (r *issueTaskRepository) List(ctx context.Context, filter models.IssueTaskFilter) ([]*models.IssueTask, error) {
+	q := sq.Select("*").From("issue_task")
+	if filter.ActivityIDs != nil {
+		q = q.Where(sq.Eq{"activity_id": filter.ActivityIDs})
+	}
+	if filter.IssueTaskIDs != nil {
+		q = q.Where(sq.Eq{"issue_id": filter.IssueTaskIDs})
+	}
+	if filter.IssueIDs != nil {
+		q = q.Where(sq.Eq{"issue_id": filter.IssueIDs})
+	}
+	if filter.MinStage != nil {
+		q = q.Where(sq.GtOrEq{"status_stage": *filter.MinStage})
+	}
+	if filter.MaxStage != nil {
+		q = q.Where(sq.LtOrEq{"status_stage": *filter.MaxStage})
+	}
+
+	query, args, err := q.ToSql()
+	if err != nil {
+		return nil, err
+	}
+
+	results := make([]*models.IssueTask, 0, 16)
+	err = r.db.SelectContext(ctx, &results, query, args...)
+	if err != nil {
+		if err == sql.ErrNoRows {
+			return []*models.IssueTask{}, nil
+		}
+
+		return nil, err
+	}
+
+	return results, nil
+}
+
+func (r *issueTaskRepository) Insert(ctx context.Context, task models.IssueTask) (*models.IssueTask, error) {
+	if task.IssueID == "" {
+		return nil, errors.New("missing issue id")
+	}
+
+	if task.CreatedTime.IsZero() {
+		task.CreatedTime = time.Now().Truncate(time.Second)
+		task.UpdatedTime = task.CreatedTime
+	}
+
+	tx, err := r.db.BeginTxx(ctx, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	nextID, err := incCounter(ctx, tx, counterKindIssueSubID, task.IssueID)
+	if err != nil {
+		_ = tx.Rollback()
+		return nil, err
+	}
+	task.ID = fmt.Sprintf("%s-%d", task.IssueID, nextID)
+
+	_, err = tx.NamedExecContext(ctx, `
+		INSERT INTO issue_task (
+		    issue_task_id, issue_id, activity_id, created_time,
+		    updated_time, due_time, status_stage, status_name,
+		    name, description, estimated_time, estimated_units,
+		    points_multiplier
+		) VALUES (
+		    :issue_task_id, :issue_id, :activity_id, :created_time,
+		    :updated_time, :due_time, :status_stage, :status_name,
+		    :name, :description, :estimated_time, :estimated_units,
+		    :points_multiplier
+		)
+	`, task)
+	if err != nil {
+		_ = tx.Rollback()
+		return nil, err
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		_ = tx.Rollback()
+		return nil, err
+	}
+
+	return &task, nil
+}
+
+func (r *issueTaskRepository) Save(ctx context.Context, task models.IssueTask) error {
+	_, err := r.db.NamedExecContext(ctx, `
+		UPDATE issue_task SET
+			due_time=:due_time,
+			status_stage=:status_stage,
+			status_name=:status_name,
+			name=:name,
+			description=:description,
+			estimated_time=:estimated_time,
+			estimated_units=:estimated_units,
+			points_multiplier=:points_multiplier
+		WHERE issue_task_id=:issue_task_id
+	`, task)
+
+	return err
+}
+
+func (r *issueTaskRepository) Delete(ctx context.Context, task models.IssueTask) error {
+	_, err := r.db.ExecContext(ctx, "DELETE FROM issue_task WHERE issue_task_id=? LIMIT 1;", task.ID)
+	return err
+}

database/drivers/mysqldriver/issues.go

@@ -13,6 +13,7 @@ import (
 )
 
 var counterKindIssueID = "NextIssueID"
+var counterKindIssueSubID = "NextIssueSubID"
 
 type issueRepository struct {
 	db *sqlx.DB

database/repositories/issuetaskrepository.go

@@ -0,0 +1,14 @@
+package repositories
+
+import (
+	"context"
+	"git.aiterp.net/stufflog/server/models"
+)
+
+type IssueTaskRepository interface {
+	Find(ctx context.Context, id string) (*models.IssueTask, error)
+	List(ctx context.Context, filter models.IssueTaskFilter) ([]*models.IssueTask, error)
+	Insert(ctx context.Context, task models.IssueTask) (*models.IssueTask, error)
+	Save(ctx context.Context, task models.IssueTask) error
+	Delete(ctx context.Context, task models.IssueTask) error
+}