stufflog3/internal/database/mysql/mysqlcore/scope.sql.go

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

package mysqlcore

import (
	"context"
	"database/sql"
)

const getScope = `-- name: GetScope :one
SELECT id, name, abbreviation FROM scope
WHERE id = ?
`

func (q *Queries) GetScope(ctx context.Context, id int) (Scope, error) {
	row := q.queryRow(ctx, q.getScopeStmt, getScope, id)
	var i Scope
	err := row.Scan(&i.ID, &i.Name, &i.Abbreviation)
	return i, err
}

const getScopeDisplayName = `-- name: GetScopeDisplayName :one
SELECT name FROM scope_member
WHERE user_id = ? AND scope_id = ?
`

type GetScopeDisplayNameParams struct {
	UserID  string `json:"user_id"`
	ScopeID int    `json:"scope_id"`
}

func (q *Queries) GetScopeDisplayName(ctx context.Context, arg GetScopeDisplayNameParams) (string, error) {
	row := q.queryRow(ctx, q.getScopeDisplayNameStmt, getScopeDisplayName, arg.UserID, arg.ScopeID)
	var name string
	err := row.Scan(&name)
	return name, err
}

const getScopeWithDisplayName = `-- name: GetScopeWithDisplayName :one
SELECT id, scope.name, abbreviation, sm.name AS display_name FROM scope
LEFT JOIN scope_member sm ON scope.id = sm.scope_id
WHERE id = ? AND sm.user_id = ?
`

type GetScopeWithDisplayNameParams struct {
	ID     int    `json:"id"`
	UserID string `json:"user_id"`
}

type GetScopeWithDisplayNameRow struct {
	ID           int            `json:"id"`
	Name         string         `json:"name"`
	Abbreviation string         `json:"abbreviation"`
	DisplayName  sql.NullString `json:"display_name"`
}

func (q *Queries) GetScopeWithDisplayName(ctx context.Context, arg GetScopeWithDisplayNameParams) (GetScopeWithDisplayNameRow, error) {
	row := q.queryRow(ctx, q.getScopeWithDisplayNameStmt, getScopeWithDisplayName, arg.ID, arg.UserID)
	var i GetScopeWithDisplayNameRow
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Abbreviation,
		&i.DisplayName,
	)
	return i, err
}

const listScopeMembers = `-- name: ListScopeMembers :many
SELECT user_id, name, owner FROM scope_member
WHERE scope_id = ?
ORDER BY name
`

type ListScopeMembersRow struct {
	UserID string `json:"user_id"`
	Name   string `json:"name"`
	Owner  bool   `json:"owner"`
}

func (q *Queries) ListScopeMembers(ctx context.Context, scopeID int) ([]ListScopeMembersRow, error) {
	rows, err := q.query(ctx, q.listScopeMembersStmt, listScopeMembers, scopeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListScopeMembersRow{}
	for rows.Next() {
		var i ListScopeMembersRow
		if err := rows.Scan(&i.UserID, &i.Name, &i.Owner); 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 listScopes = `-- name: ListScopes :many
SELECT id, name, abbreviation FROM scope
ORDER BY name
`

func (q *Queries) ListScopes(ctx context.Context) ([]Scope, error) {
	rows, err := q.query(ctx, q.listScopesStmt, listScopes)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Scope{}
	for rows.Next() {
		var i Scope
		if err := rows.Scan(&i.ID, &i.Name, &i.Abbreviation); 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 listScopesByUser = `-- name: ListScopesByUser :many
SELECT id, s.name, abbreviation, sm.name as display_name FROM scope_member sm
RIGHT JOIN scope s on s.id = sm.scope_id
WHERE sm.user_id = ?
ORDER BY s.name
`

type ListScopesByUserRow struct {
	ID           int            `json:"id"`
	Name         string         `json:"name"`
	Abbreviation string         `json:"abbreviation"`
	DisplayName  sql.NullString `json:"display_name"`
}

func (q *Queries) ListScopesByUser(ctx context.Context, userID string) ([]ListScopesByUserRow, error) {
	rows, err := q.query(ctx, q.listScopesByUserStmt, listScopesByUser, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListScopesByUserRow{}
	for rows.Next() {
		var i ListScopesByUserRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Abbreviation,
			&i.DisplayName,
		); 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
}