projectx/internal/db/sqlc/budget.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.28.0
// source: budget.sql

package db

import (
	"context"
	"time"

	"github.com/jackc/pgx/v5/pgtype"
)

const createBudget = `-- name: CreateBudget :one
INSERT INTO budgets (project_id, name, budget_type, category, start_at, end_at, amount, used_amount, remaining_amount, remark, created_user_id)
VALUES($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
RETURNING id, project_id, name, budget_type, category, start_at, end_at, amount, used_amount, remaining_amount, remark, status, sort, created_at, created_user_id, updated_at, updated_user_id
`

type CreateBudgetParams struct {
	ProjectID       int64          `json:"project_id"`
	Name            string         `json:"name"`
	BudgetType      int32          `json:"budget_type"`
	Category        int32          `json:"category"`
	StartAt         time.Time      `json:"start_at"`
	EndAt           time.Time      `json:"end_at"`
	Amount          pgtype.Numeric `json:"amount"`
	UsedAmount      pgtype.Numeric `json:"used_amount"`
	RemainingAmount pgtype.Numeric `json:"remaining_amount"`
	Remark          string         `json:"remark"`
	CreatedUserID   int32          `json:"created_user_id"`
}

func (q *Queries) CreateBudget(ctx context.Context, arg *CreateBudgetParams) (*Budget, error) {
	row := q.db.QueryRow(ctx, createBudget,
		arg.ProjectID,
		arg.Name,
		arg.BudgetType,
		arg.Category,
		arg.StartAt,
		arg.EndAt,
		arg.Amount,
		arg.UsedAmount,
		arg.RemainingAmount,
		arg.Remark,
		arg.CreatedUserID,
	)
	var i Budget
	err := row.Scan(
		&i.ID,
		&i.ProjectID,
		&i.Name,
		&i.BudgetType,
		&i.Category,
		&i.StartAt,
		&i.EndAt,
		&i.Amount,
		&i.UsedAmount,
		&i.RemainingAmount,
		&i.Remark,
		&i.Status,
		&i.Sort,
		&i.CreatedAt,
		&i.CreatedUserID,
		&i.UpdatedAt,
		&i.UpdatedUserID,
	)
	return &i, err
}

const getBudget = `-- name: GetBudget :one
SELECT id, project_id, name, budget_type, category, start_at, end_at, amount, used_amount, remaining_amount, remark, status, sort, created_at, created_user_id, updated_at, updated_user_id 
FROM budgets 
WHERE id = $1
LIMIT 1
`

func (q *Queries) GetBudget(ctx context.Context, id int64) (*Budget, error) {
	row := q.db.QueryRow(ctx, getBudget, id)
	var i Budget
	err := row.Scan(
		&i.ID,
		&i.ProjectID,
		&i.Name,
		&i.BudgetType,
		&i.Category,
		&i.StartAt,
		&i.EndAt,
		&i.Amount,
		&i.UsedAmount,
		&i.RemainingAmount,
		&i.Remark,
		&i.Status,
		&i.Sort,
		&i.CreatedAt,
		&i.CreatedUserID,
		&i.UpdatedAt,
		&i.UpdatedUserID,
	)
	return &i, err
}

const listBudgets = `-- name: ListBudgets :many
SELECT id, project_id, name, budget_type, category, start_at, end_at, amount, used_amount, remaining_amount, remark, status, sort, created_at, created_user_id, updated_at, updated_user_id 
FROM budgets
WHERE project_id = $1
ORDER BY id
`

func (q *Queries) ListBudgets(ctx context.Context, projectID int64) ([]*Budget, error) {
	rows, err := q.db.Query(ctx, listBudgets, projectID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*Budget{}
	for rows.Next() {
		var i Budget
		if err := rows.Scan(
			&i.ID,
			&i.ProjectID,
			&i.Name,
			&i.BudgetType,
			&i.Category,
			&i.StartAt,
			&i.EndAt,
			&i.Amount,
			&i.UsedAmount,
			&i.RemainingAmount,
			&i.Remark,
			&i.Status,
			&i.Sort,
			&i.CreatedAt,
			&i.CreatedUserID,
			&i.UpdatedAt,
			&i.UpdatedUserID,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateBudget = `-- name: UpdateBudget :one
UPDATE budgets
SET
    project_id = COALESCE($2, project_id),
    name = COALESCE($3, name),
    budget_type = COALESCE($4, budget_type),
    category = COALESCE($5, category),
    start_at = COALESCE($6, start_at),
    end_at = COALESCE($7, end_at),
    amount = COALESCE($8, amount),
    used_amount = COALESCE($9, used_amount),
    remaining_amount = COALESCE($10, remaining_amount),
    remark = COALESCE($11, remark),
    status = COALESCE($12, status),
    updated_user_id = COALESCE($13, updated_user_id),
    updated_at = NOW()
WHERE id = $1
RETURNING id, project_id, name, budget_type, category, start_at, end_at, amount, used_amount, remaining_amount, remark, status, sort, created_at, created_user_id, updated_at, updated_user_id
`

type UpdateBudgetParams struct {
	ID              int64              `json:"id"`
	ProjectID       pgtype.Int8        `json:"project_id"`
	Name            pgtype.Text        `json:"name"`
	BudgetType      pgtype.Int4        `json:"budget_type"`
	Category        pgtype.Int4        `json:"category"`
	StartAt         pgtype.Timestamptz `json:"start_at"`
	EndAt           pgtype.Timestamptz `json:"end_at"`
	Amount          pgtype.Numeric     `json:"amount"`
	UsedAmount      pgtype.Numeric     `json:"used_amount"`
	RemainingAmount pgtype.Numeric     `json:"remaining_amount"`
	Remark          pgtype.Text        `json:"remark"`
	Status          pgtype.Int2        `json:"status"`
	UpdatedUserID   pgtype.Int4        `json:"updated_user_id"`
}

func (q *Queries) UpdateBudget(ctx context.Context, arg *UpdateBudgetParams) (*Budget, error) {
	row := q.db.QueryRow(ctx, updateBudget,
		arg.ID,
		arg.ProjectID,
		arg.Name,
		arg.BudgetType,
		arg.Category,
		arg.StartAt,
		arg.EndAt,
		arg.Amount,
		arg.UsedAmount,
		arg.RemainingAmount,
		arg.Remark,
		arg.Status,
		arg.UpdatedUserID,
	)
	var i Budget
	err := row.Scan(
		&i.ID,
		&i.ProjectID,
		&i.Name,
		&i.BudgetType,
		&i.Category,
		&i.StartAt,
		&i.EndAt,
		&i.Amount,
		&i.UsedAmount,
		&i.RemainingAmount,
		&i.Remark,
		&i.Status,
		&i.Sort,
		&i.CreatedAt,
		&i.CreatedUserID,
		&i.UpdatedAt,
		&i.UpdatedUserID,
	)
	return &i, err
}