mirror of
https://github.com/lightninglabs/lightning-terminal.git
synced 2026-08-13 12:33:36 +02:00
680 lines
16 KiB
Go
680 lines
16 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.25.0
|
|
// source: sessions.sql
|
|
|
|
package sqlc
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"time"
|
|
)
|
|
|
|
const deleteSessionsWithState = `-- name: DeleteSessionsWithState :exec
|
|
DELETE FROM sessions
|
|
WHERE state = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteSessionsWithState(ctx context.Context, state int16) error {
|
|
_, err := q.db.ExecContext(ctx, deleteSessionsWithState, state)
|
|
return err
|
|
}
|
|
|
|
const getAliasBySessionID = `-- name: GetAliasBySessionID :one
|
|
SELECT alias FROM sessions
|
|
WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) GetAliasBySessionID(ctx context.Context, id int64) ([]byte, error) {
|
|
row := q.db.QueryRowContext(ctx, getAliasBySessionID, id)
|
|
var alias []byte
|
|
err := row.Scan(&alias)
|
|
return alias, err
|
|
}
|
|
|
|
const getSessionAliasesInGroup = `-- name: GetSessionAliasesInGroup :many
|
|
SELECT alias FROM sessions
|
|
WHERE group_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionAliasesInGroup(ctx context.Context, groupID sql.NullInt64) ([][]byte, error) {
|
|
rows, err := q.db.QueryContext(ctx, getSessionAliasesInGroup, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items [][]byte
|
|
for rows.Next() {
|
|
var alias []byte
|
|
if err := rows.Scan(&alias); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, alias)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getSessionByAlias = `-- name: GetSessionByAlias :one
|
|
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
|
|
WHERE alias = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionByAlias(ctx context.Context, alias []byte) (Session, error) {
|
|
row := q.db.QueryRowContext(ctx, getSessionByAlias, alias)
|
|
var i Session
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Alias,
|
|
&i.Label,
|
|
&i.State,
|
|
&i.Type,
|
|
&i.Expiry,
|
|
&i.CreatedAt,
|
|
&i.RevokedAt,
|
|
&i.ServerAddress,
|
|
&i.DevServer,
|
|
&i.MacaroonRootKey,
|
|
&i.PairingSecret,
|
|
&i.LocalPrivateKey,
|
|
&i.LocalPublicKey,
|
|
&i.RemotePublicKey,
|
|
&i.Privacy,
|
|
&i.AccountID,
|
|
&i.GroupID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getSessionByID = `-- name: GetSessionByID :one
|
|
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
|
|
WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionByID(ctx context.Context, id int64) (Session, error) {
|
|
row := q.db.QueryRowContext(ctx, getSessionByID, id)
|
|
var i Session
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Alias,
|
|
&i.Label,
|
|
&i.State,
|
|
&i.Type,
|
|
&i.Expiry,
|
|
&i.CreatedAt,
|
|
&i.RevokedAt,
|
|
&i.ServerAddress,
|
|
&i.DevServer,
|
|
&i.MacaroonRootKey,
|
|
&i.PairingSecret,
|
|
&i.LocalPrivateKey,
|
|
&i.LocalPublicKey,
|
|
&i.RemotePublicKey,
|
|
&i.Privacy,
|
|
&i.AccountID,
|
|
&i.GroupID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getSessionByLocalPublicKey = `-- name: GetSessionByLocalPublicKey :one
|
|
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
|
|
WHERE local_public_key = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionByLocalPublicKey(ctx context.Context, localPublicKey []byte) (Session, error) {
|
|
row := q.db.QueryRowContext(ctx, getSessionByLocalPublicKey, localPublicKey)
|
|
var i Session
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Alias,
|
|
&i.Label,
|
|
&i.State,
|
|
&i.Type,
|
|
&i.Expiry,
|
|
&i.CreatedAt,
|
|
&i.RevokedAt,
|
|
&i.ServerAddress,
|
|
&i.DevServer,
|
|
&i.MacaroonRootKey,
|
|
&i.PairingSecret,
|
|
&i.LocalPrivateKey,
|
|
&i.LocalPublicKey,
|
|
&i.RemotePublicKey,
|
|
&i.Privacy,
|
|
&i.AccountID,
|
|
&i.GroupID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getSessionFeatureConfigs = `-- name: GetSessionFeatureConfigs :many
|
|
SELECT session_id, feature_name, config FROM session_feature_configs
|
|
WHERE session_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionFeatureConfigs(ctx context.Context, sessionID int64) ([]SessionFeatureConfig, error) {
|
|
rows, err := q.db.QueryContext(ctx, getSessionFeatureConfigs, sessionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []SessionFeatureConfig
|
|
for rows.Next() {
|
|
var i SessionFeatureConfig
|
|
if err := rows.Scan(&i.SessionID, &i.FeatureName, &i.Config); 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 getSessionIDByAlias = `-- name: GetSessionIDByAlias :one
|
|
SELECT id FROM sessions
|
|
WHERE alias = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionIDByAlias(ctx context.Context, alias []byte) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, getSessionIDByAlias, alias)
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const getSessionMacaroonCaveats = `-- name: GetSessionMacaroonCaveats :many
|
|
SELECT id, session_id, caveat_id, verification_id, location FROM session_macaroon_caveats
|
|
WHERE session_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionMacaroonCaveats(ctx context.Context, sessionID int64) ([]SessionMacaroonCaveat, error) {
|
|
rows, err := q.db.QueryContext(ctx, getSessionMacaroonCaveats, sessionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []SessionMacaroonCaveat
|
|
for rows.Next() {
|
|
var i SessionMacaroonCaveat
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.SessionID,
|
|
&i.CaveatID,
|
|
&i.VerificationID,
|
|
&i.Location,
|
|
); 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 getSessionMacaroonPermissions = `-- name: GetSessionMacaroonPermissions :many
|
|
SELECT id, session_id, entity, action FROM session_macaroon_permissions
|
|
WHERE session_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionMacaroonPermissions(ctx context.Context, sessionID int64) ([]SessionMacaroonPermission, error) {
|
|
rows, err := q.db.QueryContext(ctx, getSessionMacaroonPermissions, sessionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []SessionMacaroonPermission
|
|
for rows.Next() {
|
|
var i SessionMacaroonPermission
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.SessionID,
|
|
&i.Entity,
|
|
&i.Action,
|
|
); 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 getSessionPrivacyFlags = `-- name: GetSessionPrivacyFlags :many
|
|
SELECT session_id, flag FROM session_privacy_flags
|
|
WHERE session_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionPrivacyFlags(ctx context.Context, sessionID int64) ([]SessionPrivacyFlag, error) {
|
|
rows, err := q.db.QueryContext(ctx, getSessionPrivacyFlags, sessionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []SessionPrivacyFlag
|
|
for rows.Next() {
|
|
var i SessionPrivacyFlag
|
|
if err := rows.Scan(&i.SessionID, &i.Flag); 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 getSessionsInGroup = `-- name: GetSessionsInGroup :many
|
|
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
|
|
WHERE group_id = $1
|
|
`
|
|
|
|
func (q *Queries) GetSessionsInGroup(ctx context.Context, groupID sql.NullInt64) ([]Session, error) {
|
|
rows, err := q.db.QueryContext(ctx, getSessionsInGroup, groupID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Session
|
|
for rows.Next() {
|
|
var i Session
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Alias,
|
|
&i.Label,
|
|
&i.State,
|
|
&i.Type,
|
|
&i.Expiry,
|
|
&i.CreatedAt,
|
|
&i.RevokedAt,
|
|
&i.ServerAddress,
|
|
&i.DevServer,
|
|
&i.MacaroonRootKey,
|
|
&i.PairingSecret,
|
|
&i.LocalPrivateKey,
|
|
&i.LocalPublicKey,
|
|
&i.RemotePublicKey,
|
|
&i.Privacy,
|
|
&i.AccountID,
|
|
&i.GroupID,
|
|
); 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 insertSession = `-- name: InsertSession :one
|
|
INSERT INTO sessions (
|
|
alias, label, state, type, expiry, created_at,
|
|
server_address, dev_server, macaroon_root_key, pairing_secret,
|
|
local_private_key, local_public_key, remote_public_key, privacy, group_id, account_id
|
|
) VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7,
|
|
$8, $9, $10, $11, $12,
|
|
$13, $14, $15, $16
|
|
) RETURNING id
|
|
`
|
|
|
|
type InsertSessionParams struct {
|
|
Alias []byte
|
|
Label string
|
|
State int16
|
|
Type int16
|
|
Expiry time.Time
|
|
CreatedAt time.Time
|
|
ServerAddress string
|
|
DevServer bool
|
|
MacaroonRootKey int64
|
|
PairingSecret []byte
|
|
LocalPrivateKey []byte
|
|
LocalPublicKey []byte
|
|
RemotePublicKey []byte
|
|
Privacy bool
|
|
GroupID sql.NullInt64
|
|
AccountID sql.NullInt64
|
|
}
|
|
|
|
func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, insertSession,
|
|
arg.Alias,
|
|
arg.Label,
|
|
arg.State,
|
|
arg.Type,
|
|
arg.Expiry,
|
|
arg.CreatedAt,
|
|
arg.ServerAddress,
|
|
arg.DevServer,
|
|
arg.MacaroonRootKey,
|
|
arg.PairingSecret,
|
|
arg.LocalPrivateKey,
|
|
arg.LocalPublicKey,
|
|
arg.RemotePublicKey,
|
|
arg.Privacy,
|
|
arg.GroupID,
|
|
arg.AccountID,
|
|
)
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const insertSessionFeatureConfig = `-- name: InsertSessionFeatureConfig :exec
|
|
INSERT INTO session_feature_configs (
|
|
session_id, feature_name, config
|
|
) VALUES (
|
|
$1, $2, $3
|
|
)
|
|
`
|
|
|
|
type InsertSessionFeatureConfigParams struct {
|
|
SessionID int64
|
|
FeatureName string
|
|
Config []byte
|
|
}
|
|
|
|
func (q *Queries) InsertSessionFeatureConfig(ctx context.Context, arg InsertSessionFeatureConfigParams) error {
|
|
_, err := q.db.ExecContext(ctx, insertSessionFeatureConfig, arg.SessionID, arg.FeatureName, arg.Config)
|
|
return err
|
|
}
|
|
|
|
const insertSessionMacaroonCaveat = `-- name: InsertSessionMacaroonCaveat :exec
|
|
INSERT INTO session_macaroon_caveats (
|
|
session_id, caveat_id, verification_id, location
|
|
) VALUES (
|
|
$1, $2, $3, $4
|
|
)
|
|
`
|
|
|
|
type InsertSessionMacaroonCaveatParams struct {
|
|
SessionID int64
|
|
CaveatID []byte
|
|
VerificationID []byte
|
|
Location sql.NullString
|
|
}
|
|
|
|
func (q *Queries) InsertSessionMacaroonCaveat(ctx context.Context, arg InsertSessionMacaroonCaveatParams) error {
|
|
_, err := q.db.ExecContext(ctx, insertSessionMacaroonCaveat,
|
|
arg.SessionID,
|
|
arg.CaveatID,
|
|
arg.VerificationID,
|
|
arg.Location,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertSessionMacaroonPermission = `-- name: InsertSessionMacaroonPermission :exec
|
|
INSERT INTO session_macaroon_permissions (
|
|
session_id, entity, action
|
|
) VALUES (
|
|
$1, $2, $3
|
|
)
|
|
`
|
|
|
|
type InsertSessionMacaroonPermissionParams struct {
|
|
SessionID int64
|
|
Entity string
|
|
Action string
|
|
}
|
|
|
|
func (q *Queries) InsertSessionMacaroonPermission(ctx context.Context, arg InsertSessionMacaroonPermissionParams) error {
|
|
_, err := q.db.ExecContext(ctx, insertSessionMacaroonPermission, arg.SessionID, arg.Entity, arg.Action)
|
|
return err
|
|
}
|
|
|
|
const insertSessionPrivacyFlag = `-- name: InsertSessionPrivacyFlag :exec
|
|
INSERT INTO session_privacy_flags (
|
|
session_id, flag
|
|
) VALUES (
|
|
$1, $2
|
|
)
|
|
`
|
|
|
|
type InsertSessionPrivacyFlagParams struct {
|
|
SessionID int64
|
|
Flag int32
|
|
}
|
|
|
|
func (q *Queries) InsertSessionPrivacyFlag(ctx context.Context, arg InsertSessionPrivacyFlagParams) error {
|
|
_, err := q.db.ExecContext(ctx, insertSessionPrivacyFlag, arg.SessionID, arg.Flag)
|
|
return err
|
|
}
|
|
|
|
const listSessions = `-- name: ListSessions :many
|
|
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
|
|
ORDER BY created_at
|
|
`
|
|
|
|
func (q *Queries) ListSessions(ctx context.Context) ([]Session, error) {
|
|
rows, err := q.db.QueryContext(ctx, listSessions)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Session
|
|
for rows.Next() {
|
|
var i Session
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Alias,
|
|
&i.Label,
|
|
&i.State,
|
|
&i.Type,
|
|
&i.Expiry,
|
|
&i.CreatedAt,
|
|
&i.RevokedAt,
|
|
&i.ServerAddress,
|
|
&i.DevServer,
|
|
&i.MacaroonRootKey,
|
|
&i.PairingSecret,
|
|
&i.LocalPrivateKey,
|
|
&i.LocalPublicKey,
|
|
&i.RemotePublicKey,
|
|
&i.Privacy,
|
|
&i.AccountID,
|
|
&i.GroupID,
|
|
); 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 listSessionsByState = `-- name: ListSessionsByState :many
|
|
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
|
|
WHERE state = $1
|
|
ORDER BY created_at
|
|
`
|
|
|
|
func (q *Queries) ListSessionsByState(ctx context.Context, state int16) ([]Session, error) {
|
|
rows, err := q.db.QueryContext(ctx, listSessionsByState, state)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Session
|
|
for rows.Next() {
|
|
var i Session
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Alias,
|
|
&i.Label,
|
|
&i.State,
|
|
&i.Type,
|
|
&i.Expiry,
|
|
&i.CreatedAt,
|
|
&i.RevokedAt,
|
|
&i.ServerAddress,
|
|
&i.DevServer,
|
|
&i.MacaroonRootKey,
|
|
&i.PairingSecret,
|
|
&i.LocalPrivateKey,
|
|
&i.LocalPublicKey,
|
|
&i.RemotePublicKey,
|
|
&i.Privacy,
|
|
&i.AccountID,
|
|
&i.GroupID,
|
|
); 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 listSessionsByType = `-- name: ListSessionsByType :many
|
|
SELECT id, alias, label, state, type, expiry, created_at, revoked_at, server_address, dev_server, macaroon_root_key, pairing_secret, local_private_key, local_public_key, remote_public_key, privacy, account_id, group_id FROM sessions
|
|
WHERE type = $1
|
|
ORDER BY created_at
|
|
`
|
|
|
|
func (q *Queries) ListSessionsByType(ctx context.Context, type_ int16) ([]Session, error) {
|
|
rows, err := q.db.QueryContext(ctx, listSessionsByType, type_)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Session
|
|
for rows.Next() {
|
|
var i Session
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Alias,
|
|
&i.Label,
|
|
&i.State,
|
|
&i.Type,
|
|
&i.Expiry,
|
|
&i.CreatedAt,
|
|
&i.RevokedAt,
|
|
&i.ServerAddress,
|
|
&i.DevServer,
|
|
&i.MacaroonRootKey,
|
|
&i.PairingSecret,
|
|
&i.LocalPrivateKey,
|
|
&i.LocalPublicKey,
|
|
&i.RemotePublicKey,
|
|
&i.Privacy,
|
|
&i.AccountID,
|
|
&i.GroupID,
|
|
); 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 setSessionGroupID = `-- name: SetSessionGroupID :exec
|
|
UPDATE sessions
|
|
SET group_id = $1
|
|
WHERE id = $2
|
|
`
|
|
|
|
type SetSessionGroupIDParams struct {
|
|
GroupID sql.NullInt64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) SetSessionGroupID(ctx context.Context, arg SetSessionGroupIDParams) error {
|
|
_, err := q.db.ExecContext(ctx, setSessionGroupID, arg.GroupID, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const setSessionRemotePublicKey = `-- name: SetSessionRemotePublicKey :exec
|
|
UPDATE sessions
|
|
SET remote_public_key = $1
|
|
WHERE id = $2
|
|
`
|
|
|
|
type SetSessionRemotePublicKeyParams struct {
|
|
RemotePublicKey []byte
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) SetSessionRemotePublicKey(ctx context.Context, arg SetSessionRemotePublicKeyParams) error {
|
|
_, err := q.db.ExecContext(ctx, setSessionRemotePublicKey, arg.RemotePublicKey, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const setSessionRevokedAt = `-- name: SetSessionRevokedAt :exec
|
|
UPDATE sessions
|
|
SET revoked_at = $1
|
|
WHERE id = $2
|
|
`
|
|
|
|
type SetSessionRevokedAtParams struct {
|
|
RevokedAt sql.NullTime
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) SetSessionRevokedAt(ctx context.Context, arg SetSessionRevokedAtParams) error {
|
|
_, err := q.db.ExecContext(ctx, setSessionRevokedAt, arg.RevokedAt, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const updateSessionState = `-- name: UpdateSessionState :exec
|
|
UPDATE sessions
|
|
SET state = $1
|
|
WHERE id = $2
|
|
`
|
|
|
|
type UpdateSessionStateParams struct {
|
|
State int16
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateSessionState(ctx context.Context, arg UpdateSessionStateParams) error {
|
|
_, err := q.db.ExecContext(ctx, updateSessionState, arg.State, arg.ID)
|
|
return err
|
|
}
|