budgeteer/postgres/categories.sql.go

// Code generated by sqlc. DO NOT EDIT.
// source: categories.sql

package postgres

import (
	"context"
	"time"

	"github.com/google/uuid"
)

const createCategory = `-- name: CreateCategory :one
INSERT INTO categories
(name, category_group_id)
VALUES ($1, $2)
RETURNING id, category_group_id, name
`

type CreateCategoryParams struct {
	Name            string
	CategoryGroupID uuid.UUID
}

func (q *Queries) CreateCategory(ctx context.Context, arg CreateCategoryParams) (Category, error) {
	row := q.db.QueryRowContext(ctx, createCategory, arg.Name, arg.CategoryGroupID)
	var i Category
	err := row.Scan(&i.ID, &i.CategoryGroupID, &i.Name)
	return i, err
}

const createCategoryGroup = `-- name: CreateCategoryGroup :one
INSERT INTO category_groups
(name, budget_id)
VALUES ($1, $2)
RETURNING id, budget_id, name
`

type CreateCategoryGroupParams struct {
	Name     string
	BudgetID uuid.UUID
}

func (q *Queries) CreateCategoryGroup(ctx context.Context, arg CreateCategoryGroupParams) (CategoryGroup, error) {
	row := q.db.QueryRowContext(ctx, createCategoryGroup, arg.Name, arg.BudgetID)
	var i CategoryGroup
	err := row.Scan(&i.ID, &i.BudgetID, &i.Name)
	return i, err
}

const getAvailableBalance = `-- name: GetAvailableBalance :one
SELECT 
    ((
        SELECT SUM(transactions.amount)
        FROM transactions
        LEFT JOIN categories ON categories.id = transactions.category_id
        LEFT JOIN budgets ON budgets.income_category_id = categories.id
        INNER JOIN accounts ON accounts.id = transactions.account_id
        WHERE budgets.id = $1
        AND transactions.date < $2
        AND accounts.on_budget
    ) - (
        SELECT SUM(assignments.amount)
        FROM assignments
        INNER JOIN categories ON categories.id = assignments.category_id
        INNER JOIN category_groups ON category_groups.id = categories.category_group_id
        WHERE category_groups.budget_id = $1
        AND assignments.date < $2
    ))::decimal(12,2)
`

type GetAvailableBalanceParams struct {
	BudgetID uuid.UUID
	FromDate time.Time
}

func (q *Queries) GetAvailableBalance(ctx context.Context, arg GetAvailableBalanceParams) (Numeric, error) {
	row := q.db.QueryRowContext(ctx, getAvailableBalance, arg.BudgetID, arg.FromDate)
	var column_1 Numeric
	err := row.Scan(&column_1)
	return column_1, err
}

const getCategories = `-- name: GetCategories :many
SELECT categories.id, categories.category_group_id, categories.name, category_groups.name as group FROM categories
INNER JOIN category_groups ON categories.category_group_id = category_groups.id
WHERE category_groups.budget_id = $1
`

type GetCategoriesRow struct {
	ID              uuid.UUID
	CategoryGroupID uuid.UUID
	Name            string
	Group           string
}

func (q *Queries) GetCategories(ctx context.Context, budgetID uuid.UUID) ([]GetCategoriesRow, error) {
	rows, err := q.db.QueryContext(ctx, getCategories, budgetID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetCategoriesRow
	for rows.Next() {
		var i GetCategoriesRow
		if err := rows.Scan(
			&i.ID,
			&i.CategoryGroupID,
			&i.Name,
			&i.Group,
		); 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 getCategoriesWithBalance = `-- name: GetCategoriesWithBalance :many
SELECT categories.id, categories.name, category_groups.name as group, 
    (COALESCE(
        (
            SELECT SUM(a_hist.amount)
            FROM assignments a_hist
            WHERE categories.id = a_hist.category_id 
            AND a_hist.date < $1
        )
    , 0)+COALESCE(
        (
            SELECT SUM(t_hist.amount)
            FROM transactions t_hist
            WHERE categories.id = t_hist.category_id 
            AND t_hist.date < $1
        )
    , 0))::decimal(12,2) as balance, 
    COALESCE(
        (
            SELECT SUM(t_this.amount)
            FROM transactions t_this
            WHERE categories.id = t_this.category_id 
            AND t_this.date >= $1 AND t_this.date < $2
        )
    , 0)::decimal(12,2) as activity,
    COALESCE(
        (
            SELECT SUM(a_hist.amount)
            FROM assignments a_hist
            WHERE categories.id = a_hist.category_id 
            AND a_hist.date >= $1 AND a_hist.date < $2
        )
    ,0)::decimal(12,2) as assigned

FROM categories
INNER JOIN category_groups ON categories.category_group_id = category_groups.id
WHERE category_groups.budget_id = $3
GROUP BY categories.id, categories.name, category_groups.name
ORDER BY category_groups.name, categories.name
`

type GetCategoriesWithBalanceParams struct {
	FromDate time.Time
	ToDate   time.Time
	BudgetID uuid.UUID
}

type GetCategoriesWithBalanceRow struct {
	ID       uuid.UUID
	Name     string
	Group    string
	Balance  Numeric
	Activity Numeric
	Assigned Numeric
}

func (q *Queries) GetCategoriesWithBalance(ctx context.Context, arg GetCategoriesWithBalanceParams) ([]GetCategoriesWithBalanceRow, error) {
	rows, err := q.db.QueryContext(ctx, getCategoriesWithBalance, arg.FromDate, arg.ToDate, arg.BudgetID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetCategoriesWithBalanceRow
	for rows.Next() {
		var i GetCategoriesWithBalanceRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Group,
			&i.Balance,
			&i.Activity,
			&i.Assigned,
		); 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 getCategoryGroups = `-- name: GetCategoryGroups :many
SELECT category_groups.id, category_groups.budget_id, category_groups.name FROM category_groups 
WHERE category_groups.budget_id = $1
`

func (q *Queries) GetCategoryGroups(ctx context.Context, budgetID uuid.UUID) ([]CategoryGroup, error) {
	rows, err := q.db.QueryContext(ctx, getCategoryGroups, budgetID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []CategoryGroup
	for rows.Next() {
		var i CategoryGroup
		if err := rows.Scan(&i.ID, &i.BudgetID, &i.Name); 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
}