transactions.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.16.0
// source: transactions.sql

package db

import (
	"context"
	"database/sql"
	"time"

	"github.com/jackc/pgtype"
)

const createTransaction = `-- name: CreateTransaction :exec
INSERT INTO transactions (
  id, account_id, payee_id, category_id, date, amount, notes
) VALUES ($1, $2, $3, $4, $5, $6, $7)
`

type CreateTransactionParams struct {
	ID         string
	AccountID  string
	PayeeID    sql.NullString
	CategoryID sql.NullString
	Date       time.Time
	Amount     pgtype.Numeric
	Notes      sql.NullString
}

func (q *Queries) CreateTransaction(ctx context.Context, arg CreateTransactionParams) error {
	_, err := q.db.Exec(ctx, createTransaction,
		arg.ID,
		arg.AccountID,
		arg.PayeeID,
		arg.CategoryID,
		arg.Date,
		arg.Amount,
		arg.Notes,
	)
	return err
}

const getActivityBeforeDateByCategory = `-- name: GetActivityBeforeDateByCategory :many
SELECT categories.id, sum(transactions.amount)::numeric as activity
  FROM transactions
  JOIN categories
    ON transactions.category_id = categories.id
  JOIN accounts
    ON accounts.id = transactions.account_id
    AND accounts.budget_id = $1
  WHERE transactions.date < $2
  GROUP BY (
    categories.id
  )
`

type GetActivityBeforeDateByCategoryParams struct {
	BudgetID string
	Date     time.Time
}

type GetActivityBeforeDateByCategoryRow struct {
	ID       string
	Activity pgtype.Numeric
}

func (q *Queries) GetActivityBeforeDateByCategory(ctx context.Context, arg GetActivityBeforeDateByCategoryParams) ([]GetActivityBeforeDateByCategoryRow, error) {
	rows, err := q.db.Query(ctx, getActivityBeforeDateByCategory, arg.BudgetID, arg.Date)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetActivityBeforeDateByCategoryRow
	for rows.Next() {
		var i GetActivityBeforeDateByCategoryRow
		if err := rows.Scan(&i.ID, &i.Activity); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getIncomeBetween = `-- name: GetIncomeBetween :one
SELECT sum(transactions.amount)::numeric
FROM transactions
JOIN categories
  ON categories.id = transactions.category_id
JOIN category_groups
  ON category_groups.id = categories.group_id
  AND category_groups.is_income = true
JOIN accounts
  ON accounts.id = transactions.account_id
  AND accounts.budget_id = $1
WHERE
  transactions.date <= $2
  AND transactions.date >= $3
`

type GetIncomeBetweenParams struct {
	BudgetID  string
	EndDate   time.Time
	BeginDate time.Time
}

func (q *Queries) GetIncomeBetween(ctx context.Context, arg GetIncomeBetweenParams) (pgtype.Numeric, error) {
	row := q.db.QueryRow(ctx, getIncomeBetween, arg.BudgetID, arg.EndDate, arg.BeginDate)
	var column_1 pgtype.Numeric
	err := row.Scan(&column_1)
	return column_1, err
}

const getTransaction = `-- name: GetTransaction :one
SELECT transactions.id, transactions.account_id, transactions.payee_id, transactions.category_id, transactions.date, transactions.amount, transactions.notes, transactions.created_at, accounts.name as account_name, accounts.budget_id as budget_id
  FROM transactions
  JOIN accounts
    ON accounts.id = transactions.account_id
  WHERE transactions.id = $1
`

type GetTransactionRow struct {
	ID          string
	AccountID   string
	PayeeID     sql.NullString
	CategoryID  sql.NullString
	Date        time.Time
	Amount      pgtype.Numeric
	Notes       sql.NullString
	CreatedAt   time.Time
	AccountName string
	BudgetID    string
}

func (q *Queries) GetTransaction(ctx context.Context, id string) (GetTransactionRow, error) {
	row := q.db.QueryRow(ctx, getTransaction, id)
	var i GetTransactionRow
	err := row.Scan(
		&i.ID,
		&i.AccountID,
		&i.PayeeID,
		&i.CategoryID,
		&i.Date,
		&i.Amount,
		&i.Notes,
		&i.CreatedAt,
		&i.AccountName,
		&i.BudgetID,
	)
	return i, err
}

const getTransactionsForBudget = `-- name: GetTransactionsForBudget :many
SELECT
  transactions.id, transactions.account_id, transactions.payee_id, transactions.category_id, transactions.date, transactions.amount, transactions.notes, transactions.created_at,
  accounts.name as account_name,
  categories.name as category_name,
  payees.name as payee_name
FROM transactions
JOIN accounts
  ON accounts.id = transactions.account_id
  AND accounts.budget_id = $1
LEFT JOIN categories
  ON categories.id = transactions.category_id
LEFT JOIN payees
  ON payees.id = transactions.payee_id
ORDER BY date desc
`

type GetTransactionsForBudgetRow struct {
	ID           string
	AccountID    string
	PayeeID      sql.NullString
	CategoryID   sql.NullString
	Date         time.Time
	Amount       pgtype.Numeric
	Notes        sql.NullString
	CreatedAt    time.Time
	AccountName  string
	CategoryName sql.NullString
	PayeeName    sql.NullString
}

func (q *Queries) GetTransactionsForBudget(ctx context.Context, budgetID string) ([]GetTransactionsForBudgetRow, error) {
	rows, err := q.db.Query(ctx, getTransactionsForBudget, budgetID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetTransactionsForBudgetRow
	for rows.Next() {
		var i GetTransactionsForBudgetRow
		if err := rows.Scan(
			&i.ID,
			&i.AccountID,
			&i.PayeeID,
			&i.CategoryID,
			&i.Date,
			&i.Amount,
			&i.Notes,
			&i.CreatedAt,
			&i.AccountName,
			&i.CategoryName,
			&i.PayeeName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateTransaction = `-- name: UpdateTransaction :exec
UPDATE transactions
  SET account_id=$1, category_id=$2, payee_id=$3, date=$4, amount=$5, notes=$6
  WHERE id=$7
`

type UpdateTransactionParams struct {
	AccountID  string
	CategoryID sql.NullString
	PayeeID    sql.NullString
	Date       time.Time
	Amount     pgtype.Numeric
	Notes      sql.NullString
	ID         string
}

func (q *Queries) UpdateTransaction(ctx context.Context, arg UpdateTransactionParams) error {
	_, err := q.db.Exec(ctx, updateTransaction,
		arg.AccountID,
		arg.CategoryID,
		arg.PayeeID,
		arg.Date,
		arg.Amount,
		arg.Notes,
		arg.ID,
	)
	return err
}