You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
805 lines
21 KiB
805 lines
21 KiB
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.13.0
|
|
// source: items.sql
|
|
|
|
package mysqlcore
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"time"
|
|
|
|
"git.aiterp.net/stufflog3/stufflog3/ports/mysql/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.exec(ctx, q.clearItemStatProgressStmt, 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.exec(ctx, q.deleteItemStmt, deleteItem, id)
|
|
return err
|
|
}
|
|
|
|
const deleteItemForRequirement = `-- name: DeleteItemForRequirement :exec
|
|
DELETE FROM item WHERE project_requirement_id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteItemForRequirement(ctx context.Context, projectRequirementID sql.NullInt32) error {
|
|
_, err := q.exec(ctx, q.deleteItemForRequirementStmt, deleteItemForRequirement, projectRequirementID)
|
|
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.exec(ctx, q.deleteItemStatProgressStmt, deleteItemStatProgress, arg.ItemID, arg.StatID)
|
|
return err
|
|
}
|
|
|
|
const getItem = `-- name: GetItem :one
|
|
SELECT i.id, i.scope_id, i.project_requirement_id, i.owner_id, i.name, i.description, i.created_time, 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
|
|
OwnerID string
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
ProjectID sql.NullInt32
|
|
}
|
|
|
|
func (q *Queries) GetItem(ctx context.Context, id int) (GetItemRow, error) {
|
|
row := q.queryRow(ctx, q.getItemStmt, getItem, id)
|
|
var i GetItemRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.ScopeID,
|
|
&i.ProjectRequirementID,
|
|
&i.OwnerID,
|
|
&i.Name,
|
|
&i.Description,
|
|
&i.CreatedTime,
|
|
&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.queryRow(ctx, q.getItemStatProgressBetweenStmt, 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, owner_id, acquired_time, scheduled_date)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertItemParams struct {
|
|
ScopeID int
|
|
ProjectRequirementID sql.NullInt32
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
OwnerID string
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
}
|
|
|
|
func (q *Queries) InsertItem(ctx context.Context, arg InsertItemParams) (sql.Result, error) {
|
|
return q.exec(ctx, q.insertItemStmt, insertItem,
|
|
arg.ScopeID,
|
|
arg.ProjectRequirementID,
|
|
arg.Name,
|
|
arg.Description,
|
|
arg.CreatedTime,
|
|
arg.OwnerID,
|
|
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.query(ctx, q.listItemStatProgressStmt, 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.query(ctx, q.listItemStatProgressMultiStmt, 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.owner_id, i.name, i.description, i.created_time, 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 = ?
|
|
ORDER BY acquired_time DESC, created_time DESC
|
|
`
|
|
|
|
type ListItemsAcquiredBetweenParams struct {
|
|
AcquiredTime sql.NullTime
|
|
AcquiredTime_2 sql.NullTime
|
|
ScopeID int
|
|
}
|
|
|
|
type ListItemsAcquiredBetweenRow struct {
|
|
ID int
|
|
ScopeID int
|
|
ProjectRequirementID sql.NullInt32
|
|
OwnerID string
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
ProjectID sql.NullInt32
|
|
}
|
|
|
|
func (q *Queries) ListItemsAcquiredBetween(ctx context.Context, arg ListItemsAcquiredBetweenParams) ([]ListItemsAcquiredBetweenRow, error) {
|
|
rows, err := q.query(ctx, q.listItemsAcquiredBetweenStmt, 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.OwnerID,
|
|
&i.Name,
|
|
&i.Description,
|
|
&i.CreatedTime,
|
|
&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.owner_id, i.name, i.description, i.created_time, 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
|
|
OwnerID string
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
ProjectID sql.NullInt32
|
|
}
|
|
|
|
func (q *Queries) ListItemsByProject(ctx context.Context, projectID int) ([]ListItemsByProjectRow, error) {
|
|
rows, err := q.query(ctx, q.listItemsByProjectStmt, 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.OwnerID,
|
|
&i.Name,
|
|
&i.Description,
|
|
&i.CreatedTime,
|
|
&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.owner_id, i.name, i.description, i.created_time, 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 = ?
|
|
ORDER BY created_time DESC
|
|
`
|
|
|
|
type ListItemsCreatedBetweenParams struct {
|
|
CreatedTime time.Time
|
|
CreatedTime_2 time.Time
|
|
ScopeID int
|
|
}
|
|
|
|
type ListItemsCreatedBetweenRow struct {
|
|
ID int
|
|
ScopeID int
|
|
ProjectRequirementID sql.NullInt32
|
|
OwnerID string
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
ProjectID sql.NullInt32
|
|
}
|
|
|
|
func (q *Queries) ListItemsCreatedBetween(ctx context.Context, arg ListItemsCreatedBetweenParams) ([]ListItemsCreatedBetweenRow, error) {
|
|
rows, err := q.query(ctx, q.listItemsCreatedBetweenStmt, 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.OwnerID,
|
|
&i.Name,
|
|
&i.Description,
|
|
&i.CreatedTime,
|
|
&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.owner_id, i.name, i.description, i.created_time, 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
|
|
OwnerID string
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
ProjectID sql.NullInt32
|
|
}
|
|
|
|
func (q *Queries) ListItemsCreatedBetweenNoScope(ctx context.Context, arg ListItemsCreatedBetweenNoScopeParams) ([]ListItemsCreatedBetweenNoScopeRow, error) {
|
|
rows, err := q.query(ctx, q.listItemsCreatedBetweenNoScopeStmt, 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.OwnerID,
|
|
&i.Name,
|
|
&i.Description,
|
|
&i.CreatedTime,
|
|
&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.owner_id, i.name, i.description, i.created_time, 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
|
|
AND i.project_requirement_id IS NULL
|
|
ORDER BY created_time DESC
|
|
`
|
|
|
|
type ListItemsLooseBetweenParams struct {
|
|
CreatedTime time.Time
|
|
CreatedTime_2 time.Time
|
|
ScopeID int
|
|
}
|
|
|
|
type ListItemsLooseBetweenRow struct {
|
|
ID int
|
|
ScopeID int
|
|
ProjectRequirementID sql.NullInt32
|
|
OwnerID string
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
ProjectID sql.NullInt32
|
|
}
|
|
|
|
func (q *Queries) ListItemsLooseBetween(ctx context.Context, arg ListItemsLooseBetweenParams) ([]ListItemsLooseBetweenRow, error) {
|
|
rows, err := q.query(ctx, q.listItemsLooseBetweenStmt, 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.OwnerID,
|
|
&i.Name,
|
|
&i.Description,
|
|
&i.CreatedTime,
|
|
&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.owner_id, i.name, i.description, i.created_time, 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
|
|
OwnerID string
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
ProjectID sql.NullInt32
|
|
}
|
|
|
|
func (q *Queries) ListItemsLooseBetweenNoScope(ctx context.Context, arg ListItemsLooseBetweenNoScopeParams) ([]ListItemsLooseBetweenNoScopeRow, error) {
|
|
rows, err := q.query(ctx, q.listItemsLooseBetweenNoScopeStmt, 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.OwnerID,
|
|
&i.Name,
|
|
&i.Description,
|
|
&i.CreatedTime,
|
|
&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.owner_id, i.name, i.description, i.created_time, 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 = ?
|
|
ORDER BY scheduled_date, created_time
|
|
`
|
|
|
|
type ListItemsScheduledBetweenParams struct {
|
|
ScheduledDate sqltypes.NullDate
|
|
ScheduledDate_2 sqltypes.NullDate
|
|
ScopeID int
|
|
}
|
|
|
|
type ListItemsScheduledBetweenRow struct {
|
|
ID int
|
|
ScopeID int
|
|
ProjectRequirementID sql.NullInt32
|
|
OwnerID string
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
ProjectID sql.NullInt32
|
|
}
|
|
|
|
func (q *Queries) ListItemsScheduledBetween(ctx context.Context, arg ListItemsScheduledBetweenParams) ([]ListItemsScheduledBetweenRow, error) {
|
|
rows, err := q.query(ctx, q.listItemsScheduledBetweenStmt, 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.OwnerID,
|
|
&i.Name,
|
|
&i.Description,
|
|
&i.CreatedTime,
|
|
&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.owner_id, i.name, i.description, i.created_time, 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
|
|
OwnerID string
|
|
Name string
|
|
Description string
|
|
CreatedTime time.Time
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
ProjectID sql.NullInt32
|
|
}
|
|
|
|
func (q *Queries) ListItemsScheduledBetweenNoScope(ctx context.Context, arg ListItemsScheduledBetweenNoScopeParams) ([]ListItemsScheduledBetweenNoScopeRow, error) {
|
|
rows, err := q.query(ctx, q.listItemsScheduledBetweenNoScopeStmt, 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.OwnerID,
|
|
&i.Name,
|
|
&i.Description,
|
|
&i.CreatedTime,
|
|
&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.exec(ctx, q.replaceItemStatProgressStmt, 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 = ?,
|
|
owner_id = ?
|
|
WHERE id = ?
|
|
`
|
|
|
|
type UpdateItemParams struct {
|
|
ProjectRequirementID sql.NullInt32
|
|
Name string
|
|
Description string
|
|
AcquiredTime sql.NullTime
|
|
ScheduledDate sqltypes.NullDate
|
|
OwnerID string
|
|
ID int
|
|
}
|
|
|
|
func (q *Queries) UpdateItem(ctx context.Context, arg UpdateItemParams) error {
|
|
_, err := q.exec(ctx, q.updateItemStmt, updateItem,
|
|
arg.ProjectRequirementID,
|
|
arg.Name,
|
|
arg.Description,
|
|
arg.AcquiredTime,
|
|
arg.ScheduledDate,
|
|
arg.OwnerID,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|