item repository and api progress.
This commit is contained in:
@@ -23,6 +23,10 @@ func (d *Database) Stats(scopeID int) database.StatRepository {
|
||||
}
|
||||
|
||||
func (d *Database) Items(scopeID int) database.ItemRepository {
|
||||
return &itemRepository{db: d.db, scopeID: scopeID}
|
||||
}
|
||||
|
||||
func (d *Database) ItemsMultiScope(scopeIDs []int) database.ItemRepository {
|
||||
//TODO implement me
|
||||
panic("implement me")
|
||||
}
|
||||
|
||||
@@ -0,0 +1,354 @@
|
||||
package mysql
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"git.aiterp.net/stufflog3/stufflog3-api/internal/database/mysql/mysqlcore"
|
||||
"git.aiterp.net/stufflog3/stufflog3-api/internal/models"
|
||||
"git.aiterp.net/stufflog3/stufflog3-api/internal/slerrors"
|
||||
"git.aiterp.net/stufflog3/stufflog3-api/internal/sqltypes"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type itemRepository struct {
|
||||
db *sql.DB
|
||||
scopeID int
|
||||
}
|
||||
|
||||
func (r *itemRepository) Find(ctx context.Context, id int) (*models.Item, error) {
|
||||
res, err := mysqlcore.New(r.db).GetItem(ctx, id)
|
||||
if err != nil {
|
||||
if err == sql.ErrNoRows {
|
||||
return nil, slerrors.NotFound("Item")
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
if res.ScopeID != r.scopeID {
|
||||
return nil, slerrors.NotFound("Item")
|
||||
}
|
||||
|
||||
item := r.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(res))
|
||||
|
||||
stats, _ := mysqlcore.New(r.db).ListItemStatProgress(ctx, id)
|
||||
for _, stat := range stats {
|
||||
item.Stats = append(item.Stats, models.StatProgressEntry{
|
||||
StatEntry: models.StatEntry{
|
||||
ID: int(stat.ID.Int32),
|
||||
Name: stat.Name.String,
|
||||
Weight: stat.Weight,
|
||||
},
|
||||
Acquired: stat.Acquired,
|
||||
Required: stat.Required,
|
||||
})
|
||||
}
|
||||
|
||||
return &item, nil
|
||||
}
|
||||
|
||||
func (r *itemRepository) ListCreated(ctx context.Context, from, to time.Time) ([]models.Item, error) {
|
||||
rows, err := mysqlcore.New(r.db).ListItemsCreatedBetween(ctx, mysqlcore.ListItemsCreatedBetweenParams{
|
||||
CreatedTime: from,
|
||||
CreatedTime_2: to,
|
||||
ScopeID: r.scopeID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
items := make([]models.Item, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
items = append(items, r.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(row)))
|
||||
}
|
||||
|
||||
err = r.fillStats(ctx, items)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return items, nil
|
||||
}
|
||||
|
||||
func (r *itemRepository) ListAcquired(ctx context.Context, from, to time.Time) ([]models.Item, error) {
|
||||
rows, err := mysqlcore.New(r.db).ListItemsAcquiredBetween(ctx, mysqlcore.ListItemsAcquiredBetweenParams{
|
||||
AcquiredTime: sql.NullTime{Valid: true, Time: from},
|
||||
AcquiredTime_2: sql.NullTime{Valid: true, Time: to},
|
||||
ScopeID: r.scopeID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
items := make([]models.Item, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
items = append(items, r.resToItem(row))
|
||||
}
|
||||
|
||||
err = r.fillStats(ctx, items)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return items, nil
|
||||
}
|
||||
|
||||
func (r *itemRepository) ListScheduled(ctx context.Context, from, to models.Date) ([]models.Item, error) {
|
||||
rows, err := mysqlcore.New(r.db).ListItemsScheduledBetween(ctx, mysqlcore.ListItemsScheduledBetweenParams{
|
||||
ScheduledDate: sqltypes.NullDate{Valid: true, Date: from},
|
||||
ScheduledDate_2: sqltypes.NullDate{Valid: true, Date: to},
|
||||
ScopeID: r.scopeID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
items := make([]models.Item, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
items = append(items, r.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(row)))
|
||||
}
|
||||
|
||||
err = r.fillStats(ctx, items)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return items, nil
|
||||
}
|
||||
|
||||
func (r *itemRepository) ListLoose(ctx context.Context, from, to time.Time) ([]models.Item, error) {
|
||||
rows, err := mysqlcore.New(r.db).ListItemsLooseBetween(ctx, mysqlcore.ListItemsLooseBetweenParams{
|
||||
CreatedTime: from,
|
||||
CreatedTime_2: to,
|
||||
ScopeID: r.scopeID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
items := make([]models.Item, 0, len(rows))
|
||||
for _, row := range rows {
|
||||
items = append(items, r.resToItem(mysqlcore.ListItemsAcquiredBetweenRow(row)))
|
||||
}
|
||||
|
||||
err = r.fillStats(ctx, items)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return items, nil
|
||||
}
|
||||
|
||||
func (r *itemRepository) Create(ctx context.Context, item models.Item) (*models.Item, error) {
|
||||
item.Stats = append(item.Stats[:0:0], item.Stats...)
|
||||
|
||||
tx, err := r.db.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
q := mysqlcore.New(tx)
|
||||
|
||||
prID, acqTime, schDate := r.generateNullables(item)
|
||||
|
||||
res, err := q.InsertItem(ctx, mysqlcore.InsertItemParams{
|
||||
ScopeID: r.scopeID,
|
||||
ProjectRequirementID: prID,
|
||||
Name: item.Name,
|
||||
Description: item.Description,
|
||||
CreatedTime: time.Now(),
|
||||
CreatedUserID: item.OwnerID,
|
||||
AcquiredTime: acqTime,
|
||||
ScheduledDate: schDate,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
id, err := res.LastInsertId()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, stat := range item.Stats {
|
||||
err = q.ReplaceItemStatProgress(ctx, mysqlcore.ReplaceItemStatProgressParams{
|
||||
ItemID: int(id),
|
||||
StatID: stat.ID,
|
||||
Acquired: stat.Acquired,
|
||||
Required: stat.Required,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
err = tx.Commit()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return r.Find(ctx, int(id))
|
||||
}
|
||||
|
||||
func (r *itemRepository) generateNullables(item models.Item) (prID sql.NullInt32, acqTime sql.NullTime, schDate sqltypes.NullDate) {
|
||||
if item.ProjectRequirementID != nil {
|
||||
prID.Valid = true
|
||||
prID.Int32 = int32(*item.ProjectRequirementID)
|
||||
}
|
||||
if item.AcquiredTime != nil {
|
||||
acqTime.Valid = true
|
||||
acqTime.Time = *item.AcquiredTime
|
||||
}
|
||||
if item.ScheduledDate != nil {
|
||||
schDate.Valid = true
|
||||
schDate.Date = *item.ScheduledDate
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
func (r *itemRepository) Update(ctx context.Context, item models.Item, update models.ItemUpdate) (*models.Item, error) {
|
||||
tx, err := r.db.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
q := mysqlcore.New(r.db)
|
||||
|
||||
item.ApplyUpdate(update)
|
||||
|
||||
prID, acqTime, schDate := r.generateNullables(item)
|
||||
|
||||
err = q.UpdateItem(ctx, mysqlcore.UpdateItemParams{
|
||||
ID: item.ID,
|
||||
|
||||
ProjectRequirementID: prID,
|
||||
Name: item.Name,
|
||||
Description: item.Description,
|
||||
AcquiredTime: acqTime,
|
||||
ScheduledDate: schDate,
|
||||
CreatedUserID: item.OwnerID,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
for _, stat := range update.Stats {
|
||||
if stat.Acquired == 0 && stat.Required == 0 {
|
||||
err = q.DeleteItemStatProgress(ctx, mysqlcore.DeleteItemStatProgressParams{
|
||||
ItemID: item.ID,
|
||||
StatID: stat.ID,
|
||||
})
|
||||
} else {
|
||||
err = q.ReplaceItemStatProgress(ctx, mysqlcore.ReplaceItemStatProgressParams{
|
||||
ItemID: item.ID,
|
||||
StatID: stat.ID,
|
||||
Acquired: stat.Acquired,
|
||||
Required: stat.Required,
|
||||
})
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
err = tx.Commit()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return r.Find(ctx, item.ID)
|
||||
}
|
||||
|
||||
func (r *itemRepository) Delete(ctx context.Context, item models.Item) error {
|
||||
tx, err := r.db.BeginTx(ctx, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer tx.Rollback()
|
||||
q := mysqlcore.New(r.db)
|
||||
|
||||
err = q.DeleteItem(ctx, item.ID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = q.ClearItemStatProgress(ctx, item.ID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
return tx.Commit()
|
||||
}
|
||||
|
||||
func (r *itemRepository) resToItem(res mysqlcore.ListItemsAcquiredBetweenRow) models.Item {
|
||||
item := models.Item{
|
||||
ID: res.ID,
|
||||
ScopeID: res.ScopeID,
|
||||
OwnerID: res.CreatedUserID,
|
||||
Name: res.Name,
|
||||
Description: res.Description,
|
||||
CreatedTime: res.CreatedTime.UTC(),
|
||||
}
|
||||
if res.ProjectRequirementID.Valid {
|
||||
projectRequirementID := int(res.ProjectRequirementID.Int32)
|
||||
projectID := int(res.ProjectID.Int32)
|
||||
item.ProjectRequirementID = &projectRequirementID
|
||||
item.ProjectID = &projectID
|
||||
}
|
||||
if res.ScheduledDate.Valid {
|
||||
item.ScheduledDate = &res.ScheduledDate.Date
|
||||
}
|
||||
if res.AcquiredTime.Valid {
|
||||
item.AcquiredTime = &res.AcquiredTime.Time
|
||||
}
|
||||
|
||||
return item
|
||||
}
|
||||
|
||||
func (r *itemRepository) fillStats(ctx context.Context, items []models.Item) error {
|
||||
if len(items) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
ids := make([]interface{}, 0, len(items))
|
||||
for _, item := range items {
|
||||
ids = append(ids, item.ID)
|
||||
}
|
||||
query := `
|
||||
SELECT isp.item_id, isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
|
||||
LEFT JOIN stat s ON s.id = isp.stat_id
|
||||
WHERE item_id IN (?` + strings.Repeat(",?", len(ids)-1) + `);
|
||||
`
|
||||
|
||||
rows, err := r.db.QueryContext(ctx, query, ids...)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for rows.Next() {
|
||||
var itemID, required, acquired, statID int
|
||||
var statName string
|
||||
var statWeight float64
|
||||
|
||||
err = rows.Scan(&itemID, &required, &acquired, &statID, &statName, &statWeight)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for i := range items {
|
||||
if items[i].ID == itemID {
|
||||
items[i].Stats = append(items[i].Stats, models.StatProgressEntry{
|
||||
StatEntry: models.StatEntry{
|
||||
ID: statID,
|
||||
Name: statName,
|
||||
Weight: statWeight,
|
||||
},
|
||||
Acquired: acquired,
|
||||
Required: required,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
@@ -7,7 +7,6 @@ package mysqlcore
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
type DBTX interface {
|
||||
@@ -21,198 +20,12 @@ func New(db DBTX) *Queries {
|
||||
return &Queries{db: db}
|
||||
}
|
||||
|
||||
func Prepare(ctx context.Context, db DBTX) (*Queries, error) {
|
||||
q := Queries{db: db}
|
||||
var err error
|
||||
if q.deleteAllScopeMembersStmt, err = db.PrepareContext(ctx, deleteAllScopeMembers); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query DeleteAllScopeMembers: %w", err)
|
||||
}
|
||||
if q.deleteScopeStmt, err = db.PrepareContext(ctx, deleteScope); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query DeleteScope: %w", err)
|
||||
}
|
||||
if q.deleteScopeMemberStmt, err = db.PrepareContext(ctx, deleteScopeMember); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query DeleteScopeMember: %w", err)
|
||||
}
|
||||
if q.getScopeStmt, err = db.PrepareContext(ctx, getScope); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query GetScope: %w", err)
|
||||
}
|
||||
if q.getScopeDisplayNameStmt, err = db.PrepareContext(ctx, getScopeDisplayName); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query GetScopeDisplayName: %w", err)
|
||||
}
|
||||
if q.getScopeWithDisplayNameStmt, err = db.PrepareContext(ctx, getScopeWithDisplayName); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query GetScopeWithDisplayName: %w", err)
|
||||
}
|
||||
if q.insertScopeStmt, err = db.PrepareContext(ctx, insertScope); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query InsertScope: %w", err)
|
||||
}
|
||||
if q.listProjectEntriesStmt, err = db.PrepareContext(ctx, listProjectEntries); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query ListProjectEntries: %w", err)
|
||||
}
|
||||
if q.listScopeMembersStmt, err = db.PrepareContext(ctx, listScopeMembers); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query ListScopeMembers: %w", err)
|
||||
}
|
||||
if q.listScopesStmt, err = db.PrepareContext(ctx, listScopes); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query ListScopes: %w", err)
|
||||
}
|
||||
if q.listScopesByUserStmt, err = db.PrepareContext(ctx, listScopesByUser); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query ListScopesByUser: %w", err)
|
||||
}
|
||||
if q.listStatsStmt, err = db.PrepareContext(ctx, listStats); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query ListStats: %w", err)
|
||||
}
|
||||
if q.updateScopeStmt, err = db.PrepareContext(ctx, updateScope); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query UpdateScope: %w", err)
|
||||
}
|
||||
if q.updateScopeMemberStmt, err = db.PrepareContext(ctx, updateScopeMember); err != nil {
|
||||
return nil, fmt.Errorf("error preparing query UpdateScopeMember: %w", err)
|
||||
}
|
||||
return &q, nil
|
||||
}
|
||||
|
||||
func (q *Queries) Close() error {
|
||||
var err error
|
||||
if q.deleteAllScopeMembersStmt != nil {
|
||||
if cerr := q.deleteAllScopeMembersStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing deleteAllScopeMembersStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.deleteScopeStmt != nil {
|
||||
if cerr := q.deleteScopeStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing deleteScopeStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.deleteScopeMemberStmt != nil {
|
||||
if cerr := q.deleteScopeMemberStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing deleteScopeMemberStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.getScopeStmt != nil {
|
||||
if cerr := q.getScopeStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing getScopeStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.getScopeDisplayNameStmt != nil {
|
||||
if cerr := q.getScopeDisplayNameStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing getScopeDisplayNameStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.getScopeWithDisplayNameStmt != nil {
|
||||
if cerr := q.getScopeWithDisplayNameStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing getScopeWithDisplayNameStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.insertScopeStmt != nil {
|
||||
if cerr := q.insertScopeStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing insertScopeStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.listProjectEntriesStmt != nil {
|
||||
if cerr := q.listProjectEntriesStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing listProjectEntriesStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.listScopeMembersStmt != nil {
|
||||
if cerr := q.listScopeMembersStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing listScopeMembersStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.listScopesStmt != nil {
|
||||
if cerr := q.listScopesStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing listScopesStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.listScopesByUserStmt != nil {
|
||||
if cerr := q.listScopesByUserStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing listScopesByUserStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.listStatsStmt != nil {
|
||||
if cerr := q.listStatsStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing listStatsStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.updateScopeStmt != nil {
|
||||
if cerr := q.updateScopeStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing updateScopeStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
if q.updateScopeMemberStmt != nil {
|
||||
if cerr := q.updateScopeMemberStmt.Close(); cerr != nil {
|
||||
err = fmt.Errorf("error closing updateScopeMemberStmt: %w", cerr)
|
||||
}
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (q *Queries) exec(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) (sql.Result, error) {
|
||||
switch {
|
||||
case stmt != nil && q.tx != nil:
|
||||
return q.tx.StmtContext(ctx, stmt).ExecContext(ctx, args...)
|
||||
case stmt != nil:
|
||||
return stmt.ExecContext(ctx, args...)
|
||||
default:
|
||||
return q.db.ExecContext(ctx, query, args...)
|
||||
}
|
||||
}
|
||||
|
||||
func (q *Queries) query(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) (*sql.Rows, error) {
|
||||
switch {
|
||||
case stmt != nil && q.tx != nil:
|
||||
return q.tx.StmtContext(ctx, stmt).QueryContext(ctx, args...)
|
||||
case stmt != nil:
|
||||
return stmt.QueryContext(ctx, args...)
|
||||
default:
|
||||
return q.db.QueryContext(ctx, query, args...)
|
||||
}
|
||||
}
|
||||
|
||||
func (q *Queries) queryRow(ctx context.Context, stmt *sql.Stmt, query string, args ...interface{}) *sql.Row {
|
||||
switch {
|
||||
case stmt != nil && q.tx != nil:
|
||||
return q.tx.StmtContext(ctx, stmt).QueryRowContext(ctx, args...)
|
||||
case stmt != nil:
|
||||
return stmt.QueryRowContext(ctx, args...)
|
||||
default:
|
||||
return q.db.QueryRowContext(ctx, query, args...)
|
||||
}
|
||||
}
|
||||
|
||||
type Queries struct {
|
||||
db DBTX
|
||||
tx *sql.Tx
|
||||
deleteAllScopeMembersStmt *sql.Stmt
|
||||
deleteScopeStmt *sql.Stmt
|
||||
deleteScopeMemberStmt *sql.Stmt
|
||||
getScopeStmt *sql.Stmt
|
||||
getScopeDisplayNameStmt *sql.Stmt
|
||||
getScopeWithDisplayNameStmt *sql.Stmt
|
||||
insertScopeStmt *sql.Stmt
|
||||
listProjectEntriesStmt *sql.Stmt
|
||||
listScopeMembersStmt *sql.Stmt
|
||||
listScopesStmt *sql.Stmt
|
||||
listScopesByUserStmt *sql.Stmt
|
||||
listStatsStmt *sql.Stmt
|
||||
updateScopeStmt *sql.Stmt
|
||||
updateScopeMemberStmt *sql.Stmt
|
||||
db DBTX
|
||||
}
|
||||
|
||||
func (q *Queries) WithTx(tx *sql.Tx) *Queries {
|
||||
return &Queries{
|
||||
db: tx,
|
||||
tx: tx,
|
||||
deleteAllScopeMembersStmt: q.deleteAllScopeMembersStmt,
|
||||
deleteScopeStmt: q.deleteScopeStmt,
|
||||
deleteScopeMemberStmt: q.deleteScopeMemberStmt,
|
||||
getScopeStmt: q.getScopeStmt,
|
||||
getScopeDisplayNameStmt: q.getScopeDisplayNameStmt,
|
||||
getScopeWithDisplayNameStmt: q.getScopeWithDisplayNameStmt,
|
||||
insertScopeStmt: q.insertScopeStmt,
|
||||
listProjectEntriesStmt: q.listProjectEntriesStmt,
|
||||
listScopeMembersStmt: q.listScopeMembersStmt,
|
||||
listScopesStmt: q.listScopesStmt,
|
||||
listScopesByUserStmt: q.listScopesByUserStmt,
|
||||
listStatsStmt: q.listStatsStmt,
|
||||
updateScopeStmt: q.updateScopeStmt,
|
||||
updateScopeMemberStmt: q.updateScopeMemberStmt,
|
||||
db: tx,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,791 @@
|
||||
// Code generated by sqlc. DO NOT EDIT.
|
||||
// versions:
|
||||
// sqlc v1.13.0
|
||||
// source: item.sql
|
||||
|
||||
package mysqlcore
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"time"
|
||||
|
||||
"git.aiterp.net/stufflog3/stufflog3-api/internal/sqltypes"
|
||||
)
|
||||
|
||||
const clearItemStatProgress = `-- name: ClearItemStatProgress :exec
|
||||
DELETE FROM item_stat_progress WHERE item_id = ?
|
||||
`
|
||||
|
||||
func (q *Queries) ClearItemStatProgress(ctx context.Context, itemID int) error {
|
||||
_, err := q.db.ExecContext(ctx, clearItemStatProgress, itemID)
|
||||
return err
|
||||
}
|
||||
|
||||
const deleteItem = `-- name: DeleteItem :exec
|
||||
DELETE FROM item WHERE id = ?
|
||||
`
|
||||
|
||||
func (q *Queries) DeleteItem(ctx context.Context, id int) error {
|
||||
_, err := q.db.ExecContext(ctx, deleteItem, id)
|
||||
return err
|
||||
}
|
||||
|
||||
const deleteItemStatProgress = `-- name: DeleteItemStatProgress :exec
|
||||
DELETE FROM item_stat_progress WHERE item_id = ? AND stat_id = ?
|
||||
`
|
||||
|
||||
type DeleteItemStatProgressParams struct {
|
||||
ItemID int
|
||||
StatID int
|
||||
}
|
||||
|
||||
func (q *Queries) DeleteItemStatProgress(ctx context.Context, arg DeleteItemStatProgressParams) error {
|
||||
_, err := q.db.ExecContext(ctx, deleteItemStatProgress, arg.ItemID, arg.StatID)
|
||||
return err
|
||||
}
|
||||
|
||||
const getItem = `-- name: GetItem :one
|
||||
SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.id = ?
|
||||
`
|
||||
|
||||
type GetItemRow struct {
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ProjectID sql.NullInt32
|
||||
}
|
||||
|
||||
func (q *Queries) GetItem(ctx context.Context, id int) (GetItemRow, error) {
|
||||
row := q.db.QueryRowContext(ctx, getItem, id)
|
||||
var i GetItemRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectRequirementID,
|
||||
&i.Name,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
&i.CreatedUserID,
|
||||
&i.AcquiredTime,
|
||||
&i.ScheduledDate,
|
||||
&i.ProjectID,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const getItemStatProgressBetween = `-- name: GetItemStatProgressBetween :one
|
||||
SELECT s.id, s.name, s.weight, SUM(isp.acquired), SUM(isp.required) FROM item i
|
||||
LEFT JOIN item_stat_progress isp on i.id = isp.item_id
|
||||
LEFT JOIN stat s on isp.stat_id = s.id
|
||||
WHERE i.acquired_time >= ?
|
||||
AND i.acquired_time < ?
|
||||
AND i.scope_id = ?
|
||||
GROUP BY stat_id
|
||||
`
|
||||
|
||||
type GetItemStatProgressBetweenParams struct {
|
||||
AcquiredTime sql.NullTime
|
||||
AcquiredTime_2 sql.NullTime
|
||||
ScopeID int
|
||||
}
|
||||
|
||||
type GetItemStatProgressBetweenRow struct {
|
||||
ID sql.NullInt32
|
||||
Name sql.NullString
|
||||
Weight float64
|
||||
Sum interface{}
|
||||
Sum_2 interface{}
|
||||
}
|
||||
|
||||
func (q *Queries) GetItemStatProgressBetween(ctx context.Context, arg GetItemStatProgressBetweenParams) (GetItemStatProgressBetweenRow, error) {
|
||||
row := q.db.QueryRowContext(ctx, getItemStatProgressBetween, arg.AcquiredTime, arg.AcquiredTime_2, arg.ScopeID)
|
||||
var i GetItemStatProgressBetweenRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.Name,
|
||||
&i.Weight,
|
||||
&i.Sum,
|
||||
&i.Sum_2,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const insertItem = `-- name: InsertItem :execresult
|
||||
INSERT INTO item (scope_id, project_requirement_id, name, description, created_time, created_user_id, acquired_time, scheduled_date)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
||||
`
|
||||
|
||||
type InsertItemParams struct {
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
}
|
||||
|
||||
func (q *Queries) InsertItem(ctx context.Context, arg InsertItemParams) (sql.Result, error) {
|
||||
return q.db.ExecContext(ctx, insertItem,
|
||||
arg.ScopeID,
|
||||
arg.ProjectRequirementID,
|
||||
arg.Name,
|
||||
arg.Description,
|
||||
arg.CreatedTime,
|
||||
arg.CreatedUserID,
|
||||
arg.AcquiredTime,
|
||||
arg.ScheduledDate,
|
||||
)
|
||||
}
|
||||
|
||||
const listItemStatProgress = `-- name: ListItemStatProgress :many
|
||||
SELECT isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
|
||||
LEFT JOIN stat s ON s.id = isp.stat_id
|
||||
WHERE item_id = ?
|
||||
`
|
||||
|
||||
type ListItemStatProgressRow struct {
|
||||
Required int
|
||||
Acquired int
|
||||
ID sql.NullInt32
|
||||
Name sql.NullString
|
||||
Weight float64
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemStatProgress(ctx context.Context, itemID int) ([]ListItemStatProgressRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemStatProgress, itemID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemStatProgressRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemStatProgressRow
|
||||
if err := rows.Scan(
|
||||
&i.Required,
|
||||
&i.Acquired,
|
||||
&i.ID,
|
||||
&i.Name,
|
||||
&i.Weight,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listItemStatProgressMulti = `-- name: ListItemStatProgressMulti :many
|
||||
SELECT isp.item_id, isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
|
||||
LEFT JOIN stat s ON s.id = isp.stat_id
|
||||
WHERE item_id IN (?, ?, ?, ?, ?, ?, ?, ?)
|
||||
`
|
||||
|
||||
type ListItemStatProgressMultiParams struct {
|
||||
ItemID int
|
||||
ItemID_2 int
|
||||
ItemID_3 int
|
||||
ItemID_4 int
|
||||
ItemID_5 int
|
||||
ItemID_6 int
|
||||
ItemID_7 int
|
||||
ItemID_8 int
|
||||
}
|
||||
|
||||
type ListItemStatProgressMultiRow struct {
|
||||
ItemID int
|
||||
Required int
|
||||
Acquired int
|
||||
ID sql.NullInt32
|
||||
Name sql.NullString
|
||||
Weight float64
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemStatProgressMulti(ctx context.Context, arg ListItemStatProgressMultiParams) ([]ListItemStatProgressMultiRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemStatProgressMulti,
|
||||
arg.ItemID,
|
||||
arg.ItemID_2,
|
||||
arg.ItemID_3,
|
||||
arg.ItemID_4,
|
||||
arg.ItemID_5,
|
||||
arg.ItemID_6,
|
||||
arg.ItemID_7,
|
||||
arg.ItemID_8,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemStatProgressMultiRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemStatProgressMultiRow
|
||||
if err := rows.Scan(
|
||||
&i.ItemID,
|
||||
&i.Required,
|
||||
&i.Acquired,
|
||||
&i.ID,
|
||||
&i.Name,
|
||||
&i.Weight,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listItemsAcquiredBetween = `-- name: ListItemsAcquiredBetween :many
|
||||
SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.acquired_time >= ?
|
||||
AND i.acquired_time < ?
|
||||
AND i.scope_id = ?
|
||||
`
|
||||
|
||||
type ListItemsAcquiredBetweenParams struct {
|
||||
AcquiredTime sql.NullTime
|
||||
AcquiredTime_2 sql.NullTime
|
||||
ScopeID int
|
||||
}
|
||||
|
||||
type ListItemsAcquiredBetweenRow struct {
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ProjectID sql.NullInt32
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemsAcquiredBetween(ctx context.Context, arg ListItemsAcquiredBetweenParams) ([]ListItemsAcquiredBetweenRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemsAcquiredBetween, arg.AcquiredTime, arg.AcquiredTime_2, arg.ScopeID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemsAcquiredBetweenRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemsAcquiredBetweenRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectRequirementID,
|
||||
&i.Name,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
&i.CreatedUserID,
|
||||
&i.AcquiredTime,
|
||||
&i.ScheduledDate,
|
||||
&i.ProjectID,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listItemsByProject = `-- name: ListItemsByProject :many
|
||||
SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE pr.project_id = ?
|
||||
`
|
||||
|
||||
type ListItemsByProjectRow struct {
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ProjectID sql.NullInt32
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemsByProject(ctx context.Context, projectID int) ([]ListItemsByProjectRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemsByProject, projectID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemsByProjectRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemsByProjectRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectRequirementID,
|
||||
&i.Name,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
&i.CreatedUserID,
|
||||
&i.AcquiredTime,
|
||||
&i.ScheduledDate,
|
||||
&i.ProjectID,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listItemsCreatedBetween = `-- name: ListItemsCreatedBetween :many
|
||||
SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.created_time >= ?
|
||||
AND i.created_time < ?
|
||||
AND i.scope_id = ?
|
||||
`
|
||||
|
||||
type ListItemsCreatedBetweenParams struct {
|
||||
CreatedTime time.Time
|
||||
CreatedTime_2 time.Time
|
||||
ScopeID int
|
||||
}
|
||||
|
||||
type ListItemsCreatedBetweenRow struct {
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ProjectID sql.NullInt32
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemsCreatedBetween(ctx context.Context, arg ListItemsCreatedBetweenParams) ([]ListItemsCreatedBetweenRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemsCreatedBetween, arg.CreatedTime, arg.CreatedTime_2, arg.ScopeID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemsCreatedBetweenRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemsCreatedBetweenRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectRequirementID,
|
||||
&i.Name,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
&i.CreatedUserID,
|
||||
&i.AcquiredTime,
|
||||
&i.ScheduledDate,
|
||||
&i.ProjectID,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listItemsCreatedBetweenNoScope = `-- name: ListItemsCreatedBetweenNoScope :many
|
||||
SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.created_time >= ?
|
||||
AND i.created_time < ?
|
||||
`
|
||||
|
||||
type ListItemsCreatedBetweenNoScopeParams struct {
|
||||
CreatedTime time.Time
|
||||
CreatedTime_2 time.Time
|
||||
}
|
||||
|
||||
type ListItemsCreatedBetweenNoScopeRow struct {
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ProjectID sql.NullInt32
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemsCreatedBetweenNoScope(ctx context.Context, arg ListItemsCreatedBetweenNoScopeParams) ([]ListItemsCreatedBetweenNoScopeRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemsCreatedBetweenNoScope, arg.CreatedTime, arg.CreatedTime_2)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemsCreatedBetweenNoScopeRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemsCreatedBetweenNoScopeRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectRequirementID,
|
||||
&i.Name,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
&i.CreatedUserID,
|
||||
&i.AcquiredTime,
|
||||
&i.ScheduledDate,
|
||||
&i.ProjectID,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listItemsLooseBetween = `-- name: ListItemsLooseBetween :many
|
||||
SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.created_time >= ?
|
||||
AND i.created_time < ?
|
||||
AND i.scope_id = ?
|
||||
AND i.scheduled_date IS NULL
|
||||
AND i.acquired_time IS NULL
|
||||
`
|
||||
|
||||
type ListItemsLooseBetweenParams struct {
|
||||
CreatedTime time.Time
|
||||
CreatedTime_2 time.Time
|
||||
ScopeID int
|
||||
}
|
||||
|
||||
type ListItemsLooseBetweenRow struct {
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ProjectID sql.NullInt32
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemsLooseBetween(ctx context.Context, arg ListItemsLooseBetweenParams) ([]ListItemsLooseBetweenRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemsLooseBetween, arg.CreatedTime, arg.CreatedTime_2, arg.ScopeID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemsLooseBetweenRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemsLooseBetweenRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectRequirementID,
|
||||
&i.Name,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
&i.CreatedUserID,
|
||||
&i.AcquiredTime,
|
||||
&i.ScheduledDate,
|
||||
&i.ProjectID,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listItemsLooseBetweenNoScope = `-- name: ListItemsLooseBetweenNoScope :many
|
||||
SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.created_time >= ?
|
||||
AND i.created_time < ?
|
||||
AND i.scheduled_date IS NULL
|
||||
AND i.acquired_time IS NULL
|
||||
`
|
||||
|
||||
type ListItemsLooseBetweenNoScopeParams struct {
|
||||
CreatedTime time.Time
|
||||
CreatedTime_2 time.Time
|
||||
}
|
||||
|
||||
type ListItemsLooseBetweenNoScopeRow struct {
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ProjectID sql.NullInt32
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemsLooseBetweenNoScope(ctx context.Context, arg ListItemsLooseBetweenNoScopeParams) ([]ListItemsLooseBetweenNoScopeRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemsLooseBetweenNoScope, arg.CreatedTime, arg.CreatedTime_2)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemsLooseBetweenNoScopeRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemsLooseBetweenNoScopeRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectRequirementID,
|
||||
&i.Name,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
&i.CreatedUserID,
|
||||
&i.AcquiredTime,
|
||||
&i.ScheduledDate,
|
||||
&i.ProjectID,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listItemsScheduledBetween = `-- name: ListItemsScheduledBetween :many
|
||||
SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.scheduled_date >= ?
|
||||
AND i.scheduled_date < ?
|
||||
AND i.scope_id = ?
|
||||
`
|
||||
|
||||
type ListItemsScheduledBetweenParams struct {
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ScheduledDate_2 sqltypes.NullDate
|
||||
ScopeID int
|
||||
}
|
||||
|
||||
type ListItemsScheduledBetweenRow struct {
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ProjectID sql.NullInt32
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemsScheduledBetween(ctx context.Context, arg ListItemsScheduledBetweenParams) ([]ListItemsScheduledBetweenRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemsScheduledBetween, arg.ScheduledDate, arg.ScheduledDate_2, arg.ScopeID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemsScheduledBetweenRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemsScheduledBetweenRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectRequirementID,
|
||||
&i.Name,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
&i.CreatedUserID,
|
||||
&i.AcquiredTime,
|
||||
&i.ScheduledDate,
|
||||
&i.ProjectID,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listItemsScheduledBetweenNoScope = `-- name: ListItemsScheduledBetweenNoScope :many
|
||||
SELECT i.id, i.scope_id, i.project_requirement_id, i.name, i.description, i.created_time, i.created_user_id, i.acquired_time, i.scheduled_date, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.scheduled_date >= ?
|
||||
AND i.scheduled_date < ?
|
||||
`
|
||||
|
||||
type ListItemsScheduledBetweenNoScopeParams struct {
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ScheduledDate_2 sqltypes.NullDate
|
||||
}
|
||||
|
||||
type ListItemsScheduledBetweenNoScopeRow struct {
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
ProjectID sql.NullInt32
|
||||
}
|
||||
|
||||
func (q *Queries) ListItemsScheduledBetweenNoScope(ctx context.Context, arg ListItemsScheduledBetweenNoScopeParams) ([]ListItemsScheduledBetweenNoScopeRow, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listItemsScheduledBetweenNoScope, arg.ScheduledDate, arg.ScheduledDate_2)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ListItemsScheduledBetweenNoScopeRow{}
|
||||
for rows.Next() {
|
||||
var i ListItemsScheduledBetweenNoScopeRow
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectRequirementID,
|
||||
&i.Name,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
&i.CreatedUserID,
|
||||
&i.AcquiredTime,
|
||||
&i.ScheduledDate,
|
||||
&i.ProjectID,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const replaceItemStatProgress = `-- name: ReplaceItemStatProgress :exec
|
||||
REPLACE INTO item_stat_progress (item_id, stat_id, acquired, required)
|
||||
VALUES (?, ?, ?, ?)
|
||||
`
|
||||
|
||||
type ReplaceItemStatProgressParams struct {
|
||||
ItemID int
|
||||
StatID int
|
||||
Acquired int
|
||||
Required int
|
||||
}
|
||||
|
||||
func (q *Queries) ReplaceItemStatProgress(ctx context.Context, arg ReplaceItemStatProgressParams) error {
|
||||
_, err := q.db.ExecContext(ctx, replaceItemStatProgress,
|
||||
arg.ItemID,
|
||||
arg.StatID,
|
||||
arg.Acquired,
|
||||
arg.Required,
|
||||
)
|
||||
return err
|
||||
}
|
||||
|
||||
const updateItem = `-- name: UpdateItem :exec
|
||||
UPDATE item
|
||||
SET project_requirement_id = ?,
|
||||
name = ?,
|
||||
description = ?,
|
||||
acquired_time = ?,
|
||||
scheduled_date = ?,
|
||||
created_user_id = ?
|
||||
WHERE id = ?
|
||||
`
|
||||
|
||||
type UpdateItemParams struct {
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
CreatedUserID string
|
||||
ID int
|
||||
}
|
||||
|
||||
func (q *Queries) UpdateItem(ctx context.Context, arg UpdateItemParams) error {
|
||||
_, err := q.db.ExecContext(ctx, updateItem,
|
||||
arg.ProjectRequirementID,
|
||||
arg.Name,
|
||||
arg.Description,
|
||||
arg.AcquiredTime,
|
||||
arg.ScheduledDate,
|
||||
arg.CreatedUserID,
|
||||
arg.ID,
|
||||
)
|
||||
return err
|
||||
}
|
||||
@@ -12,67 +12,67 @@ import (
|
||||
)
|
||||
|
||||
type Item struct {
|
||||
ID int `json:"id"`
|
||||
ScopeID int `json:"scope_id"`
|
||||
ProjectRequirementID sql.NullInt32 `json:"project_requirement_id"`
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description"`
|
||||
CreatedTime time.Time `json:"created_time"`
|
||||
CreatedUserID string `json:"created_user_id"`
|
||||
AcquiredTime sql.NullTime `json:"acquired_time"`
|
||||
ScheduledDate sql.NullTime `json:"scheduled_date"`
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectRequirementID sql.NullInt32
|
||||
Name string
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
CreatedUserID string
|
||||
AcquiredTime sql.NullTime
|
||||
ScheduledDate sqltypes.NullDate
|
||||
}
|
||||
|
||||
type ItemStatProgress struct {
|
||||
ItemID int `json:"item_id"`
|
||||
StatID int `json:"stat_id"`
|
||||
Acquired int `json:"acquired"`
|
||||
Required int `json:"required"`
|
||||
ItemID int
|
||||
StatID int
|
||||
Acquired int
|
||||
Required int
|
||||
}
|
||||
|
||||
type Project struct {
|
||||
ID int `json:"id"`
|
||||
ScopeID int `json:"scope_id"`
|
||||
AuthorID string `json:"author_id"`
|
||||
Name string `json:"name"`
|
||||
Status int `json:"status"`
|
||||
Description string `json:"description"`
|
||||
CreatedTime time.Time `json:"created_time"`
|
||||
ID int
|
||||
ScopeID int
|
||||
AuthorID string
|
||||
Name string
|
||||
Status int
|
||||
Description string
|
||||
CreatedTime time.Time
|
||||
}
|
||||
|
||||
type ProjectRequirement struct {
|
||||
ID int `json:"id"`
|
||||
ScopeID int `json:"scope_id"`
|
||||
ProjectID int `json:"project_id"`
|
||||
Name string `json:"name"`
|
||||
Status int `json:"status"`
|
||||
Description string `json:"description"`
|
||||
ID int
|
||||
ScopeID int
|
||||
ProjectID int
|
||||
Name string
|
||||
Status int
|
||||
Description string
|
||||
}
|
||||
|
||||
type ProjectRequirementStat struct {
|
||||
ProjectRequirementID int `json:"project_requirement_id"`
|
||||
StatID int `json:"stat_id"`
|
||||
Required int `json:"required"`
|
||||
ProjectRequirementID int
|
||||
StatID int
|
||||
Required int
|
||||
}
|
||||
|
||||
type Scope struct {
|
||||
ID int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Abbreviation string `json:"abbreviation"`
|
||||
ID int
|
||||
Name string
|
||||
Abbreviation string
|
||||
}
|
||||
|
||||
type ScopeMember struct {
|
||||
ScopeID int `json:"scope_id"`
|
||||
UserID string `json:"user_id"`
|
||||
Name string `json:"name"`
|
||||
Owner bool `json:"owner"`
|
||||
ScopeID int
|
||||
UserID string
|
||||
Name string
|
||||
Owner bool
|
||||
}
|
||||
|
||||
type Stat struct {
|
||||
ID int `json:"id"`
|
||||
ScopeID int `json:"scope_id"`
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description"`
|
||||
Weight float64 `json:"weight"`
|
||||
AllowedAmounts sqltypes.NullRawMessage `json:"allowed_amounts"`
|
||||
ID int
|
||||
ScopeID int
|
||||
Name string
|
||||
Description string
|
||||
Weight float64
|
||||
AllowedAmounts sqltypes.NullRawMessage
|
||||
}
|
||||
|
||||
@@ -9,6 +9,25 @@ import (
|
||||
"context"
|
||||
)
|
||||
|
||||
const getProject = `-- name: GetProject :one
|
||||
SELECT id, scope_id, author_id, name, status, description, created_time FROM project WHERE id = ?
|
||||
`
|
||||
|
||||
func (q *Queries) GetProject(ctx context.Context, id int) (Project, error) {
|
||||
row := q.db.QueryRowContext(ctx, getProject, id)
|
||||
var i Project
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.AuthorID,
|
||||
&i.Name,
|
||||
&i.Status,
|
||||
&i.Description,
|
||||
&i.CreatedTime,
|
||||
)
|
||||
return i, err
|
||||
}
|
||||
|
||||
const listProjectEntries = `-- name: ListProjectEntries :many
|
||||
SELECT id, name, status FROM project
|
||||
WHERE scope_id = ?
|
||||
@@ -16,13 +35,13 @@ ORDER BY status, created_time
|
||||
`
|
||||
|
||||
type ListProjectEntriesRow struct {
|
||||
ID int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Status int `json:"status"`
|
||||
ID int
|
||||
Name string
|
||||
Status int
|
||||
}
|
||||
|
||||
func (q *Queries) ListProjectEntries(ctx context.Context, scopeID int) ([]ListProjectEntriesRow, error) {
|
||||
rows, err := q.query(ctx, q.listProjectEntriesStmt, listProjectEntries, scopeID)
|
||||
rows, err := q.db.QueryContext(ctx, listProjectEntries, scopeID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -43,3 +62,37 @@ func (q *Queries) ListProjectEntries(ctx context.Context, scopeID int) ([]ListPr
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
const listProjectRequirementsByProjectID = `-- name: ListProjectRequirementsByProjectID :many
|
||||
SELECT id, scope_id, project_id, name, status, description FROM project_requirement WHERE project_id = ?
|
||||
`
|
||||
|
||||
func (q *Queries) ListProjectRequirementsByProjectID(ctx context.Context, projectID int) ([]ProjectRequirement, error) {
|
||||
rows, err := q.db.QueryContext(ctx, listProjectRequirementsByProjectID, projectID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
items := []ProjectRequirement{}
|
||||
for rows.Next() {
|
||||
var i ProjectRequirement
|
||||
if err := rows.Scan(
|
||||
&i.ID,
|
||||
&i.ScopeID,
|
||||
&i.ProjectID,
|
||||
&i.Name,
|
||||
&i.Status,
|
||||
&i.Description,
|
||||
); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
items = append(items, i)
|
||||
}
|
||||
if err := rows.Close(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return items, nil
|
||||
}
|
||||
|
||||
@@ -15,7 +15,7 @@ DELETE FROM scope_member WHERE scope_id=?
|
||||
`
|
||||
|
||||
func (q *Queries) DeleteAllScopeMembers(ctx context.Context, scopeID int) error {
|
||||
_, err := q.exec(ctx, q.deleteAllScopeMembersStmt, deleteAllScopeMembers, scopeID)
|
||||
_, err := q.db.ExecContext(ctx, deleteAllScopeMembers, scopeID)
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -24,7 +24,7 @@ DELETE FROM scope WHERE id=?
|
||||
`
|
||||
|
||||
func (q *Queries) DeleteScope(ctx context.Context, id int) error {
|
||||
_, err := q.exec(ctx, q.deleteScopeStmt, deleteScope, id)
|
||||
_, err := q.db.ExecContext(ctx, deleteScope, id)
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -33,12 +33,12 @@ DELETE FROM scope_member WHERE scope_id=? AND user_id=?
|
||||
`
|
||||
|
||||
type DeleteScopeMemberParams struct {
|
||||
ScopeID int `json:"scope_id"`
|
||||
UserID string `json:"user_id"`
|
||||
ScopeID int
|
||||
UserID string
|
||||
}
|
||||
|
||||
func (q *Queries) DeleteScopeMember(ctx context.Context, arg DeleteScopeMemberParams) error {
|
||||
_, err := q.exec(ctx, q.deleteScopeMemberStmt, deleteScopeMember, arg.ScopeID, arg.UserID)
|
||||
_, err := q.db.ExecContext(ctx, deleteScopeMember, arg.ScopeID, arg.UserID)
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -48,7 +48,7 @@ WHERE id = ?
|
||||
`
|
||||
|
||||
func (q *Queries) GetScope(ctx context.Context, id int) (Scope, error) {
|
||||
row := q.queryRow(ctx, q.getScopeStmt, getScope, id)
|
||||
row := q.db.QueryRowContext(ctx, getScope, id)
|
||||
var i Scope
|
||||
err := row.Scan(&i.ID, &i.Name, &i.Abbreviation)
|
||||
return i, err
|
||||
@@ -60,12 +60,12 @@ WHERE user_id = ? AND scope_id = ?
|
||||
`
|
||||
|
||||
type GetScopeDisplayNameParams struct {
|
||||
UserID string `json:"user_id"`
|
||||
ScopeID int `json:"scope_id"`
|
||||
UserID string
|
||||
ScopeID int
|
||||
}
|
||||
|
||||
func (q *Queries) GetScopeDisplayName(ctx context.Context, arg GetScopeDisplayNameParams) (string, error) {
|
||||
row := q.queryRow(ctx, q.getScopeDisplayNameStmt, getScopeDisplayName, arg.UserID, arg.ScopeID)
|
||||
row := q.db.QueryRowContext(ctx, getScopeDisplayName, arg.UserID, arg.ScopeID)
|
||||
var name string
|
||||
err := row.Scan(&name)
|
||||
return name, err
|
||||
@@ -78,19 +78,19 @@ WHERE id = ? AND sm.user_id = ?
|
||||
`
|
||||
|
||||
type GetScopeWithDisplayNameParams struct {
|
||||
ID int `json:"id"`
|
||||
UserID string `json:"user_id"`
|
||||
ID int
|
||||
UserID string
|
||||
}
|
||||
|
||||
type GetScopeWithDisplayNameRow struct {
|
||||
ID int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Abbreviation string `json:"abbreviation"`
|
||||
DisplayName sql.NullString `json:"display_name"`
|
||||
ID int
|
||||
Name string
|
||||
Abbreviation string
|
||||
DisplayName sql.NullString
|
||||
}
|
||||
|
||||
func (q *Queries) GetScopeWithDisplayName(ctx context.Context, arg GetScopeWithDisplayNameParams) (GetScopeWithDisplayNameRow, error) {
|
||||
row := q.queryRow(ctx, q.getScopeWithDisplayNameStmt, getScopeWithDisplayName, arg.ID, arg.UserID)
|
||||
row := q.db.QueryRowContext(ctx, getScopeWithDisplayName, arg.ID, arg.UserID)
|
||||
var i GetScopeWithDisplayNameRow
|
||||
err := row.Scan(
|
||||
&i.ID,
|
||||
@@ -107,13 +107,13 @@ VALUES (?, ?, ?)
|
||||
`
|
||||
|
||||
type InsertScopeParams struct {
|
||||
ID int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Abbreviation string `json:"abbreviation"`
|
||||
ID int
|
||||
Name string
|
||||
Abbreviation string
|
||||
}
|
||||
|
||||
func (q *Queries) InsertScope(ctx context.Context, arg InsertScopeParams) (sql.Result, error) {
|
||||
return q.exec(ctx, q.insertScopeStmt, insertScope, arg.ID, arg.Name, arg.Abbreviation)
|
||||
return q.db.ExecContext(ctx, insertScope, arg.ID, arg.Name, arg.Abbreviation)
|
||||
}
|
||||
|
||||
const listScopeMembers = `-- name: ListScopeMembers :many
|
||||
@@ -123,13 +123,13 @@ ORDER BY name
|
||||
`
|
||||
|
||||
type ListScopeMembersRow struct {
|
||||
UserID string `json:"user_id"`
|
||||
Name string `json:"name"`
|
||||
Owner bool `json:"owner"`
|
||||
UserID string
|
||||
Name string
|
||||
Owner bool
|
||||
}
|
||||
|
||||
func (q *Queries) ListScopeMembers(ctx context.Context, scopeID int) ([]ListScopeMembersRow, error) {
|
||||
rows, err := q.query(ctx, q.listScopeMembersStmt, listScopeMembers, scopeID)
|
||||
rows, err := q.db.QueryContext(ctx, listScopeMembers, scopeID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -157,7 +157,7 @@ ORDER BY name
|
||||
`
|
||||
|
||||
func (q *Queries) ListScopes(ctx context.Context) ([]Scope, error) {
|
||||
rows, err := q.query(ctx, q.listScopesStmt, listScopes)
|
||||
rows, err := q.db.QueryContext(ctx, listScopes)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -187,14 +187,14 @@ ORDER BY s.name
|
||||
`
|
||||
|
||||
type ListScopesByUserRow struct {
|
||||
ID int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Abbreviation string `json:"abbreviation"`
|
||||
DisplayName sql.NullString `json:"display_name"`
|
||||
ID int
|
||||
Name string
|
||||
Abbreviation string
|
||||
DisplayName sql.NullString
|
||||
}
|
||||
|
||||
func (q *Queries) ListScopesByUser(ctx context.Context, userID string) ([]ListScopesByUserRow, error) {
|
||||
rows, err := q.query(ctx, q.listScopesByUserStmt, listScopesByUser, userID)
|
||||
rows, err := q.db.QueryContext(ctx, listScopesByUser, userID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -226,13 +226,13 @@ UPDATE scope SET name = ?, abbreviation = ? WHERE id = ?
|
||||
`
|
||||
|
||||
type UpdateScopeParams struct {
|
||||
Name string `json:"name"`
|
||||
Abbreviation string `json:"abbreviation"`
|
||||
ID int `json:"id"`
|
||||
Name string
|
||||
Abbreviation string
|
||||
ID int
|
||||
}
|
||||
|
||||
func (q *Queries) UpdateScope(ctx context.Context, arg UpdateScopeParams) error {
|
||||
_, err := q.exec(ctx, q.updateScopeStmt, updateScope, arg.Name, arg.Abbreviation, arg.ID)
|
||||
_, err := q.db.ExecContext(ctx, updateScope, arg.Name, arg.Abbreviation, arg.ID)
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -242,14 +242,14 @@ VALUES (?, ?, ?, ?)
|
||||
`
|
||||
|
||||
type UpdateScopeMemberParams struct {
|
||||
ScopeID int `json:"scope_id"`
|
||||
UserID string `json:"user_id"`
|
||||
Name string `json:"name"`
|
||||
Owner bool `json:"owner"`
|
||||
ScopeID int
|
||||
UserID string
|
||||
Name string
|
||||
Owner bool
|
||||
}
|
||||
|
||||
func (q *Queries) UpdateScopeMember(ctx context.Context, arg UpdateScopeMemberParams) error {
|
||||
_, err := q.exec(ctx, q.updateScopeMemberStmt, updateScopeMember,
|
||||
_, err := q.db.ExecContext(ctx, updateScopeMember,
|
||||
arg.ScopeID,
|
||||
arg.UserID,
|
||||
arg.Name,
|
||||
|
||||
@@ -17,15 +17,15 @@ WHERE scope_id = ?
|
||||
`
|
||||
|
||||
type ListStatsRow struct {
|
||||
ID int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Description string `json:"description"`
|
||||
Weight float64 `json:"weight"`
|
||||
AllowedAmounts sqltypes.NullRawMessage `json:"allowed_amounts"`
|
||||
ID int
|
||||
Name string
|
||||
Description string
|
||||
Weight float64
|
||||
AllowedAmounts sqltypes.NullRawMessage
|
||||
}
|
||||
|
||||
func (q *Queries) ListStats(ctx context.Context, scopeID int) ([]ListStatsRow, error) {
|
||||
rows, err := q.query(ctx, q.listStatsStmt, listStats, scopeID)
|
||||
rows, err := q.db.QueryContext(ctx, listStats, scopeID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
@@ -0,0 +1,105 @@
|
||||
-- name: GetItem :one
|
||||
SELECT i.*, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.id = ?;
|
||||
|
||||
-- name: ListItemsByProject :many
|
||||
SELECT i.*, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE pr.project_id = ?;
|
||||
|
||||
-- name: ListItemsAcquiredBetween :many
|
||||
SELECT i.*, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.acquired_time >= ?
|
||||
AND i.acquired_time < ?
|
||||
AND i.scope_id = ?;
|
||||
|
||||
-- name: ListItemsScheduledBetween :many
|
||||
SELECT i.*, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.scheduled_date >= ?
|
||||
AND i.scheduled_date < ?
|
||||
AND i.scope_id = ?;
|
||||
|
||||
-- name: ListItemsCreatedBetween :many
|
||||
SELECT i.*, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.created_time >= ?
|
||||
AND i.created_time < ?
|
||||
AND i.scope_id = ?;
|
||||
|
||||
-- name: ListItemsLooseBetween :many
|
||||
SELECT i.*, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.created_time >= ?
|
||||
AND i.created_time < ?
|
||||
AND i.scope_id = ?
|
||||
AND i.scheduled_date IS NULL
|
||||
AND i.acquired_time IS NULL;
|
||||
|
||||
-- name: ListItemsScheduledBetweenNoScope :many
|
||||
SELECT i.*, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.scheduled_date >= ?
|
||||
AND i.scheduled_date < ?;
|
||||
|
||||
-- name: ListItemsCreatedBetweenNoScope :many
|
||||
SELECT i.*, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.created_time >= ?
|
||||
AND i.created_time < ?;
|
||||
|
||||
-- name: ListItemsLooseBetweenNoScope :many
|
||||
SELECT i.*, pr.project_id FROM item i
|
||||
LEFT JOIN project_requirement pr ON pr.id = i.project_requirement_id
|
||||
WHERE i.created_time >= ?
|
||||
AND i.created_time < ?
|
||||
AND i.scheduled_date IS NULL
|
||||
AND i.acquired_time IS NULL;
|
||||
|
||||
-- name: GetItemStatProgressBetween :one
|
||||
SELECT s.id, s.name, s.weight, SUM(isp.acquired), SUM(isp.required) FROM item i
|
||||
LEFT JOIN item_stat_progress isp on i.id = isp.item_id
|
||||
LEFT JOIN stat s on isp.stat_id = s.id
|
||||
WHERE i.acquired_time >= ?
|
||||
AND i.acquired_time < ?
|
||||
AND i.scope_id = ?
|
||||
GROUP BY stat_id;
|
||||
|
||||
-- name: ListItemStatProgress :many
|
||||
SELECT isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
|
||||
LEFT JOIN stat s ON s.id = isp.stat_id
|
||||
WHERE item_id = ?;
|
||||
|
||||
-- name: ListItemStatProgressMulti :many
|
||||
SELECT isp.item_id, isp.required, isp.acquired, s.id, s.name, s.weight FROM item_stat_progress isp
|
||||
LEFT JOIN stat s ON s.id = isp.stat_id
|
||||
WHERE item_id IN (?, ?, ?, ?, ?, ?, ?, ?);
|
||||
|
||||
-- name: InsertItem :execresult
|
||||
INSERT INTO item (scope_id, project_requirement_id, name, description, created_time, created_user_id, acquired_time, scheduled_date)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?);
|
||||
|
||||
-- name: UpdateItem :exec
|
||||
UPDATE item
|
||||
SET project_requirement_id = ?,
|
||||
name = ?,
|
||||
description = ?,
|
||||
acquired_time = ?,
|
||||
scheduled_date = ?,
|
||||
created_user_id = ?
|
||||
WHERE id = ?;
|
||||
|
||||
-- name: DeleteItem :exec
|
||||
DELETE FROM item WHERE id = ?;
|
||||
|
||||
-- name: ReplaceItemStatProgress :exec
|
||||
REPLACE INTO item_stat_progress (item_id, stat_id, acquired, required)
|
||||
VALUES (?, ?, ?, ?);
|
||||
|
||||
-- name: DeleteItemStatProgress :exec
|
||||
DELETE FROM item_stat_progress WHERE item_id = ? AND stat_id = ?;
|
||||
|
||||
-- name: ClearItemStatProgress :exec
|
||||
DELETE FROM item_stat_progress WHERE item_id = ?;
|
||||
@@ -3,3 +3,9 @@ SELECT id, name, status FROM project
|
||||
WHERE scope_id = ?
|
||||
ORDER BY status, created_time;
|
||||
|
||||
-- name: GetProject :one
|
||||
SELECT * FROM project WHERE id = ?;
|
||||
|
||||
-- name: ListProjectRequirementsByProjectID :many
|
||||
SELECT * FROM project_requirement WHERE project_id = ?;
|
||||
|
||||
|
||||
@@ -16,7 +16,7 @@ type scopeRepository struct {
|
||||
db *sql.DB
|
||||
}
|
||||
|
||||
func (r *scopeRepository) Find(ctx context.Context, id int) (*models.Scope, error) {
|
||||
func (r *scopeRepository) Find(ctx context.Context, id int, full bool) (*models.Scope, error) {
|
||||
q := mysqlcore.New(r.db)
|
||||
scope, err := q.GetScope(ctx, id)
|
||||
if err != nil {
|
||||
@@ -37,6 +37,55 @@ func (r *scopeRepository) Find(ctx context.Context, id int) (*models.Scope, erro
|
||||
|
||||
eg, ctx := errgroup.WithContext(ctx)
|
||||
|
||||
if full {
|
||||
eg.Go(func() error {
|
||||
projects, err := q.ListProjectEntries(ctx, id)
|
||||
if err != nil && err != sql.ErrNoRows {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, project := range projects {
|
||||
res.Projects = append(res.Projects, models.ProjectEntry{
|
||||
ID: project.ID,
|
||||
Name: project.Name,
|
||||
Status: models.Status(project.Status),
|
||||
})
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
eg.Go(func() error {
|
||||
stats, err := q.ListStats(ctx, id)
|
||||
if err != nil && err != sql.ErrNoRows {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, stat := range stats {
|
||||
var amounts map[string]int
|
||||
if stat.AllowedAmounts.Valid {
|
||||
amounts = make(map[string]int)
|
||||
err := json.Unmarshal(stat.AllowedAmounts.RawMessage, &amounts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
res.Stats = append(res.Stats, models.Stat{
|
||||
StatEntry: models.StatEntry{
|
||||
ID: stat.ID,
|
||||
Name: stat.Name,
|
||||
Weight: stat.Weight,
|
||||
},
|
||||
Description: stat.Description,
|
||||
AllowedAmounts: amounts,
|
||||
})
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
eg.Go(func() error {
|
||||
members, err := q.ListScopeMembers(ctx, id)
|
||||
if err != nil && err != sql.ErrNoRows {
|
||||
@@ -54,53 +103,6 @@ func (r *scopeRepository) Find(ctx context.Context, id int) (*models.Scope, erro
|
||||
return nil
|
||||
})
|
||||
|
||||
eg.Go(func() error {
|
||||
projects, err := q.ListProjectEntries(ctx, id)
|
||||
if err != nil && err != sql.ErrNoRows {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, project := range projects {
|
||||
res.Projects = append(res.Projects, models.ProjectEntry{
|
||||
ID: project.ID,
|
||||
Name: project.Name,
|
||||
Status: models.Status(project.Status),
|
||||
})
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
eg.Go(func() error {
|
||||
stats, err := q.ListStats(ctx, id)
|
||||
if err != nil && err != sql.ErrNoRows {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, stat := range stats {
|
||||
var amounts map[string]int
|
||||
if stat.AllowedAmounts.Valid {
|
||||
amounts = make(map[string]int)
|
||||
err := json.Unmarshal(stat.AllowedAmounts.RawMessage, &amounts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
res.Stats = append(res.Stats, models.Stat{
|
||||
StatEntry: models.StatEntry{
|
||||
ID: stat.ID,
|
||||
Name: stat.Name,
|
||||
Weight: stat.Weight,
|
||||
},
|
||||
Description: stat.Description,
|
||||
AllowedAmounts: amounts,
|
||||
})
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
err = eg.Wait()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
|
||||
Reference in New Issue
Block a user