mirror of
https://github.com/Kyren223/eko.git
synced 2026-03-10 18:05:36 +00:00
330 lines
7.9 KiB
Go
330 lines
7.9 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.27.0
|
|
// source: users_networks.sql
|
|
|
|
package data
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
"github.com/kyren223/eko/pkg/snowflake"
|
|
)
|
|
|
|
const filterUsersInNetwork = `-- name: FilterUsersInNetwork :many
|
|
SELECT user_id FROM users_networks
|
|
WHERE network_id = ? AND user_id IN (/*SLICE:users*/?)
|
|
`
|
|
|
|
type FilterUsersInNetworkParams struct {
|
|
NetworkID snowflake.ID
|
|
Users []snowflake.ID
|
|
}
|
|
|
|
func (q *Queries) FilterUsersInNetwork(ctx context.Context, arg FilterUsersInNetworkParams) ([]snowflake.ID, error) {
|
|
query := filterUsersInNetwork
|
|
var queryParams []interface{}
|
|
queryParams = append(queryParams, arg.NetworkID)
|
|
if len(arg.Users) > 0 {
|
|
for _, v := range arg.Users {
|
|
queryParams = append(queryParams, v)
|
|
}
|
|
query = strings.Replace(query, "/*SLICE:users*/?", strings.Repeat(",?", len(arg.Users))[1:], 1)
|
|
} else {
|
|
query = strings.Replace(query, "/*SLICE:users*/?", "NULL", 1)
|
|
}
|
|
rows, err := q.db.QueryContext(ctx, query, queryParams...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []snowflake.ID
|
|
for rows.Next() {
|
|
var user_id snowflake.ID
|
|
if err := rows.Scan(&user_id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, user_id)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getNetworkBannedUsers = `-- name: GetNetworkBannedUsers :many
|
|
SELECT
|
|
users.id, users.name, users.public_key, users.description, users.is_public_dm, users.is_deleted,
|
|
users_networks.ban_reason
|
|
FROM users_networks
|
|
JOIN users ON users.id = users_networks.user_id
|
|
WHERE users_networks.network_id = ?
|
|
`
|
|
|
|
type GetNetworkBannedUsersRow struct {
|
|
User User
|
|
BanReason *string
|
|
}
|
|
|
|
func (q *Queries) GetNetworkBannedUsers(ctx context.Context, networkID snowflake.ID) ([]GetNetworkBannedUsersRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getNetworkBannedUsers, networkID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetNetworkBannedUsersRow
|
|
for rows.Next() {
|
|
var i GetNetworkBannedUsersRow
|
|
if err := rows.Scan(
|
|
&i.User.ID,
|
|
&i.User.Name,
|
|
&i.User.PublicKey,
|
|
&i.User.Description,
|
|
&i.User.IsPublicDM,
|
|
&i.User.IsDeleted,
|
|
&i.BanReason,
|
|
); 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 getNetworkMemberById = `-- name: GetNetworkMemberById :one
|
|
SELECT user_id, network_id, joined_at, is_member, is_admin, is_muted, is_banned, ban_reason, position
|
|
FROM users_networks
|
|
WHERE users_networks.network_id = ? AND users_networks.user_id = ?
|
|
`
|
|
|
|
type GetNetworkMemberByIdParams struct {
|
|
NetworkID snowflake.ID
|
|
UserID snowflake.ID
|
|
}
|
|
|
|
func (q *Queries) GetNetworkMemberById(ctx context.Context, arg GetNetworkMemberByIdParams) (UserNetwork, error) {
|
|
row := q.db.QueryRowContext(ctx, getNetworkMemberById, arg.NetworkID, arg.UserID)
|
|
var i UserNetwork
|
|
err := row.Scan(
|
|
&i.UserID,
|
|
&i.NetworkID,
|
|
&i.JoinedAt,
|
|
&i.IsMember,
|
|
&i.IsAdmin,
|
|
&i.IsMuted,
|
|
&i.IsBanned,
|
|
&i.BanReason,
|
|
&i.Position,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getNetworkMembers = `-- name: GetNetworkMembers :many
|
|
SELECT
|
|
users.id, users.name, users.public_key, users.description, users.is_public_dm, users.is_deleted,
|
|
users_networks.joined_at,
|
|
users_networks.is_admin,
|
|
users_networks.is_muted
|
|
FROM users_networks
|
|
JOIN users ON users.id = users_networks.user_id
|
|
WHERE users_networks.network_id = ? AND is_member = true
|
|
`
|
|
|
|
type GetNetworkMembersRow struct {
|
|
User User
|
|
JoinedAt string
|
|
IsAdmin bool
|
|
IsMuted bool
|
|
}
|
|
|
|
func (q *Queries) GetNetworkMembers(ctx context.Context, networkID snowflake.ID) ([]GetNetworkMembersRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getNetworkMembers, networkID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetNetworkMembersRow
|
|
for rows.Next() {
|
|
var i GetNetworkMembersRow
|
|
if err := rows.Scan(
|
|
&i.User.ID,
|
|
&i.User.Name,
|
|
&i.User.PublicKey,
|
|
&i.User.Description,
|
|
&i.User.IsPublicDM,
|
|
&i.User.IsDeleted,
|
|
&i.JoinedAt,
|
|
&i.IsAdmin,
|
|
&i.IsMuted,
|
|
); 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 getUserNetwork = `-- name: GetUserNetwork :one
|
|
SELECT user_id, network_id, joined_at, is_member, is_admin, is_muted, is_banned, ban_reason, position FROM users_networks
|
|
WHERE user_id = ? AND network_id = ?
|
|
`
|
|
|
|
type GetUserNetworkParams struct {
|
|
UserID snowflake.ID
|
|
NetworkID snowflake.ID
|
|
}
|
|
|
|
func (q *Queries) GetUserNetwork(ctx context.Context, arg GetUserNetworkParams) (UserNetwork, error) {
|
|
row := q.db.QueryRowContext(ctx, getUserNetwork, arg.UserID, arg.NetworkID)
|
|
var i UserNetwork
|
|
err := row.Scan(
|
|
&i.UserID,
|
|
&i.NetworkID,
|
|
&i.JoinedAt,
|
|
&i.IsMember,
|
|
&i.IsAdmin,
|
|
&i.IsMuted,
|
|
&i.IsBanned,
|
|
&i.BanReason,
|
|
&i.Position,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUserNetworks = `-- name: GetUserNetworks :many
|
|
SELECT networks.id, networks.owner_id, networks.name, networks.icon, networks.bg_hex_color, networks.fg_hex_color, networks.is_public, users_networks.position FROM networks
|
|
JOIN users_networks ON networks.id = users_networks.network_id
|
|
WHERE users_networks.user_id = ?
|
|
ORDER BY users_networks.position
|
|
`
|
|
|
|
type GetUserNetworksRow struct {
|
|
Network Network
|
|
Position *int64
|
|
}
|
|
|
|
func (q *Queries) GetUserNetworks(ctx context.Context, userID snowflake.ID) ([]GetUserNetworksRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getUserNetworks, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetUserNetworksRow
|
|
for rows.Next() {
|
|
var i GetUserNetworksRow
|
|
if err := rows.Scan(
|
|
&i.Network.ID,
|
|
&i.Network.OwnerID,
|
|
&i.Network.Name,
|
|
&i.Network.Icon,
|
|
&i.Network.BgHexColor,
|
|
&i.Network.FgHexColor,
|
|
&i.Network.IsPublic,
|
|
&i.Position,
|
|
); 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 setMember = `-- name: SetMember :one
|
|
INSERT INTO users_networks (
|
|
user_id, network_id,
|
|
is_member, is_admin, is_muted,
|
|
is_banned, ban_reason, position
|
|
) VALUES (
|
|
?1, ?2,
|
|
?3, ?4, ?5,
|
|
?6, ?7,
|
|
CASE
|
|
WHEN ?3 = false THEN NULL
|
|
ELSE (SELECT COUNT(*) FROM users_networks WHERE user_id = ?1)
|
|
END
|
|
)
|
|
ON CONFLICT DO
|
|
UPDATE SET
|
|
is_member = EXCLUDED.is_member, is_admin = EXCLUDED.is_admin, is_muted = EXCLUDED.is_muted,
|
|
is_banned = EXCLUDED.is_banned, ban_reason = EXCLUDED.ban_reason, position = EXCLUDED.position
|
|
WHERE user_id = EXCLUDED.user_id AND network_id = EXCLUDED.network_id
|
|
RETURNING user_id, network_id, joined_at, is_member, is_admin, is_muted, is_banned, ban_reason, position
|
|
`
|
|
|
|
type SetMemberParams struct {
|
|
UserID snowflake.ID
|
|
NetworkID snowflake.ID
|
|
IsMember bool
|
|
IsAdmin bool
|
|
IsMuted bool
|
|
IsBanned bool
|
|
BanReason *string
|
|
}
|
|
|
|
func (q *Queries) SetMember(ctx context.Context, arg SetMemberParams) (UserNetwork, error) {
|
|
row := q.db.QueryRowContext(ctx, setMember,
|
|
arg.UserID,
|
|
arg.NetworkID,
|
|
arg.IsMember,
|
|
arg.IsAdmin,
|
|
arg.IsMuted,
|
|
arg.IsBanned,
|
|
arg.BanReason,
|
|
)
|
|
var i UserNetwork
|
|
err := row.Scan(
|
|
&i.UserID,
|
|
&i.NetworkID,
|
|
&i.JoinedAt,
|
|
&i.IsMember,
|
|
&i.IsAdmin,
|
|
&i.IsMuted,
|
|
&i.IsBanned,
|
|
&i.BanReason,
|
|
&i.Position,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const swapUserNetworks = `-- name: SwapUserNetworks :exec
|
|
UPDATE users_networks SET
|
|
position = CASE
|
|
WHEN position = ?1 THEN ?2
|
|
WHEN position = ?2 THEN ?1
|
|
END
|
|
WHERE user_id = ?3 AND position IN (?1, ?2)
|
|
`
|
|
|
|
type SwapUserNetworksParams struct {
|
|
Pos1 *int64
|
|
Pos2 *int64
|
|
UserID snowflake.ID
|
|
}
|
|
|
|
func (q *Queries) SwapUserNetworks(ctx context.Context, arg SwapUserNetworksParams) error {
|
|
_, err := q.db.ExecContext(ctx, swapUserNetworks, arg.Pos1, arg.Pos2, arg.UserID)
|
|
return err
|
|
}
|