// Code generated by sqlc. DO NOT EDIT.

// versions:

// sqlc v1.20.0

package database

import (

"context"

"database/sql"

"encoding/json"

"time"

"github.com/google/uuid"

"github.com/lib/pq"

"github.com/sqlc-dev/pqtype"

)

const activityBumpWorkspace = `-- name: ActivityBumpWorkspace :exec

WITH latest AS (

SELECT

workspace_builds.id::uuid AS build_id,

workspace_builds.deadline::timestamp with time zone AS build_deadline,

workspace_builds.max_deadline::timestamp with time zone AS build_max_deadline,

workspace_builds.transition AS build_transition,

provisioner_jobs.completed_at::timestamp with time zone AS job_completed_at,

(workspaces.ttl / 1000 / 1000 / 1000 || ' seconds')::interval AS ttl_interval

FROM workspace_builds

JOIN provisioner_jobs

ON provisioner_jobs.id = workspace_builds.job_id

JOIN workspaces

ON workspaces.id = workspace_builds.workspace_id

WHERE workspace_builds.workspace_id = $1::uuid

ORDER BY workspace_builds.build_number DESC

LIMIT 1

)

UPDATE

workspace_builds wb

SET

updated_at = NOW(),

deadline = CASE

WHEN l.build_max_deadline = '0001-01-01 00:00:00+00'

THEN NOW() + l.ttl_interval

ELSE LEAST(NOW() + l.ttl_interval, l.build_max_deadline)

END

FROM latest l

WHERE wb.id = l.build_id

AND l.job_completed_at IS NOT NULL

AND l.build_transition = 'start'

AND l.build_deadline != '0001-01-01 00:00:00+00'

AND l.build_deadline - (l.ttl_interval * 0.95) < NOW()

`

// We bump by the original TTL to prevent counter-intuitive behavior

// as the TTL wraps. For example, if I set the TTL to 12 hours, sign off

// work at midnight, come back at 10am, I would want another full day

// of uptime.

// We only bump if workspace shutdown is manual.

// We only bump when 5% of the deadline has elapsed.

func (q *sqlQuerier) ActivityBumpWorkspace(ctx context.Context, workspaceID uuid.UUID) error {

_, err := q.db.ExecContext(ctx, activityBumpWorkspace, workspaceID)

return err

}

const deleteAPIKeyByID = `-- name: DeleteAPIKeyByID :exec

DELETE FROM

api_keys

WHERE

id = $1

`

func (q *sqlQuerier) DeleteAPIKeyByID(ctx context.Context, id string) error {

_, err := q.db.ExecContext(ctx, deleteAPIKeyByID, id)

return err

}

const deleteAPIKeysByUserID = `-- name: DeleteAPIKeysByUserID :exec

DELETE FROM

api_keys

WHERE

user_id = $1

`

func (q *sqlQuerier) DeleteAPIKeysByUserID(ctx context.Context, userID uuid.UUID) error {

_, err := q.db.ExecContext(ctx, deleteAPIKeysByUserID, userID)

return err

}

const deleteApplicationConnectAPIKeysByUserID = `-- name: DeleteApplicationConnectAPIKeysByUserID :exec

DELETE FROM

api_keys

WHERE

user_id = $1 AND

scope = 'application_connect'::api_key_scope

`

func (q *sqlQuerier) DeleteApplicationConnectAPIKeysByUserID(ctx context.Context, userID uuid.UUID) error {

_, err := q.db.ExecContext(ctx, deleteApplicationConnectAPIKeysByUserID, userID)

return err

}

const getAPIKeyByID = `-- name: GetAPIKeyByID :one

SELECT

id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope, token_name

FROM

api_keys

WHERE

id = $1

LIMIT

1

`

func (q *sqlQuerier) GetAPIKeyByID(ctx context.Context, id string) (APIKey, error) {

row := q.db.QueryRowContext(ctx, getAPIKeyByID, id)

var i APIKey

err := row.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

&i.TokenName,

)

return i, err

}

const getAPIKeyByName = `-- name: GetAPIKeyByName :one

SELECT

id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope, token_name

FROM

api_keys

WHERE

user_id = $1 AND

token_name = $2 AND

token_name != ''

LIMIT

1

`

type GetAPIKeyByNameParams struct {

UserID uuid.UUID `db:"user_id" json:"user_id"`

TokenName string `db:"token_name" json:"token_name"`

}

// there is no unique constraint on empty token names

func (q *sqlQuerier) GetAPIKeyByName(ctx context.Context, arg GetAPIKeyByNameParams) (APIKey, error) {

row := q.db.QueryRowContext(ctx, getAPIKeyByName, arg.UserID, arg.TokenName)

var i APIKey

err := row.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

&i.TokenName,

)

return i, err

}

const getAPIKeysByLoginType = `-- name: GetAPIKeysByLoginType :many

SELECT id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope, token_name FROM api_keys WHERE login_type = $1

`

func (q *sqlQuerier) GetAPIKeysByLoginType(ctx context.Context, loginType LoginType) ([]APIKey, error) {

rows, err := q.db.QueryContext(ctx, getAPIKeysByLoginType, loginType)

if err != nil {

return nil, err

}

defer rows.Close()

var items []APIKey

for rows.Next() {

var i APIKey

if err := rows.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

&i.TokenName,

); 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 getAPIKeysByUserID = `-- name: GetAPIKeysByUserID :many

SELECT id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope, token_name FROM api_keys WHERE login_type = $1 AND user_id = $2

`

type GetAPIKeysByUserIDParams struct {

LoginType LoginType `db:"login_type" json:"login_type"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

}

func (q *sqlQuerier) GetAPIKeysByUserID(ctx context.Context, arg GetAPIKeysByUserIDParams) ([]APIKey, error) {

rows, err := q.db.QueryContext(ctx, getAPIKeysByUserID, arg.LoginType, arg.UserID)

if err != nil {

return nil, err

}

defer rows.Close()

var items []APIKey

for rows.Next() {

var i APIKey

if err := rows.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

&i.TokenName,

); 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 getAPIKeysLastUsedAfter = `-- name: GetAPIKeysLastUsedAfter :many

SELECT id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope, token_name FROM api_keys WHERE last_used > $1

`

func (q *sqlQuerier) GetAPIKeysLastUsedAfter(ctx context.Context, lastUsed time.Time) ([]APIKey, error) {

rows, err := q.db.QueryContext(ctx, getAPIKeysLastUsedAfter, lastUsed)

if err != nil {

return nil, err

}

defer rows.Close()

var items []APIKey

for rows.Next() {

var i APIKey

if err := rows.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

&i.TokenName,

); 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 insertAPIKey = `-- name: InsertAPIKey :one

INSERT INTO

api_keys (

id,

lifetime_seconds,

hashed_secret,

ip_address,

user_id,

last_used,

expires_at,

created_at,

updated_at,

login_type,

scope,

token_name

)

VALUES

($1,

-- If the lifetime is set to 0, default to 24hrs

CASE $2::bigint

WHEN 0 THEN 86400

ELSE $2::bigint

END

, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) RETURNING id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope, token_name

`

type InsertAPIKeyParams struct {

ID string `db:"id" json:"id"`

LifetimeSeconds int64 `db:"lifetime_seconds" json:"lifetime_seconds"`

HashedSecret []byte `db:"hashed_secret" json:"hashed_secret"`

IPAddress pqtype.Inet `db:"ip_address" json:"ip_address"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

LastUsed time.Time `db:"last_used" json:"last_used"`

ExpiresAt time.Time `db:"expires_at" json:"expires_at"`

CreatedAt time.Time `db:"created_at" json:"created_at"`

UpdatedAt time.Time `db:"updated_at" json:"updated_at"`

LoginType LoginType `db:"login_type" json:"login_type"`

Scope APIKeyScope `db:"scope" json:"scope"`

TokenName string `db:"token_name" json:"token_name"`

}

func (q *sqlQuerier) InsertAPIKey(ctx context.Context, arg InsertAPIKeyParams) (APIKey, error) {

row := q.db.QueryRowContext(ctx, insertAPIKey,

arg.ID,

arg.LifetimeSeconds,

arg.HashedSecret,

arg.IPAddress,

arg.UserID,

arg.LastUsed,

arg.ExpiresAt,

arg.CreatedAt,

arg.UpdatedAt,

arg.LoginType,

arg.Scope,

arg.TokenName,

)

var i APIKey

err := row.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

&i.TokenName,

)

return i, err

}

const updateAPIKeyByID = `-- name: UpdateAPIKeyByID :exec

UPDATE

api_keys

SET

last_used = $2,

expires_at = $3,

ip_address = $4

WHERE

id = $1

`

type UpdateAPIKeyByIDParams struct {

ID string `db:"id" json:"id"`

LastUsed time.Time `db:"last_used" json:"last_used"`

ExpiresAt time.Time `db:"expires_at" json:"expires_at"`

IPAddress pqtype.Inet `db:"ip_address" json:"ip_address"`

}

func (q *sqlQuerier) UpdateAPIKeyByID(ctx context.Context, arg UpdateAPIKeyByIDParams) error {

_, err := q.db.ExecContext(ctx, updateAPIKeyByID,

arg.ID,

arg.LastUsed,

arg.ExpiresAt,

arg.IPAddress,

)

return err

}

const getAuditLogsOffset = `-- name: GetAuditLogsOffset :many

SELECT

audit_logs.id, audit_logs.time, audit_logs.user_id, audit_logs.organization_id, audit_logs.ip, audit_logs.user_agent, audit_logs.resource_type, audit_logs.resource_id, audit_logs.resource_target, audit_logs.action, audit_logs.diff, audit_logs.status_code, audit_logs.additional_fields, audit_logs.request_id, audit_logs.resource_icon,

users.username AS user_username,

users.email AS user_email,

users.created_at AS user_created_at,

users.status AS user_status,

users.rbac_roles AS user_roles,

users.avatar_url AS user_avatar_url,

COUNT(audit_logs.*) OVER () AS count

FROM

audit_logs

LEFT JOIN users ON audit_logs.user_id = users.id

LEFT JOIN

-- First join on workspaces to get the initial workspace create

-- to workspace build 1 id. This is because the first create is

-- is a different audit log than subsequent starts.

workspaces ON

audit_logs.resource_type = 'workspace' AND

audit_logs.resource_id = workspaces.id

LEFT JOIN

workspace_builds ON

-- Get the reason from the build if the resource type

-- is a workspace_build

(

audit_logs.resource_type = 'workspace_build'

AND audit_logs.resource_id = workspace_builds.id

)

OR

-- Get the reason from the build #1 if this is the first

-- workspace create.

(

audit_logs.resource_type = 'workspace' AND

audit_logs.action = 'create' AND

workspaces.id = workspace_builds.workspace_id AND

workspace_builds.build_number = 1

)

WHERE

-- Filter resource_type

CASE

WHEN $3 :: text != '' THEN

resource_type = $3 :: resource_type

ELSE true

END

-- Filter resource_id

AND CASE

WHEN $4 :: uuid != '00000000-0000-0000-0000-000000000000'::uuid THEN

resource_id = $4

ELSE true

END

-- Filter by resource_target

AND CASE

WHEN $5 :: text != '' THEN

resource_target = $5

ELSE true

END

-- Filter action

AND CASE

WHEN $6 :: text != '' THEN

action = $6 :: audit_action

ELSE true

END

-- Filter by user_id

AND CASE

WHEN $7 :: uuid != '00000000-0000-0000-0000-000000000000'::uuid THEN

user_id = $7

ELSE true

END

-- Filter by username

AND CASE

WHEN $8 :: text != '' THEN

user_id = (SELECT id FROM users WHERE lower(username) = lower($8) AND deleted = false)

ELSE true

END

-- Filter by user_email

AND CASE

WHEN $9 :: text != '' THEN

users.email = $9

ELSE true

END

-- Filter by date_from

AND CASE

WHEN $10 :: timestamp with time zone != '0001-01-01 00:00:00Z' THEN

"time" >= $10

ELSE true

END

-- Filter by date_to

AND CASE

WHEN $11 :: timestamp with time zone != '0001-01-01 00:00:00Z' THEN

"time" <= $11

ELSE true

END

-- Filter by build_reason

AND CASE

WHEN $12::text != '' THEN

workspace_builds.reason::text = $12

ELSE true

END

ORDER BY

"time" DESC

LIMIT

$1

OFFSET

$2

`

type GetAuditLogsOffsetParams struct {

Limit int32 `db:"limit" json:"limit"`

Offset int32 `db:"offset" json:"offset"`

ResourceType string `db:"resource_type" json:"resource_type"`

ResourceID uuid.UUID `db:"resource_id" json:"resource_id"`

ResourceTarget string `db:"resource_target" json:"resource_target"`

Action string `db:"action" json:"action"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

Username string `db:"username" json:"username"`

Email string `db:"email" json:"email"`

DateFrom time.Time `db:"date_from" json:"date_from"`

DateTo time.Time `db:"date_to" json:"date_to"`

BuildReason string `db:"build_reason" json:"build_reason"`

}

type GetAuditLogsOffsetRow struct {

ID uuid.UUID `db:"id" json:"id"`

Time time.Time `db:"time" json:"time"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"`

Ip pqtype.Inet `db:"ip" json:"ip"`

UserAgent sql.NullString `db:"user_agent" json:"user_agent"`

ResourceType ResourceType `db:"resource_type" json:"resource_type"`

ResourceID uuid.UUID `db:"resource_id" json:"resource_id"`

ResourceTarget string `db:"resource_target" json:"resource_target"`

Action AuditAction `db:"action" json:"action"`

Diff json.RawMessage `db:"diff" json:"diff"`

StatusCode int32 `db:"status_code" json:"status_code"`

AdditionalFields json.RawMessage `db:"additional_fields" json:"additional_fields"`

RequestID uuid.UUID `db:"request_id" json:"request_id"`

ResourceIcon string `db:"resource_icon" json:"resource_icon"`

UserUsername sql.NullString `db:"user_username" json:"user_username"`

UserEmail sql.NullString `db:"user_email" json:"user_email"`

UserCreatedAt sql.NullTime `db:"user_created_at" json:"user_created_at"`

UserStatus NullUserStatus `db:"user_status" json:"user_status"`

UserRoles pq.StringArray `db:"user_roles" json:"user_roles"`

UserAvatarUrl sql.NullString `db:"user_avatar_url" json:"user_avatar_url"`

Count int64 `db:"count" json:"count"`

}

// GetAuditLogsBefore retrieves `row_limit` number of audit logs before the provided

// ID.

func (q *sqlQuerier) GetAuditLogsOffset(ctx context.Context, arg GetAuditLogsOffsetParams) ([]GetAuditLogsOffsetRow, error) {

rows, err := q.db.QueryContext(ctx, getAuditLogsOffset,

arg.Limit,

arg.Offset,

arg.ResourceType,

arg.ResourceID,

arg.ResourceTarget,

arg.Action,

arg.UserID,

arg.Username,

arg.Email,

arg.DateFrom,

arg.DateTo,

arg.BuildReason,

)

if err != nil {

return nil, err

}

defer rows.Close()

var items []GetAuditLogsOffsetRow

for rows.Next() {

var i GetAuditLogsOffsetRow

if err := rows.Scan(

&i.ID,

&i.Time,

&i.UserID,

&i.OrganizationID,

&i.Ip,

&i.UserAgent,

&i.ResourceType,

&i.ResourceID,

&i.ResourceTarget,

&i.Action,

&i.Diff,

&i.StatusCode,

&i.AdditionalFields,

&i.RequestID,

&i.ResourceIcon,

&i.UserUsername,

&i.UserEmail,

&i.UserCreatedAt,

&i.UserStatus,

&i.UserRoles,

&i.UserAvatarUrl,

&i.Count,

); 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 insertAuditLog = `-- name: InsertAuditLog :one

INSERT INTO

audit_logs (

id,

"time",

user_id,

organization_id,

ip,

user_agent,

resource_type,

resource_id,

resource_target,

action,

diff,

status_code,

additional_fields,

request_id,

resource_icon

)

VALUES

($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) RETURNING id, time, user_id, organization_id, ip, user_agent, resource_type, resource_id, resource_target, action, diff, status_code, additional_fields, request_id, resource_icon

`

type InsertAuditLogParams struct {

ID uuid.UUID `db:"id" json:"id"`

Time time.Time `db:"time" json:"time"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"`

Ip pqtype.Inet `db:"ip" json:"ip"`

UserAgent sql.NullString `db:"user_agent" json:"user_agent"`

ResourceType ResourceType `db:"resource_type" json:"resource_type"`

ResourceID uuid.UUID `db:"resource_id" json:"resource_id"`

ResourceTarget string `db:"resource_target" json:"resource_target"`

Action AuditAction `db:"action" json:"action"`

Diff json.RawMessage `db:"diff" json:"diff"`

StatusCode int32 `db:"status_code" json:"status_code"`

AdditionalFields json.RawMessage `db:"additional_fields" json:"additional_fields"`

RequestID uuid.UUID `db:"request_id" json:"request_id"`

ResourceIcon string `db:"resource_icon" json:"resource_icon"`

}

func (q *sqlQuerier) InsertAuditLog(ctx context.Context, arg InsertAuditLogParams) (AuditLog, error) {

row := q.db.QueryRowContext(ctx, insertAuditLog,

arg.ID,

arg.Time,

arg.UserID,

arg.OrganizationID,

arg.Ip,

arg.UserAgent,

arg.ResourceType,

arg.ResourceID,

arg.ResourceTarget,

arg.Action,

arg.Diff,

arg.StatusCode,

arg.AdditionalFields,

arg.RequestID,

arg.ResourceIcon,

)

var i AuditLog

err := row.Scan(

&i.ID,

&i.Time,

&i.UserID,

&i.OrganizationID,

&i.Ip,

&i.UserAgent,

&i.ResourceType,

&i.ResourceID,

&i.ResourceTarget,

&i.Action,

&i.Diff,

&i.StatusCode,

&i.AdditionalFields,

&i.RequestID,

&i.ResourceIcon,

)

return i, err

}

const getDBCryptKeys = `-- name: GetDBCryptKeys :many

SELECT number, active_key_digest, revoked_key_digest, created_at, revoked_at, test FROM dbcrypt_keys ORDER BY number ASC

`

func (q *sqlQuerier) GetDBCryptKeys(ctx context.Context) ([]DBCryptKey, error) {

rows, err := q.db.QueryContext(ctx, getDBCryptKeys)

if err != nil {

return nil, err

}

defer rows.Close()

var items []DBCryptKey

for rows.Next() {

var i DBCryptKey

if err := rows.Scan(

&i.Number,

&i.ActiveKeyDigest,

&i.RevokedKeyDigest,

&i.CreatedAt,

&i.RevokedAt,

&i.Test,

); 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 insertDBCryptKey = `-- name: InsertDBCryptKey :exec

INSERT INTO dbcrypt_keys

(number, active_key_digest, created_at, test)

VALUES ($1::int, $2::text, CURRENT_TIMESTAMP, $3::text)

`

type InsertDBCryptKeyParams struct {

Number int32 `db:"number" json:"number"`

ActiveKeyDigest string `db:"active_key_digest" json:"active_key_digest"`

Test string `db:"test" json:"test"`

}

func (q *sqlQuerier) InsertDBCryptKey(ctx context.Context, arg InsertDBCryptKeyParams) error {

_, err := q.db.ExecContext(ctx, insertDBCryptKey, arg.Number, arg.ActiveKeyDigest, arg.Test)

return err

}

const revokeDBCryptKey = `-- name: RevokeDBCryptKey :exec

UPDATE dbcrypt_keys

SET

revoked_key_digest = active_key_digest,

active_key_digest = revoked_key_digest,

revoked_at = CURRENT_TIMESTAMP

WHERE

active_key_digest = $1::text

AND

revoked_key_digest IS NULL

`

func (q *sqlQuerier) RevokeDBCryptKey(ctx context.Context, activeKeyDigest string) error {

_, err := q.db.ExecContext(ctx, revokeDBCryptKey, activeKeyDigest)

return err

}

const getFileByHashAndCreator = `-- name: GetFileByHashAndCreator :one

SELECT

hash, created_at, created_by, mimetype, data, id

FROM

files

WHERE

hash = $1

AND

created_by = $2

LIMIT

1

`

type GetFileByHashAndCreatorParams struct {

Hash string `db:"hash" json:"hash"`

CreatedBy uuid.UUID `db:"created_by" json:"created_by"`

}

func (q *sqlQuerier) GetFileByHashAndCreator(ctx context.Context, arg GetFileByHashAndCreatorParams) (File, error) {

row := q.db.QueryRowContext(ctx, getFileByHashAndCreator, arg.Hash, arg.CreatedBy)

var i File

err := row.Scan(

&i.Hash,

&i.CreatedAt,

&i.CreatedBy,

&i.Mimetype,

&i.Data,

&i.ID,

)

return i, err

}

const getFileByID = `-- name: GetFileByID :one

SELECT

hash, created_at, created_by, mimetype, data, id

FROM

files

WHERE

id = $1

LIMIT

1

`

func (q *sqlQuerier) GetFileByID(ctx context.Context, id uuid.UUID) (File, error) {

row := q.db.QueryRowContext(ctx, getFileByID, id)

var i File

err := row.Scan(

&i.Hash,

&i.CreatedAt,

&i.CreatedBy,

&i.Mimetype,

&i.Data,

&i.ID,

)

return i, err

}

const getFileTemplates = `-- name: GetFileTemplates :many

SELECT

files.id AS file_id,

files.created_by AS file_created_by,

templates.id AS template_id,

templates.organization_id AS template_organization_id,

templates.created_by AS template_created_by,

templates.user_acl,

templates.group_acl

FROM

templates

INNER JOIN

template_versions

ON templates.id = template_versions.template_id

INNER JOIN

provisioner_jobs

ON job_id = provisioner_jobs.id

INNER JOIN

files

ON files.id = provisioner_jobs.file_id

WHERE

-- Only fetch template version associated files.

storage_method = 'file'

AND provisioner_jobs.type = 'template_version_import'

AND file_id = $1

`

type GetFileTemplatesRow struct {

FileID uuid.UUID `db:"file_id" json:"file_id"`

FileCreatedBy uuid.UUID `db:"file_created_by" json:"file_created_by"`

TemplateID uuid.UUID `db:"template_id" json:"template_id"`

TemplateOrganizationID uuid.UUID `db:"template_organization_id" json:"template_organization_id"`

TemplateCreatedBy uuid.UUID `db:"template_created_by" json:"template_created_by"`

UserACL TemplateACL `db:"user_acl" json:"user_acl"`

GroupACL TemplateACL `db:"group_acl" json:"group_acl"`

}

// Get all templates that use a file.

func (q *sqlQuerier) GetFileTemplates(ctx context.Context, fileID uuid.UUID) ([]GetFileTemplatesRow, error) {

rows, err := q.db.QueryContext(ctx, getFileTemplates, fileID)

if err != nil {

return nil, err

}

defer rows.Close()

var items []GetFileTemplatesRow

for rows.Next() {

var i GetFileTemplatesRow

if err := rows.Scan(

&i.FileID,

&i.FileCreatedBy,

&i.TemplateID,

&i.TemplateOrganizationID,

&i.TemplateCreatedBy,

&i.UserACL,

&i.GroupACL,

); 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 insertFile = `-- name: InsertFile :one

INSERT INTO

files (id, hash, created_at, created_by, mimetype, "data")

VALUES

($1, $2, $3, $4, $5, $6) RETURNING hash, created_at, created_by, mimetype, data, id

`

type InsertFileParams struct {

ID uuid.UUID `db:"id" json:"id"`

Hash string `db:"hash" json:"hash"`

CreatedAt time.Time `db:"created_at" json:"created_at"`

CreatedBy uuid.UUID `db:"created_by" json:"created_by"`

Mimetype string `db:"mimetype" json:"mimetype"`

Data []byte `db:"data" json:"data"`

}

func (q *sqlQuerier) InsertFile(ctx context.Context, arg InsertFileParams) (File, error) {

row := q.db.QueryRowContext(ctx, insertFile,

arg.ID,

arg.Hash,

arg.CreatedAt,

arg.CreatedBy,

arg.Mimetype,

arg.Data,

)

var i File

err := row.Scan(

&i.Hash,

&i.CreatedAt,

&i.CreatedBy,

&i.Mimetype,

&i.Data,

&i.ID,

)

return i, err

}

const getGitAuthLink = `-- name: GetGitAuthLink :one

SELECT provider_id, user_id, created_at, updated_at, oauth_access_token, oauth_refresh_token, oauth_expiry, oauth_access_token_key_id, oauth_refresh_token_key_id FROM git_auth_links WHERE provider_id = $1 AND user_id = $2

`

type GetGitAuthLinkParams struct {

ProviderID string `db:"provider_id" json:"provider_id"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

}

func (q *sqlQuerier) GetGitAuthLink(ctx context.Context, arg GetGitAuthLinkParams) (GitAuthLink, error) {

row := q.db.QueryRowContext(ctx, getGitAuthLink, arg.ProviderID, arg.UserID)

var i GitAuthLink

err := row.Scan(

&i.ProviderID,

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.OAuthAccessToken,

&i.OAuthRefreshToken,

&i.OAuthExpiry,

&i.OAuthAccessTokenKeyID,

&i.OAuthRefreshTokenKeyID,

)

return i, err

}

const getGitAuthLinksByUserID = `-- name: GetGitAuthLinksByUserID :many

SELECT provider_id, user_id, created_at, updated_at, oauth_access_token, oauth_refresh_token, oauth_expiry, oauth_access_token_key_id, oauth_refresh_token_key_id FROM git_auth_links WHERE user_id = $1

`

func (q *sqlQuerier) GetGitAuthLinksByUserID(ctx context.Context, userID uuid.UUID) ([]GitAuthLink, error) {

rows, err := q.db.QueryContext(ctx, getGitAuthLinksByUserID, userID)

if err != nil {

return nil, err

}

defer rows.Close()

var items []GitAuthLink

for rows.Next() {

var i GitAuthLink

if err := rows.Scan(

&i.ProviderID,

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.OAuthAccessToken,

&i.OAuthRefreshToken,

&i.OAuthExpiry,

&i.OAuthAccessTokenKeyID,

&i.OAuthRefreshTokenKeyID,

); 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 insertGitAuthLink = `-- name: InsertGitAuthLink :one

INSERT INTO git_auth_links (

provider_id,

user_id,

created_at,

updated_at,

oauth_access_token,

oauth_access_token_key_id,

oauth_refresh_token,

oauth_refresh_token_key_id,

oauth_expiry

) VALUES (

$1,

$2,

$3,

$4,

$5,

$6,

$7,

$8,

$9

) RETURNING provider_id, user_id, created_at, updated_at, oauth_access_token, oauth_refresh_token, oauth_expiry, oauth_access_token_key_id, oauth_refresh_token_key_id