// Code generated by sqlc. DO NOT EDIT.

// versions:

// sqlc v1.13.0

package database

import (

"context"

"database/sql"

"encoding/json"

"time"

"github.com/google/uuid"

"github.com/lib/pq"

"github.com/tabbed/pqtype"

)

const deleteOldAgentStats = `-- name: DeleteOldAgentStats :exec

DELETE FROM AGENT_STATS WHERE created_at < now() - interval '30 days'

`

func (q *sqlQuerier) DeleteOldAgentStats(ctx context.Context) error {

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

return err

}

const getLatestAgentStat = `-- name: GetLatestAgentStat :one

SELECT id, created_at, user_id, agent_id, workspace_id, template_id, payload FROM agent_stats WHERE agent_id = $1 ORDER BY created_at DESC LIMIT 1

`

func (q *sqlQuerier) GetLatestAgentStat(ctx context.Context, agentID uuid.UUID) (AgentStat, error) {

row := q.db.QueryRowContext(ctx, getLatestAgentStat, agentID)

var i AgentStat

err := row.Scan(

&i.ID,

&i.CreatedAt,

&i.UserID,

&i.AgentID,

&i.WorkspaceID,

&i.TemplateID,

&i.Payload,

)

return i, err

}

const getTemplateDAUs = `-- name: GetTemplateDAUs :many

select

(created_at at TIME ZONE 'UTC')::date as date,

user_id

from

agent_stats

where template_id = $1

group by

date, user_id

order by

date asc

`

type GetTemplateDAUsRow struct {

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

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

}

func (q *sqlQuerier) GetTemplateDAUs(ctx context.Context, templateID uuid.UUID) ([]GetTemplateDAUsRow, error) {

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

if err != nil {

return nil, err

}

defer rows.Close()

var items []GetTemplateDAUsRow

for rows.Next() {

var i GetTemplateDAUsRow

if err := rows.Scan(&i.Date, &i.UserID); 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 insertAgentStat = `-- name: InsertAgentStat :one

INSERT INTO

agent_stats (

id,

created_at,

user_id,

workspace_id,

template_id,

agent_id,

payload

)

VALUES

($1, $2, $3, $4, $5, $6, $7) RETURNING id, created_at, user_id, agent_id, workspace_id, template_id, payload

`

type InsertAgentStatParams struct {

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

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

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

WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"`

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

AgentID uuid.UUID `db:"agent_id" json:"agent_id"`

Payload json.RawMessage `db:"payload" json:"payload"`

}

func (q *sqlQuerier) InsertAgentStat(ctx context.Context, arg InsertAgentStatParams) (AgentStat, error) {

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

arg.ID,

arg.CreatedAt,

arg.UserID,

arg.WorkspaceID,

arg.TemplateID,

arg.AgentID,

arg.Payload,

)

var i AgentStat

err := row.Scan(

&i.ID,

&i.CreatedAt,

&i.UserID,

&i.AgentID,

&i.WorkspaceID,

&i.TemplateID,

&i.Payload,

)

return i, 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 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

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,

)

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 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,

); 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 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,

); 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

)

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) RETURNING id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope

`

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"`

}

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,

)

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,

)

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 getAuditLogCount = `-- name: GetAuditLogCount :one

SELECT

COUNT(*) as count

FROM

audit_logs

WHERE

-- Filter resource_type

CASE

WHEN $1 :: text != '' THEN

resource_type = $1 :: resource_type

ELSE true

END

-- Filter resource_id

AND CASE

WHEN $2 :: uuid != '00000000-00000000-00000000-00000000' THEN

resource_id = $2

ELSE true

END

-- Filter by resource_target

AND CASE

WHEN $3 :: text != '' THEN

resource_target = $3

ELSE true

END

-- Filter action

AND CASE

WHEN $4 :: text != '' THEN

action = $4 :: audit_action

ELSE true

END

-- Filter by username

AND CASE

WHEN $5 :: text != '' THEN

user_id = (SELECT id from users WHERE users.username = $5 )

ELSE true

END

-- Filter by user_email

AND CASE

WHEN $6 :: text != '' THEN

user_id = (SELECT id from users WHERE users.email = $6 )

ELSE true

END

`

type GetAuditLogCountParams struct {

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"`

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

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

}

func (q *sqlQuerier) GetAuditLogCount(ctx context.Context, arg GetAuditLogCountParams) (int64, error) {

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

arg.ResourceType,

arg.ResourceID,

arg.ResourceTarget,

arg.Action,

arg.Username,

arg.Email,

)

var count int64

err := row.Scan(&count)

return count, 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

FROM

audit_logs

LEFT JOIN

users ON audit_logs.user_id = users.id

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-00000000-00000000-00000000' 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 username

AND CASE

WHEN $7 :: text != '' THEN

users.username = $7

ELSE true

END

-- Filter by user_email

AND CASE

WHEN $8 :: text != '' THEN

users.email = $8

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"`

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

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

}

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 string `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 UserStatus `db:"user_status" json:"user_status"`

UserRoles []string `db:"user_roles" json:"user_roles"`

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

}

// 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.Username,

arg.Email,

)

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,

pq.Array(&i.UserRoles),

&i.UserAvatarUrl,

); 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 string `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 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 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 deleteGitSSHKey = `-- name: DeleteGitSSHKey :exec

DELETE FROM

gitsshkeys

WHERE

user_id = $1

`

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

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

return err

}

const getGitSSHKey = `-- name: GetGitSSHKey :one

SELECT

user_id, created_at, updated_at, private_key, public_key

FROM

gitsshkeys

WHERE

user_id = $1

`

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

row := q.db.QueryRowContext(ctx, getGitSSHKey, userID)

var i GitSSHKey

err := row.Scan(

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.PrivateKey,

&i.PublicKey,

)

return i, err

}

const insertGitSSHKey = `-- name: InsertGitSSHKey :one

INSERT INTO

gitsshkeys (

user_id,

created_at,

updated_at,

private_key,

public_key

)

VALUES

($1, $2, $3, $4, $5) RETURNING user_id, created_at, updated_at, private_key, public_key

`

type InsertGitSSHKeyParams struct {

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

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

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

PrivateKey string `db:"private_key" json:"private_key"`

PublicKey string `db:"public_key" json:"public_key"`

}

func (q *sqlQuerier) InsertGitSSHKey(ctx context.Context, arg InsertGitSSHKeyParams) (GitSSHKey, error) {

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

arg.UserID,

arg.CreatedAt,

arg.UpdatedAt,

arg.PrivateKey,

arg.PublicKey,

)

var i GitSSHKey

err := row.Scan(

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.PrivateKey,

&i.PublicKey,

)

return i, err

}

const updateGitSSHKey = `-- name: UpdateGitSSHKey :one

UPDATE

gitsshkeys

SET

updated_at = $2,

private_key = $3,

public_key = $4

WHERE

user_id = $1

RETURNING

user_id, created_at, updated_at, private_key, public_key

`

type UpdateGitSSHKeyParams struct {

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

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

PrivateKey string `db:"private_key" json:"private_key"`

PublicKey string `db:"public_key" json:"public_key"`

}

func (q *sqlQuerier) UpdateGitSSHKey(ctx context.Context, arg UpdateGitSSHKeyParams) (GitSSHKey, error) {

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

arg.UserID,

arg.UpdatedAt,

arg.PrivateKey,

arg.PublicKey,

)

var i GitSSHKey

err := row.Scan(

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.PrivateKey,

&i.PublicKey,

)

return i, err

}

const deleteGroupByID = `-- name: DeleteGroupByID :exec

DELETE FROM

groups

WHERE

id = $1

`

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

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

return err

}

const deleteGroupMember = `-- name: DeleteGroupMember :exec

DELETE FROM

group_members

WHERE

user_id = $1

`

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

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

return err

}

const getAllOrganizationMembers = `-- name: GetAllOrganizationMembers :many

SELECT

users.id, users.email, users.username, users.hashed_password, users.created_at, users.updated_at, users.status, users.rbac_roles, users.login_type, users.avatar_url, users.deleted, users.last_seen_at

FROM

users

JOIN

organization_members

ON

users.id = organization_members.user_id

WHERE

organization_members.organization_id = $1

`

func (q *sqlQuerier) GetAllOrganizationMembers(ctx context.Context, organizationID uuid.UUID) ([]User, error) {

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

if err != nil {

return nil, err

}

defer rows.Close()

var items []User

for rows.Next() {

var i User

if err := rows.Scan(

&i.ID,

&i.Email,

&i.Username,

&i.HashedPassword,

&i.CreatedAt,

&i.UpdatedAt,

&i.Status,

&i.RBACRoles,

&i.LoginType,

&i.AvatarURL,

&i.Deleted,

&i.LastSeenAt,

); 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 getGroupByID = `-- name: GetGroupByID :one

SELECT

id, name, organization_id, avatar_url

FROM

groups

WHERE

id = $1

LIMIT

1

`

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

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

var i Group

err := row.Scan(

&i.ID,

&i.Name,

&i.OrganizationID,

&i.AvatarURL,

)

return i, err

}

const getGroupByOrgAndName = `-- name: GetGroupByOrgAndName :one

SELECT

id, name, organization_id, avatar_url

FROM

groups

WHERE

organization_id = $1

AND

name = $2

LIMIT

1

`

type GetGroupByOrgAndNameParams struct {

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

Name string `db:"name" json:"name"`

}

func (q *sqlQuerier) GetGroupByOrgAndName(ctx context.Context, arg GetGroupByOrgAndNameParams) (Group, error) {

row := q.db.QueryRowContext(ctx, getGroupByOrgAndName, arg.OrganizationID, arg.Name)

var i Group

err := row.Scan(

&i.ID,

&i.Name,

&i.OrganizationID,

&i.AvatarURL,

)

return i, err

}

const getGroupMembers = `-- name: GetGroupMembers :many

SELECT

users.id, users.email, users.username, users.hashed_password, users.created_at, users.updated_at, users.status, users.rbac_roles, users.login_type, users.avatar_url, users.deleted, users.last_seen_at

FROM

users

JOIN

group_members