You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
781 lines
20 KiB
781 lines
20 KiB
// Code generated by sqlc. DO NOT EDIT. |
|
// versions: |
|
// sqlc v1.19.1 |
|
// source: query.sql |
|
|
|
package db |
|
|
|
import ( |
|
"context" |
|
"database/sql" |
|
"time" |
|
) |
|
|
|
const addAccessTokenForUser = `-- name: AddAccessTokenForUser :exec |
|
INSERT INTO user_access_tokens(token, user_id) values($1, $2) |
|
` |
|
|
|
type AddAccessTokenForUserParams struct { |
|
Token string |
|
UserID string |
|
} |
|
|
|
func (q *Queries) AddAccessTokenForUser(ctx context.Context, arg AddAccessTokenForUserParams) error { |
|
_, err := q.db.ExecContext(ctx, addAccessTokenForUser, arg.Token, arg.UserID) |
|
return err |
|
} |
|
|
|
const addAuthForUser = `-- name: AddAuthForUser :exec |
|
INSERT INTO auth(user_id, token, type) values($1, $2, $3) |
|
` |
|
|
|
type AddAuthForUserParams struct { |
|
UserID string |
|
Token string |
|
Type string |
|
} |
|
|
|
func (q *Queries) AddAuthForUser(ctx context.Context, arg AddAuthForUserParams) error { |
|
_, err := q.db.ExecContext(ctx, addAuthForUser, arg.UserID, arg.Token, arg.Type) |
|
return err |
|
} |
|
|
|
const addFollower = `-- name: AddFollower :exec |
|
INSERT INTO ap_followers(iri, inbox, request, request_object, name, username, image, approved_at) values($1, $2, $3, $4, $5, $6, $7, $8) |
|
` |
|
|
|
type AddFollowerParams struct { |
|
Iri string |
|
Inbox string |
|
Request string |
|
RequestObject []byte |
|
Name sql.NullString |
|
Username string |
|
Image sql.NullString |
|
ApprovedAt sql.NullTime |
|
} |
|
|
|
func (q *Queries) AddFollower(ctx context.Context, arg AddFollowerParams) error { |
|
_, err := q.db.ExecContext(ctx, addFollower, |
|
arg.Iri, |
|
arg.Inbox, |
|
arg.Request, |
|
arg.RequestObject, |
|
arg.Name, |
|
arg.Username, |
|
arg.Image, |
|
arg.ApprovedAt, |
|
) |
|
return err |
|
} |
|
|
|
const addNotification = `-- name: AddNotification :exec |
|
INSERT INTO notifications (channel, destination) VALUES($1, $2) |
|
` |
|
|
|
type AddNotificationParams struct { |
|
Channel string |
|
Destination string |
|
} |
|
|
|
func (q *Queries) AddNotification(ctx context.Context, arg AddNotificationParams) error { |
|
_, err := q.db.ExecContext(ctx, addNotification, arg.Channel, arg.Destination) |
|
return err |
|
} |
|
|
|
const addToAcceptedActivities = `-- name: AddToAcceptedActivities :exec |
|
INSERT INTO ap_accepted_activities(iri, actor, type, timestamp) values($1, $2, $3, $4) |
|
` |
|
|
|
type AddToAcceptedActivitiesParams struct { |
|
Iri string |
|
Actor string |
|
Type string |
|
Timestamp time.Time |
|
} |
|
|
|
func (q *Queries) AddToAcceptedActivities(ctx context.Context, arg AddToAcceptedActivitiesParams) error { |
|
_, err := q.db.ExecContext(ctx, addToAcceptedActivities, |
|
arg.Iri, |
|
arg.Actor, |
|
arg.Type, |
|
arg.Timestamp, |
|
) |
|
return err |
|
} |
|
|
|
const addToOutbox = `-- name: AddToOutbox :exec |
|
INSERT INTO ap_outbox(iri, value, type, live_notification) values($1, $2, $3, $4) |
|
` |
|
|
|
type AddToOutboxParams struct { |
|
Iri string |
|
Value []byte |
|
Type string |
|
LiveNotification sql.NullBool |
|
} |
|
|
|
func (q *Queries) AddToOutbox(ctx context.Context, arg AddToOutboxParams) error { |
|
_, err := q.db.ExecContext(ctx, addToOutbox, |
|
arg.Iri, |
|
arg.Value, |
|
arg.Type, |
|
arg.LiveNotification, |
|
) |
|
return err |
|
} |
|
|
|
const approveFederationFollower = `-- name: ApproveFederationFollower :exec |
|
UPDATE ap_followers SET approved_at = $1, disabled_at = null WHERE iri = $2 |
|
` |
|
|
|
type ApproveFederationFollowerParams struct { |
|
ApprovedAt sql.NullTime |
|
Iri string |
|
} |
|
|
|
func (q *Queries) ApproveFederationFollower(ctx context.Context, arg ApproveFederationFollowerParams) error { |
|
_, err := q.db.ExecContext(ctx, approveFederationFollower, arg.ApprovedAt, arg.Iri) |
|
return err |
|
} |
|
|
|
const banIPAddress = `-- name: BanIPAddress :exec |
|
INSERT INTO ip_bans(ip_address, notes) values($1, $2) |
|
` |
|
|
|
type BanIPAddressParams struct { |
|
IpAddress string |
|
Notes sql.NullString |
|
} |
|
|
|
func (q *Queries) BanIPAddress(ctx context.Context, arg BanIPAddressParams) error { |
|
_, err := q.db.ExecContext(ctx, banIPAddress, arg.IpAddress, arg.Notes) |
|
return err |
|
} |
|
|
|
const changeDisplayColor = `-- name: ChangeDisplayColor :exec |
|
UPDATE users SET display_color = $1 WHERE id = $2 |
|
` |
|
|
|
type ChangeDisplayColorParams struct { |
|
DisplayColor int32 |
|
ID string |
|
} |
|
|
|
func (q *Queries) ChangeDisplayColor(ctx context.Context, arg ChangeDisplayColorParams) error { |
|
_, err := q.db.ExecContext(ctx, changeDisplayColor, arg.DisplayColor, arg.ID) |
|
return err |
|
} |
|
|
|
const changeDisplayName = `-- name: ChangeDisplayName :exec |
|
UPDATE users SET display_name = $1, previous_names = previous_names || $2, namechanged_at = $3 WHERE id = $4 |
|
` |
|
|
|
type ChangeDisplayNameParams struct { |
|
DisplayName string |
|
PreviousNames sql.NullString |
|
NamechangedAt sql.NullTime |
|
ID string |
|
} |
|
|
|
func (q *Queries) ChangeDisplayName(ctx context.Context, arg ChangeDisplayNameParams) error { |
|
_, err := q.db.ExecContext(ctx, changeDisplayName, |
|
arg.DisplayName, |
|
arg.PreviousNames, |
|
arg.NamechangedAt, |
|
arg.ID, |
|
) |
|
return err |
|
} |
|
|
|
const doesInboundActivityExist = `-- name: DoesInboundActivityExist :one |
|
SELECT count(*) FROM ap_accepted_activities WHERE iri = $1 AND actor = $2 AND TYPE = $3 |
|
` |
|
|
|
type DoesInboundActivityExistParams struct { |
|
Iri string |
|
Actor string |
|
Type string |
|
} |
|
|
|
func (q *Queries) DoesInboundActivityExist(ctx context.Context, arg DoesInboundActivityExistParams) (int64, error) { |
|
row := q.db.QueryRowContext(ctx, doesInboundActivityExist, arg.Iri, arg.Actor, arg.Type) |
|
var count int64 |
|
err := row.Scan(&count) |
|
return count, err |
|
} |
|
|
|
const getFederationFollowerApprovalRequests = `-- name: GetFederationFollowerApprovalRequests :many |
|
SELECT iri, inbox, name, username, image, created_at FROM ap_followers WHERE approved_at IS null AND disabled_at is null |
|
` |
|
|
|
type GetFederationFollowerApprovalRequestsRow struct { |
|
Iri string |
|
Inbox string |
|
Name sql.NullString |
|
Username string |
|
Image sql.NullString |
|
CreatedAt sql.NullTime |
|
} |
|
|
|
func (q *Queries) GetFederationFollowerApprovalRequests(ctx context.Context) ([]GetFederationFollowerApprovalRequestsRow, error) { |
|
rows, err := q.db.QueryContext(ctx, getFederationFollowerApprovalRequests) |
|
if err != nil { |
|
return nil, err |
|
} |
|
defer rows.Close() |
|
var items []GetFederationFollowerApprovalRequestsRow |
|
for rows.Next() { |
|
var i GetFederationFollowerApprovalRequestsRow |
|
if err := rows.Scan( |
|
&i.Iri, |
|
&i.Inbox, |
|
&i.Name, |
|
&i.Username, |
|
&i.Image, |
|
&i.CreatedAt, |
|
); 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 getFederationFollowersWithOffset = `-- name: GetFederationFollowersWithOffset :many |
|
SELECT iri, inbox, name, username, image, created_at FROM ap_followers WHERE approved_at is not null ORDER BY created_at DESC LIMIT $1 OFFSET $2 |
|
` |
|
|
|
type GetFederationFollowersWithOffsetParams struct { |
|
Limit int32 |
|
Offset int32 |
|
} |
|
|
|
type GetFederationFollowersWithOffsetRow struct { |
|
Iri string |
|
Inbox string |
|
Name sql.NullString |
|
Username string |
|
Image sql.NullString |
|
CreatedAt sql.NullTime |
|
} |
|
|
|
func (q *Queries) GetFederationFollowersWithOffset(ctx context.Context, arg GetFederationFollowersWithOffsetParams) ([]GetFederationFollowersWithOffsetRow, error) { |
|
rows, err := q.db.QueryContext(ctx, getFederationFollowersWithOffset, arg.Limit, arg.Offset) |
|
if err != nil { |
|
return nil, err |
|
} |
|
defer rows.Close() |
|
var items []GetFederationFollowersWithOffsetRow |
|
for rows.Next() { |
|
var i GetFederationFollowersWithOffsetRow |
|
if err := rows.Scan( |
|
&i.Iri, |
|
&i.Inbox, |
|
&i.Name, |
|
&i.Username, |
|
&i.Image, |
|
&i.CreatedAt, |
|
); 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 getFollowerByIRI = `-- name: GetFollowerByIRI :one |
|
SELECT iri, inbox, name, username, image, request, request_object, created_at, approved_at, disabled_at FROM ap_followers WHERE iri = $1 |
|
` |
|
|
|
func (q *Queries) GetFollowerByIRI(ctx context.Context, iri string) (ApFollower, error) { |
|
row := q.db.QueryRowContext(ctx, getFollowerByIRI, iri) |
|
var i ApFollower |
|
err := row.Scan( |
|
&i.Iri, |
|
&i.Inbox, |
|
&i.Name, |
|
&i.Username, |
|
&i.Image, |
|
&i.Request, |
|
&i.RequestObject, |
|
&i.CreatedAt, |
|
&i.ApprovedAt, |
|
&i.DisabledAt, |
|
) |
|
return i, err |
|
} |
|
|
|
const getFollowerCount = `-- name: GetFollowerCount :one |
|
|
|
|
|
SElECT count(*) FROM ap_followers WHERE approved_at is not null |
|
` |
|
|
|
// Queries added to query.sql must be compiled into Go code with sqlc. Read README.md for details. |
|
// Federation related queries. |
|
func (q *Queries) GetFollowerCount(ctx context.Context) (int64, error) { |
|
row := q.db.QueryRowContext(ctx, getFollowerCount) |
|
var count int64 |
|
err := row.Scan(&count) |
|
return count, err |
|
} |
|
|
|
const getIPAddressBans = `-- name: GetIPAddressBans :many |
|
SELECT ip_address, notes, created_at FROM ip_bans |
|
` |
|
|
|
func (q *Queries) GetIPAddressBans(ctx context.Context) ([]IpBan, error) { |
|
rows, err := q.db.QueryContext(ctx, getIPAddressBans) |
|
if err != nil { |
|
return nil, err |
|
} |
|
defer rows.Close() |
|
var items []IpBan |
|
for rows.Next() { |
|
var i IpBan |
|
if err := rows.Scan(&i.IpAddress, &i.Notes, &i.CreatedAt); 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 getInboundActivitiesWithOffset = `-- name: GetInboundActivitiesWithOffset :many |
|
SELECT iri, actor, type, timestamp FROM ap_accepted_activities ORDER BY timestamp DESC LIMIT $1 OFFSET $2 |
|
` |
|
|
|
type GetInboundActivitiesWithOffsetParams struct { |
|
Limit int32 |
|
Offset int32 |
|
} |
|
|
|
type GetInboundActivitiesWithOffsetRow struct { |
|
Iri string |
|
Actor string |
|
Type string |
|
Timestamp time.Time |
|
} |
|
|
|
func (q *Queries) GetInboundActivitiesWithOffset(ctx context.Context, arg GetInboundActivitiesWithOffsetParams) ([]GetInboundActivitiesWithOffsetRow, error) { |
|
rows, err := q.db.QueryContext(ctx, getInboundActivitiesWithOffset, arg.Limit, arg.Offset) |
|
if err != nil { |
|
return nil, err |
|
} |
|
defer rows.Close() |
|
var items []GetInboundActivitiesWithOffsetRow |
|
for rows.Next() { |
|
var i GetInboundActivitiesWithOffsetRow |
|
if err := rows.Scan( |
|
&i.Iri, |
|
&i.Actor, |
|
&i.Type, |
|
&i.Timestamp, |
|
); 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 getInboundActivityCount = `-- name: GetInboundActivityCount :one |
|
SELECT count(*) FROM ap_accepted_activities |
|
` |
|
|
|
func (q *Queries) GetInboundActivityCount(ctx context.Context) (int64, error) { |
|
row := q.db.QueryRowContext(ctx, getInboundActivityCount) |
|
var count int64 |
|
err := row.Scan(&count) |
|
return count, err |
|
} |
|
|
|
const getLocalPostCount = `-- name: GetLocalPostCount :one |
|
SElECT count(*) FROM ap_outbox |
|
` |
|
|
|
func (q *Queries) GetLocalPostCount(ctx context.Context) (int64, error) { |
|
row := q.db.QueryRowContext(ctx, getLocalPostCount) |
|
var count int64 |
|
err := row.Scan(&count) |
|
return count, err |
|
} |
|
|
|
const getMessagesFromUser = `-- name: GetMessagesFromUser :many |
|
SELECT id, body, hidden_at, timestamp FROM messages WHERE eventType = 'CHAT' AND user_id = $1 ORDER BY TIMESTAMP DESC |
|
` |
|
|
|
type GetMessagesFromUserRow struct { |
|
ID string |
|
Body sql.NullString |
|
HiddenAt sql.NullTime |
|
Timestamp sql.NullTime |
|
} |
|
|
|
func (q *Queries) GetMessagesFromUser(ctx context.Context, userID sql.NullString) ([]GetMessagesFromUserRow, error) { |
|
rows, err := q.db.QueryContext(ctx, getMessagesFromUser, userID) |
|
if err != nil { |
|
return nil, err |
|
} |
|
defer rows.Close() |
|
var items []GetMessagesFromUserRow |
|
for rows.Next() { |
|
var i GetMessagesFromUserRow |
|
if err := rows.Scan( |
|
&i.ID, |
|
&i.Body, |
|
&i.HiddenAt, |
|
&i.Timestamp, |
|
); 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 getNotificationDestinationsForChannel = `-- name: GetNotificationDestinationsForChannel :many |
|
SELECT destination FROM notifications WHERE channel = $1 |
|
` |
|
|
|
func (q *Queries) GetNotificationDestinationsForChannel(ctx context.Context, channel string) ([]string, error) { |
|
rows, err := q.db.QueryContext(ctx, getNotificationDestinationsForChannel, channel) |
|
if err != nil { |
|
return nil, err |
|
} |
|
defer rows.Close() |
|
var items []string |
|
for rows.Next() { |
|
var destination string |
|
if err := rows.Scan(&destination); err != nil { |
|
return nil, err |
|
} |
|
items = append(items, destination) |
|
} |
|
if err := rows.Close(); err != nil { |
|
return nil, err |
|
} |
|
if err := rows.Err(); err != nil { |
|
return nil, err |
|
} |
|
return items, nil |
|
} |
|
|
|
const getObjectFromOutboxByIRI = `-- name: GetObjectFromOutboxByIRI :one |
|
SELECT value, live_notification, created_at FROM ap_outbox WHERE iri = $1 |
|
` |
|
|
|
type GetObjectFromOutboxByIRIRow struct { |
|
Value []byte |
|
LiveNotification sql.NullBool |
|
CreatedAt sql.NullTime |
|
} |
|
|
|
func (q *Queries) GetObjectFromOutboxByIRI(ctx context.Context, iri string) (GetObjectFromOutboxByIRIRow, error) { |
|
row := q.db.QueryRowContext(ctx, getObjectFromOutboxByIRI, iri) |
|
var i GetObjectFromOutboxByIRIRow |
|
err := row.Scan(&i.Value, &i.LiveNotification, &i.CreatedAt) |
|
return i, err |
|
} |
|
|
|
const getOutboxWithOffset = `-- name: GetOutboxWithOffset :many |
|
SELECT value FROM ap_outbox LIMIT $1 OFFSET $2 |
|
` |
|
|
|
type GetOutboxWithOffsetParams struct { |
|
Limit int32 |
|
Offset int32 |
|
} |
|
|
|
func (q *Queries) GetOutboxWithOffset(ctx context.Context, arg GetOutboxWithOffsetParams) ([][]byte, error) { |
|
rows, err := q.db.QueryContext(ctx, getOutboxWithOffset, arg.Limit, arg.Offset) |
|
if err != nil { |
|
return nil, err |
|
} |
|
defer rows.Close() |
|
var items [][]byte |
|
for rows.Next() { |
|
var value []byte |
|
if err := rows.Scan(&value); err != nil { |
|
return nil, err |
|
} |
|
items = append(items, value) |
|
} |
|
if err := rows.Close(); err != nil { |
|
return nil, err |
|
} |
|
if err := rows.Err(); err != nil { |
|
return nil, err |
|
} |
|
return items, nil |
|
} |
|
|
|
const getRejectedAndBlockedFollowers = `-- name: GetRejectedAndBlockedFollowers :many |
|
SELECT iri, name, username, image, created_at, disabled_at FROM ap_followers WHERE disabled_at is not null |
|
` |
|
|
|
type GetRejectedAndBlockedFollowersRow struct { |
|
Iri string |
|
Name sql.NullString |
|
Username string |
|
Image sql.NullString |
|
CreatedAt sql.NullTime |
|
DisabledAt sql.NullTime |
|
} |
|
|
|
func (q *Queries) GetRejectedAndBlockedFollowers(ctx context.Context) ([]GetRejectedAndBlockedFollowersRow, error) { |
|
rows, err := q.db.QueryContext(ctx, getRejectedAndBlockedFollowers) |
|
if err != nil { |
|
return nil, err |
|
} |
|
defer rows.Close() |
|
var items []GetRejectedAndBlockedFollowersRow |
|
for rows.Next() { |
|
var i GetRejectedAndBlockedFollowersRow |
|
if err := rows.Scan( |
|
&i.Iri, |
|
&i.Name, |
|
&i.Username, |
|
&i.Image, |
|
&i.CreatedAt, |
|
&i.DisabledAt, |
|
); 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 getUserByAccessToken = `-- name: GetUserByAccessToken :one |
|
SELECT users.id, display_name, display_color, users.created_at, disabled_at, previous_names, namechanged_at, authenticated_at, scopes FROM users, user_access_tokens WHERE token = $1 AND users.id = user_id |
|
` |
|
|
|
type GetUserByAccessTokenRow struct { |
|
ID string |
|
DisplayName string |
|
DisplayColor int32 |
|
CreatedAt sql.NullTime |
|
DisabledAt sql.NullTime |
|
PreviousNames sql.NullString |
|
NamechangedAt sql.NullTime |
|
AuthenticatedAt sql.NullTime |
|
Scopes sql.NullString |
|
} |
|
|
|
func (q *Queries) GetUserByAccessToken(ctx context.Context, token string) (GetUserByAccessTokenRow, error) { |
|
row := q.db.QueryRowContext(ctx, getUserByAccessToken, token) |
|
var i GetUserByAccessTokenRow |
|
err := row.Scan( |
|
&i.ID, |
|
&i.DisplayName, |
|
&i.DisplayColor, |
|
&i.CreatedAt, |
|
&i.DisabledAt, |
|
&i.PreviousNames, |
|
&i.NamechangedAt, |
|
&i.AuthenticatedAt, |
|
&i.Scopes, |
|
) |
|
return i, err |
|
} |
|
|
|
const getUserByAuth = `-- name: GetUserByAuth :one |
|
SELECT users.id, display_name, display_color, users.created_at, disabled_at, previous_names, namechanged_at, authenticated_at, scopes FROM auth, users WHERE token = $1 AND auth.type = $2 AND users.id = auth.user_id |
|
` |
|
|
|
type GetUserByAuthParams struct { |
|
Token string |
|
Type string |
|
} |
|
|
|
type GetUserByAuthRow struct { |
|
ID string |
|
DisplayName string |
|
DisplayColor int32 |
|
CreatedAt sql.NullTime |
|
DisabledAt sql.NullTime |
|
PreviousNames sql.NullString |
|
NamechangedAt sql.NullTime |
|
AuthenticatedAt sql.NullTime |
|
Scopes sql.NullString |
|
} |
|
|
|
func (q *Queries) GetUserByAuth(ctx context.Context, arg GetUserByAuthParams) (GetUserByAuthRow, error) { |
|
row := q.db.QueryRowContext(ctx, getUserByAuth, arg.Token, arg.Type) |
|
var i GetUserByAuthRow |
|
err := row.Scan( |
|
&i.ID, |
|
&i.DisplayName, |
|
&i.DisplayColor, |
|
&i.CreatedAt, |
|
&i.DisabledAt, |
|
&i.PreviousNames, |
|
&i.NamechangedAt, |
|
&i.AuthenticatedAt, |
|
&i.Scopes, |
|
) |
|
return i, err |
|
} |
|
|
|
const getUserDisplayNameByToken = `-- name: GetUserDisplayNameByToken :one |
|
SELECT display_name FROM users, user_access_tokens WHERE token = $1 AND users.id = user_id AND disabled_at = NULL |
|
` |
|
|
|
func (q *Queries) GetUserDisplayNameByToken(ctx context.Context, token string) (string, error) { |
|
row := q.db.QueryRowContext(ctx, getUserDisplayNameByToken, token) |
|
var display_name string |
|
err := row.Scan(&display_name) |
|
return display_name, err |
|
} |
|
|
|
const isDisplayNameAvailable = `-- name: IsDisplayNameAvailable :one |
|
SELECT count(*) FROM users WHERE display_name = $1 AND ( type='API' OR authenticated_at IS NOT NULL ) AND disabled_at IS NULL |
|
` |
|
|
|
func (q *Queries) IsDisplayNameAvailable(ctx context.Context, displayName string) (int64, error) { |
|
row := q.db.QueryRowContext(ctx, isDisplayNameAvailable, displayName) |
|
var count int64 |
|
err := row.Scan(&count) |
|
return count, err |
|
} |
|
|
|
const isIPAddressBlocked = `-- name: IsIPAddressBlocked :one |
|
SELECT count(*) FROM ip_bans WHERE ip_address = $1 |
|
` |
|
|
|
func (q *Queries) IsIPAddressBlocked(ctx context.Context, ipAddress string) (int64, error) { |
|
row := q.db.QueryRowContext(ctx, isIPAddressBlocked, ipAddress) |
|
var count int64 |
|
err := row.Scan(&count) |
|
return count, err |
|
} |
|
|
|
const rejectFederationFollower = `-- name: RejectFederationFollower :exec |
|
UPDATE ap_followers SET approved_at = null, disabled_at = $1 WHERE iri = $2 |
|
` |
|
|
|
type RejectFederationFollowerParams struct { |
|
DisabledAt sql.NullTime |
|
Iri string |
|
} |
|
|
|
func (q *Queries) RejectFederationFollower(ctx context.Context, arg RejectFederationFollowerParams) error { |
|
_, err := q.db.ExecContext(ctx, rejectFederationFollower, arg.DisabledAt, arg.Iri) |
|
return err |
|
} |
|
|
|
const removeFollowerByIRI = `-- name: RemoveFollowerByIRI :exec |
|
DELETE FROM ap_followers WHERE iri = $1 |
|
` |
|
|
|
func (q *Queries) RemoveFollowerByIRI(ctx context.Context, iri string) error { |
|
_, err := q.db.ExecContext(ctx, removeFollowerByIRI, iri) |
|
return err |
|
} |
|
|
|
const removeIPAddressBan = `-- name: RemoveIPAddressBan :exec |
|
DELETE FROM ip_bans WHERE ip_address = $1 |
|
` |
|
|
|
func (q *Queries) RemoveIPAddressBan(ctx context.Context, ipAddress string) error { |
|
_, err := q.db.ExecContext(ctx, removeIPAddressBan, ipAddress) |
|
return err |
|
} |
|
|
|
const removeNotificationDestinationForChannel = `-- name: RemoveNotificationDestinationForChannel :exec |
|
DELETE FROM notifications WHERE channel = $1 AND destination = $2 |
|
` |
|
|
|
type RemoveNotificationDestinationForChannelParams struct { |
|
Channel string |
|
Destination string |
|
} |
|
|
|
func (q *Queries) RemoveNotificationDestinationForChannel(ctx context.Context, arg RemoveNotificationDestinationForChannelParams) error { |
|
_, err := q.db.ExecContext(ctx, removeNotificationDestinationForChannel, arg.Channel, arg.Destination) |
|
return err |
|
} |
|
|
|
const setAccessTokenToOwner = `-- name: SetAccessTokenToOwner :exec |
|
UPDATE user_access_tokens SET user_id = $1 WHERE token = $2 |
|
` |
|
|
|
type SetAccessTokenToOwnerParams struct { |
|
UserID string |
|
Token string |
|
} |
|
|
|
func (q *Queries) SetAccessTokenToOwner(ctx context.Context, arg SetAccessTokenToOwnerParams) error { |
|
_, err := q.db.ExecContext(ctx, setAccessTokenToOwner, arg.UserID, arg.Token) |
|
return err |
|
} |
|
|
|
const setUserAsAuthenticated = `-- name: SetUserAsAuthenticated :exec |
|
UPDATE users SET authenticated_at = CURRENT_TIMESTAMP WHERE id = $1 |
|
` |
|
|
|
func (q *Queries) SetUserAsAuthenticated(ctx context.Context, id string) error { |
|
_, err := q.db.ExecContext(ctx, setUserAsAuthenticated, id) |
|
return err |
|
} |
|
|
|
const updateFollowerByIRI = `-- name: UpdateFollowerByIRI :exec |
|
UPDATE ap_followers SET inbox = $1, name = $2, username = $3, image = $4 WHERE iri = $5 |
|
` |
|
|
|
type UpdateFollowerByIRIParams struct { |
|
Inbox string |
|
Name sql.NullString |
|
Username string |
|
Image sql.NullString |
|
Iri string |
|
} |
|
|
|
func (q *Queries) UpdateFollowerByIRI(ctx context.Context, arg UpdateFollowerByIRIParams) error { |
|
_, err := q.db.ExecContext(ctx, updateFollowerByIRI, |
|
arg.Inbox, |
|
arg.Name, |
|
arg.Username, |
|
arg.Image, |
|
arg.Iri, |
|
) |
|
return err |
|
}
|
|
|