Enshi/enshi_back/db/go_queries/badge_queries.sql.go

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

package db_repo

import (
	"context"

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

const addBadgeToUser = `-- name: AddBadgeToUser :one
INSERT INTO public.users_badges (user_id, badge_id) 
VALUES 
  (
    $1, 
    $2
  )
RETURNING user_id, badge_id
`

type AddBadgeToUserParams struct {
	UserID  int64     `json:"user_id"`
	BadgeID uuid.UUID `json:"badge_id"`
}

func (q *Queries) AddBadgeToUser(ctx context.Context, arg AddBadgeToUserParams) (UsersBadge, error) {
	row := q.db.QueryRow(ctx, addBadgeToUser, arg.UserID, arg.BadgeID)
	var i UsersBadge
	err := row.Scan(&i.UserID, &i.BadgeID)
	return i, err
}

const deleteBadge = `-- name: DeleteBadge :exec
DELETE FROM public.badges 
WHERE 
  id = $1
`

func (q *Queries) DeleteBadge(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.Exec(ctx, deleteBadge, id)
	return err
}

const getAllBadges = `-- name: GetAllBadges :many
SELECT id, name, description, color 
FROM public.badges
`

func (q *Queries) GetAllBadges(ctx context.Context) ([]Badge, error) {
	rows, err := q.db.Query(ctx, getAllBadges)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Badge
	for rows.Next() {
		var i Badge
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Description,
			&i.Color,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getBadgeByID = `-- name: GetBadgeByID :one
SELECT id, name, description, color 
FROM public.badges 
WHERE id = $1
`

func (q *Queries) GetBadgeByID(ctx context.Context, id uuid.UUID) (Badge, error) {
	row := q.db.QueryRow(ctx, getBadgeByID, id)
	var i Badge
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Color,
	)
	return i, err
}

const getUserBadges = `-- name: GetUserBadges :many
SELECT b.id, b.name, b.description, b.color 
FROM public.badges b 
JOIN public.users_badges ub ON b.id = ub.badge_id 
WHERE ub.user_id = $1
`

func (q *Queries) GetUserBadges(ctx context.Context, userID int64) ([]Badge, error) {
	rows, err := q.db.Query(ctx, getUserBadges, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Badge
	for rows.Next() {
		var i Badge
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Description,
			&i.Color,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUsersWithBadge = `-- name: GetUsersWithBadge :many
SELECT u.user_id, u.username, u.email, u.password, u.created_at, u.is_admin, u.display_name 
FROM public.users u 
JOIN public.users_badges ub ON u.user_id = ub.user_id 
WHERE ub.badge_id = $1
`

func (q *Queries) GetUsersWithBadge(ctx context.Context, badgeID uuid.UUID) ([]User, error) {
	rows, err := q.db.Query(ctx, getUsersWithBadge, badgeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []User
	for rows.Next() {
		var i User
		if err := rows.Scan(
			&i.UserID,
			&i.Username,
			&i.Email,
			&i.Password,
			&i.CreatedAt,
			&i.IsAdmin,
			&i.DisplayName,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const insertBadge = `-- name: InsertBadge :one
INSERT INTO public.badges (id, name, description, color) 
VALUES 
  (
    uuid_generate_v4(), 
    $1, 
    $2,
    $3
  )
RETURNING id, name, description, color
`

type InsertBadgeParams struct {
	Name        string      `json:"name"`
	Description pgtype.Text `json:"description"`
	Color       pgtype.Text `json:"color"`
}

func (q *Queries) InsertBadge(ctx context.Context, arg InsertBadgeParams) (Badge, error) {
	row := q.db.QueryRow(ctx, insertBadge, arg.Name, arg.Description, arg.Color)
	var i Badge
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Color,
	)
	return i, err
}

const removeBadgeFromUser = `-- name: RemoveBadgeFromUser :exec
DELETE FROM public.users_badges 
WHERE 
  user_id = $1 
  AND badge_id = $2
`

type RemoveBadgeFromUserParams struct {
	UserID  int64     `json:"user_id"`
	BadgeID uuid.UUID `json:"badge_id"`
}

func (q *Queries) RemoveBadgeFromUser(ctx context.Context, arg RemoveBadgeFromUserParams) error {
	_, err := q.db.Exec(ctx, removeBadgeFromUser, arg.UserID, arg.BadgeID)
	return err
}

const updateBadge = `-- name: UpdateBadge :one
UPDATE public.badges 
SET 
  name = $2, 
  description = $3,
  color = $4
WHERE 
  id = $1
RETURNING id, name, description, color
`

type UpdateBadgeParams struct {
	ID          uuid.UUID   `json:"id"`
	Name        string      `json:"name"`
	Description pgtype.Text `json:"description"`
	Color       pgtype.Text `json:"color"`
}

func (q *Queries) UpdateBadge(ctx context.Context, arg UpdateBadgeParams) (Badge, error) {
	row := q.db.QueryRow(ctx, updateBadge,
		arg.ID,
		arg.Name,
		arg.Description,
		arg.Color,
	)
	var i Badge
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Description,
		&i.Color,
	)
	return i, err
}