stufflog3/ports/mysql/mysqlcore/projects.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.13.0
// source: projects.sql

package mysqlcore

import (
	"context"
	"database/sql"
)

const clearItemProjectRequirement = `-- name: ClearItemProjectRequirement :exec
UPDATE item
SET project_requirement_id = NULL
WHERE project_requirement_id = ?
`

func (q *Queries) ClearItemProjectRequirement(ctx context.Context, projectRequirementID sql.NullInt32) error {
	_, err := q.exec(ctx, q.clearItemProjectRequirementStmt, clearItemProjectRequirement, projectRequirementID)
	return err
}

const clearProjectRequirementStatsByStat = `-- name: ClearProjectRequirementStatsByStat :exec
DELETE
FROM project_requirement_stat
WHERE stat_id = ?
`

func (q *Queries) ClearProjectRequirementStatsByStat(ctx context.Context, statID int) error {
	_, err := q.exec(ctx, q.clearProjectRequirementStatsByStatStmt, clearProjectRequirementStatsByStat, statID)
	return err
}

const deleteAllProjectRequirementStats = `-- name: DeleteAllProjectRequirementStats :exec
DELETE
FROM project_requirement_stat
WHERE project_requirement_id = ?
`

func (q *Queries) DeleteAllProjectRequirementStats(ctx context.Context, projectRequirementID int) error {
	_, err := q.exec(ctx, q.deleteAllProjectRequirementStatsStmt, deleteAllProjectRequirementStats, projectRequirementID)
	return err
}

const deleteAllProjectRequirements = `-- name: DeleteAllProjectRequirements :exec
DELETE
FROM project_requirement
WHERE project_id = ?
`

func (q *Queries) DeleteAllProjectRequirements(ctx context.Context, projectID int) error {
	_, err := q.exec(ctx, q.deleteAllProjectRequirementsStmt, deleteAllProjectRequirements, projectID)
	return err
}

const deleteAllScopeProjectRequirements = `-- name: DeleteAllScopeProjectRequirements :exec
DELETE
FROM project_requirement
WHERE scope_id = ?
`

func (q *Queries) DeleteAllScopeProjectRequirements(ctx context.Context, scopeID int) error {
	_, err := q.exec(ctx, q.deleteAllScopeProjectRequirementsStmt, deleteAllScopeProjectRequirements, scopeID)
	return err
}

const deleteAllScopeProjects = `-- name: DeleteAllScopeProjects :exec
DELETE
FROM project
WHERE scope_id = ?
`

func (q *Queries) DeleteAllScopeProjects(ctx context.Context, scopeID int) error {
	_, err := q.exec(ctx, q.deleteAllScopeProjectsStmt, deleteAllScopeProjects, scopeID)
	return err
}

const deleteProject = `-- name: DeleteProject :exec
DELETE
FROM project
WHERE id = ?
  AND scope_id = ?
`

type DeleteProjectParams struct {
	ID      int
	ScopeID int
}

func (q *Queries) DeleteProject(ctx context.Context, arg DeleteProjectParams) error {
	_, err := q.exec(ctx, q.deleteProjectStmt, deleteProject, arg.ID, arg.ScopeID)
	return err
}

const deleteProjectRequirement = `-- name: DeleteProjectRequirement :exec
DELETE
FROM project_requirement
WHERE id = ?
  AND scope_id = ?
`

type DeleteProjectRequirementParams struct {
	ID      int
	ScopeID int
}

func (q *Queries) DeleteProjectRequirement(ctx context.Context, arg DeleteProjectRequirementParams) error {
	_, err := q.exec(ctx, q.deleteProjectRequirementStmt, deleteProjectRequirement, arg.ID, arg.ScopeID)
	return err
}

const deleteProjectRequirementStat = `-- name: DeleteProjectRequirementStat :exec
DELETE
FROM project_requirement_stat
WHERE project_requirement_id = ?
  AND stat_id = ?
`

type DeleteProjectRequirementStatParams struct {
	ProjectRequirementID int
	StatID               int
}

func (q *Queries) DeleteProjectRequirementStat(ctx context.Context, arg DeleteProjectRequirementStatParams) error {
	_, err := q.exec(ctx, q.deleteProjectRequirementStatStmt, deleteProjectRequirementStat, arg.ProjectRequirementID, arg.StatID)
	return err
}

const getProject = `-- name: GetProject :one
SELECT id, scope_id, owner_id, name, status, description, created_time
FROM project
WHERE id = ?
  AND scope_id = ?
`

type GetProjectParams struct {
	ID      int
	ScopeID int
}

func (q *Queries) GetProject(ctx context.Context, arg GetProjectParams) (Project, error) {
	row := q.queryRow(ctx, q.getProjectStmt, getProject, arg.ID, arg.ScopeID)
	var i Project
	err := row.Scan(
		&i.ID,
		&i.ScopeID,
		&i.OwnerID,
		&i.Name,
		&i.Status,
		&i.Description,
		&i.CreatedTime,
	)
	return i, err
}

const insertProject = `-- name: InsertProject :execresult
INSERT INTO project (scope_id, owner_id, name, status, description)
VALUES (?, ?, ?, ?, ?)
`

type InsertProjectParams struct {
	ScopeID     int
	OwnerID     string
	Name        string
	Status      int
	Description string
}

func (q *Queries) InsertProject(ctx context.Context, arg InsertProjectParams) (sql.Result, error) {
	return q.exec(ctx, q.insertProjectStmt, insertProject,
		arg.ScopeID,
		arg.OwnerID,
		arg.Name,
		arg.Status,
		arg.Description,
	)
}

const insertProjectRequirement = `-- name: InsertProjectRequirement :execresult
INSERT INTO project_requirement (scope_id, project_id, name, status, description, is_coarse, aggregate_required)
VALUES (?, ?, ?, ?, ?, ?, ?)
`

type InsertProjectRequirementParams struct {
	ScopeID           int
	ProjectID         int
	Name              string
	Status            int
	Description       string
	IsCoarse          bool
	AggregateRequired int
}

func (q *Queries) InsertProjectRequirement(ctx context.Context, arg InsertProjectRequirementParams) (sql.Result, error) {
	return q.exec(ctx, q.insertProjectRequirementStmt, insertProjectRequirement,
		arg.ScopeID,
		arg.ProjectID,
		arg.Name,
		arg.Status,
		arg.Description,
		arg.IsCoarse,
		arg.AggregateRequired,
	)
}

const listProjectRequirements = `-- name: ListProjectRequirements :many
SELECT id, scope_id, project_id, name, status, description, is_coarse, aggregate_required
FROM project_requirement
WHERE project_id = ?
`

func (q *Queries) ListProjectRequirements(ctx context.Context, projectID int) ([]ProjectRequirement, error) {
	rows, err := q.query(ctx, q.listProjectRequirementsStmt, listProjectRequirements, 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,
			&i.IsCoarse,
			&i.AggregateRequired,
		); 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 listProjectRequirementsByScopeID = `-- name: ListProjectRequirementsByScopeID :many
SELECT id, scope_id, project_id, name, status, description, is_coarse, aggregate_required
FROM project_requirement
WHERE scope_id = ?
`

func (q *Queries) ListProjectRequirementsByScopeID(ctx context.Context, scopeID int) ([]ProjectRequirement, error) {
	rows, err := q.query(ctx, q.listProjectRequirementsByScopeIDStmt, listProjectRequirementsByScopeID, scopeID)
	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,
			&i.IsCoarse,
			&i.AggregateRequired,
		); 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 listProjectRequirementsStats = `-- name: ListProjectRequirementsStats :many
SELECT prs.project_requirement_id, prs.stat_id, prs.required
FROM project_requirement pr
         RIGHT JOIN project_requirement_stat prs ON pr.id = prs.project_requirement_id
WHERE pr.project_id = ?
`

func (q *Queries) ListProjectRequirementsStats(ctx context.Context, projectID int) ([]ProjectRequirementStat, error) {
	rows, err := q.query(ctx, q.listProjectRequirementsStatsStmt, listProjectRequirementsStats, projectID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ProjectRequirementStat{}
	for rows.Next() {
		var i ProjectRequirementStat
		if err := rows.Scan(&i.ProjectRequirementID, &i.StatID, &i.Required); 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 listProjectRequirementsStatsByScopeID = `-- name: ListProjectRequirementsStatsByScopeID :many
SELECT prs.project_requirement_id, prs.stat_id, prs.required
FROM project_requirement pr
         RIGHT JOIN project_requirement_stat prs ON pr.id = prs.project_requirement_id
WHERE pr.scope_id = ?
`

func (q *Queries) ListProjectRequirementsStatsByScopeID(ctx context.Context, scopeID int) ([]ProjectRequirementStat, error) {
	rows, err := q.query(ctx, q.listProjectRequirementsStatsByScopeIDStmt, listProjectRequirementsStatsByScopeID, scopeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ProjectRequirementStat{}
	for rows.Next() {
		var i ProjectRequirementStat
		if err := rows.Scan(&i.ProjectRequirementID, &i.StatID, &i.Required); 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 listProjects = `-- name: ListProjects :many
SELECT id, scope_id, owner_id, name, status, description, created_time
FROM project
WHERE scope_id = ?
ORDER BY status, name
`

func (q *Queries) ListProjects(ctx context.Context, scopeID int) ([]Project, error) {
	rows, err := q.query(ctx, q.listProjectsStmt, listProjects, scopeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Project{}
	for rows.Next() {
		var i Project
		if err := rows.Scan(
			&i.ID,
			&i.ScopeID,
			&i.OwnerID,
			&i.Name,
			&i.Status,
			&i.Description,
			&i.CreatedTime,
		); 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 replaceProjectRequirementStat = `-- name: ReplaceProjectRequirementStat :exec
REPLACE INTO project_requirement_stat (project_requirement_id, stat_id, required)
VALUES (?, ?, ?)
`

type ReplaceProjectRequirementStatParams struct {
	ProjectRequirementID int
	StatID               int
	Required             int
}

func (q *Queries) ReplaceProjectRequirementStat(ctx context.Context, arg ReplaceProjectRequirementStatParams) error {
	_, err := q.exec(ctx, q.replaceProjectRequirementStatStmt, replaceProjectRequirementStat, arg.ProjectRequirementID, arg.StatID, arg.Required)
	return err
}

const updateProject = `-- name: UpdateProject :exec
UPDATE project
SET owner_id    = ?,
    name        = ?,
    status      = ?,
    description = ?
WHERE id = ?
  AND scope_id = ?
`

type UpdateProjectParams struct {
	OwnerID     string
	Name        string
	Status      int
	Description string
	ID          int
	ScopeID     int
}

func (q *Queries) UpdateProject(ctx context.Context, arg UpdateProjectParams) error {
	_, err := q.exec(ctx, q.updateProjectStmt, updateProject,
		arg.OwnerID,
		arg.Name,
		arg.Status,
		arg.Description,
		arg.ID,
		arg.ScopeID,
	)
	return err
}

const updateProjectRequirement = `-- name: UpdateProjectRequirement :exec
UPDATE project_requirement
SET name               = ?,
    status             = ?,
    description        = ?,
    is_coarse          = ?,
    aggregate_required = ?,
    project_id         = ?
WHERE id = ?
  AND scope_id = ?
`

type UpdateProjectRequirementParams struct {
	Name              string
	Status            int
	Description       string
	IsCoarse          bool
	AggregateRequired int
	ProjectID         int
	ID                int
	ScopeID           int
}

func (q *Queries) UpdateProjectRequirement(ctx context.Context, arg UpdateProjectRequirementParams) error {
	_, err := q.exec(ctx, q.updateProjectRequirementStmt, updateProjectRequirement,
		arg.Name,
		arg.Status,
		arg.Description,
		arg.IsCoarse,
		arg.AggregateRequired,
		arg.ProjectID,
		arg.ID,
		arg.ScopeID,
	)
	return err
}