529 lines
12 KiB
Go
529 lines
12 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.29.0
|
|
// source: query.sql
|
|
|
|
package nimdb
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const addCommentHeart = `-- name: AddCommentHeart :one
|
|
UPDATE comment SET heart = heart + 1 WHERE id=$1 RETURNING heart
|
|
`
|
|
|
|
func (q *Queries) AddCommentHeart(ctx context.Context, id int32) (int32, error) {
|
|
row := q.db.QueryRow(ctx, addCommentHeart, id)
|
|
var heart int32
|
|
err := row.Scan(&heart)
|
|
return heart, err
|
|
}
|
|
|
|
const addPostHeart = `-- name: AddPostHeart :one
|
|
UPDATE posts SET heart = heart + 1 WHERE id=$1 RETURNING heart
|
|
`
|
|
|
|
func (q *Queries) AddPostHeart(ctx context.Context, id int32) (int32, error) {
|
|
row := q.db.QueryRow(ctx, addPostHeart, id)
|
|
var heart int32
|
|
err := row.Scan(&heart)
|
|
return heart, err
|
|
}
|
|
|
|
const adminCreateAccount = `-- name: AdminCreateAccount :exec
|
|
INSERT INTO admin (username, password, totp) VALUES ($1, $2,$3)
|
|
`
|
|
|
|
type AdminCreateAccountParams struct {
|
|
Username string
|
|
Password string
|
|
Totp string
|
|
}
|
|
|
|
func (q *Queries) AdminCreateAccount(ctx context.Context, arg AdminCreateAccountParams) error {
|
|
_, err := q.db.Exec(ctx, adminCreateAccount, arg.Username, arg.Password, arg.Totp)
|
|
return err
|
|
}
|
|
|
|
const adminGetMedia = `-- name: AdminGetMedia :many
|
|
SELECT url from media WHERE post_id = $1
|
|
`
|
|
|
|
func (q *Queries) AdminGetMedia(ctx context.Context, postID pgtype.Int4) ([]string, error) {
|
|
rows, err := q.db.Query(ctx, adminGetMedia, postID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []string
|
|
for rows.Next() {
|
|
var url string
|
|
if err := rows.Scan(&url); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, url)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const adminGetPost = `-- name: AdminGetPost :many
|
|
SELECT id, content, signing, post_at FROM posts WHERE phase = 'pending' ORDER BY id DESC LIMIT 100
|
|
`
|
|
|
|
type AdminGetPostRow struct {
|
|
ID int32
|
|
Content string
|
|
Signing pgtype.Text
|
|
PostAt pgtype.Timestamptz
|
|
}
|
|
|
|
func (q *Queries) AdminGetPost(ctx context.Context) ([]AdminGetPostRow, error) {
|
|
rows, err := q.db.Query(ctx, adminGetPost)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []AdminGetPostRow
|
|
for rows.Next() {
|
|
var i AdminGetPostRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Content,
|
|
&i.Signing,
|
|
&i.PostAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const adminLoginGetTOTP = `-- name: AdminLoginGetTOTP :one
|
|
SELECT totp, super FROM admin WHERE username = $1 AND password = $2
|
|
`
|
|
|
|
type AdminLoginGetTOTPParams struct {
|
|
Username string
|
|
Password string
|
|
}
|
|
|
|
type AdminLoginGetTOTPRow struct {
|
|
Totp string
|
|
Super bool
|
|
}
|
|
|
|
func (q *Queries) AdminLoginGetTOTP(ctx context.Context, arg AdminLoginGetTOTPParams) (AdminLoginGetTOTPRow, error) {
|
|
row := q.db.QueryRow(ctx, adminLoginGetTOTP, arg.Username, arg.Password)
|
|
var i AdminLoginGetTOTPRow
|
|
err := row.Scan(&i.Totp, &i.Super)
|
|
return i, err
|
|
}
|
|
|
|
const adminUpdateImage = `-- name: AdminUpdateImage :exec
|
|
UPDATE media SET visible = false WHERE post_id=$1
|
|
`
|
|
|
|
func (q *Queries) AdminUpdateImage(ctx context.Context, postID pgtype.Int4) error {
|
|
_, err := q.db.Exec(ctx, adminUpdateImage, postID)
|
|
return err
|
|
}
|
|
|
|
const adminVerify = `-- name: AdminVerify :one
|
|
UPDATE posts SET phase = $1 WHERE id=$2 AND phase = 'pending' RETURNING id
|
|
`
|
|
|
|
type AdminVerifyParams struct {
|
|
Phase PostPhase
|
|
ID int32
|
|
}
|
|
|
|
func (q *Queries) AdminVerify(ctx context.Context, arg AdminVerifyParams) (int32, error) {
|
|
row := q.db.QueryRow(ctx, adminVerify, arg.Phase, arg.ID)
|
|
var id int32
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const deletePost = `-- name: DeletePost :exec
|
|
UPDATE posts SET phase = 'deleted' WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) DeletePost(ctx context.Context, id int32) error {
|
|
_, err := q.db.Exec(ctx, deletePost, id)
|
|
return err
|
|
}
|
|
|
|
const getComment = `-- name: GetComment :many
|
|
SELECT id, content, signing, post_at
|
|
FROM comment
|
|
WHERE phase = 'ok' AND post_id = $1
|
|
ORDER BY id DESC
|
|
LIMIT $2
|
|
`
|
|
|
|
type GetCommentParams struct {
|
|
PostID int32
|
|
Limit int32
|
|
}
|
|
|
|
type GetCommentRow struct {
|
|
ID int32
|
|
Content string
|
|
Signing pgtype.Text
|
|
PostAt pgtype.Timestamptz
|
|
}
|
|
|
|
func (q *Queries) GetComment(ctx context.Context, arg GetCommentParams) ([]GetCommentRow, error) {
|
|
rows, err := q.db.Query(ctx, getComment, arg.PostID, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetCommentRow
|
|
for rows.Next() {
|
|
var i GetCommentRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Content,
|
|
&i.Signing,
|
|
&i.PostAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getCommentMedia = `-- name: GetCommentMedia :many
|
|
SELECT url
|
|
FROM media
|
|
WHERE comment_id=$1 AND visible = true
|
|
`
|
|
|
|
func (q *Queries) GetCommentMedia(ctx context.Context, commentID pgtype.Int4) ([]string, error) {
|
|
rows, err := q.db.Query(ctx, getCommentMedia, commentID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []string
|
|
for rows.Next() {
|
|
var url string
|
|
if err := rows.Scan(&url); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, url)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getCommentWithCursor = `-- name: GetCommentWithCursor :many
|
|
SELECT id, content, signing, post_at
|
|
FROM comment
|
|
WHERE id <= $1 AND phase = 'ok' AND post_id = $2
|
|
ORDER BY id DESC
|
|
LIMIT $3
|
|
`
|
|
|
|
type GetCommentWithCursorParams struct {
|
|
ID int32
|
|
PostID int32
|
|
Limit int32
|
|
}
|
|
|
|
type GetCommentWithCursorRow struct {
|
|
ID int32
|
|
Content string
|
|
Signing pgtype.Text
|
|
PostAt pgtype.Timestamptz
|
|
}
|
|
|
|
func (q *Queries) GetCommentWithCursor(ctx context.Context, arg GetCommentWithCursorParams) ([]GetCommentWithCursorRow, error) {
|
|
rows, err := q.db.Query(ctx, getCommentWithCursor, arg.ID, arg.PostID, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetCommentWithCursorRow
|
|
for rows.Next() {
|
|
var i GetCommentWithCursorRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Content,
|
|
&i.Signing,
|
|
&i.PostAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getPost = `-- name: GetPost :many
|
|
SELECT id, content, signing, post_at, heart, igid
|
|
FROM posts
|
|
WHERE phase = 'ok'
|
|
ORDER BY id DESC
|
|
LIMIT $1
|
|
`
|
|
|
|
type GetPostRow struct {
|
|
ID int32
|
|
Content string
|
|
Signing pgtype.Text
|
|
PostAt pgtype.Timestamptz
|
|
Heart int32
|
|
Igid pgtype.Text
|
|
}
|
|
|
|
func (q *Queries) GetPost(ctx context.Context, limit int32) ([]GetPostRow, error) {
|
|
rows, err := q.db.Query(ctx, getPost, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetPostRow
|
|
for rows.Next() {
|
|
var i GetPostRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Content,
|
|
&i.Signing,
|
|
&i.PostAt,
|
|
&i.Heart,
|
|
&i.Igid,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getPostMedia = `-- name: GetPostMedia :many
|
|
SELECT url
|
|
FROM media
|
|
WHERE post_id=$1 AND visible = true
|
|
`
|
|
|
|
func (q *Queries) GetPostMedia(ctx context.Context, postID pgtype.Int4) ([]string, error) {
|
|
rows, err := q.db.Query(ctx, getPostMedia, postID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []string
|
|
for rows.Next() {
|
|
var url string
|
|
if err := rows.Scan(&url); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, url)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getPostWithCursor = `-- name: GetPostWithCursor :many
|
|
SELECT id, content, signing, post_at, heart, igid
|
|
FROM posts
|
|
WHERE id <= $1 AND phase = 'ok'
|
|
ORDER BY id DESC
|
|
LIMIT $2
|
|
`
|
|
|
|
type GetPostWithCursorParams struct {
|
|
ID int32
|
|
Limit int32
|
|
}
|
|
|
|
type GetPostWithCursorRow struct {
|
|
ID int32
|
|
Content string
|
|
Signing pgtype.Text
|
|
PostAt pgtype.Timestamptz
|
|
Heart int32
|
|
Igid pgtype.Text
|
|
}
|
|
|
|
func (q *Queries) GetPostWithCursor(ctx context.Context, arg GetPostWithCursorParams) ([]GetPostWithCursorRow, error) {
|
|
rows, err := q.db.Query(ctx, getPostWithCursor, arg.ID, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetPostWithCursorRow
|
|
for rows.Next() {
|
|
var i GetPostWithCursorRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Content,
|
|
&i.Signing,
|
|
&i.PostAt,
|
|
&i.Heart,
|
|
&i.Igid,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const insertCommentImage = `-- name: InsertCommentImage :exec
|
|
INSERT INTO media (url, comment_id) VALUES ($1, $2)
|
|
`
|
|
|
|
type InsertCommentImageParams struct {
|
|
Url string
|
|
CommentID pgtype.Int4
|
|
}
|
|
|
|
func (q *Queries) InsertCommentImage(ctx context.Context, arg InsertCommentImageParams) error {
|
|
_, err := q.db.Exec(ctx, insertCommentImage, arg.Url, arg.CommentID)
|
|
return err
|
|
}
|
|
|
|
const insertPost = `-- name: InsertPost :one
|
|
INSERT INTO posts (content,signing,hash)
|
|
VALUES ($1, $2 ,$3)
|
|
RETURNING id,hash
|
|
`
|
|
|
|
type InsertPostParams struct {
|
|
Content string
|
|
Signing pgtype.Text
|
|
Hash string
|
|
}
|
|
|
|
type InsertPostRow struct {
|
|
ID int32
|
|
Hash string
|
|
}
|
|
|
|
func (q *Queries) InsertPost(ctx context.Context, arg InsertPostParams) (InsertPostRow, error) {
|
|
row := q.db.QueryRow(ctx, insertPost, arg.Content, arg.Signing, arg.Hash)
|
|
var i InsertPostRow
|
|
err := row.Scan(&i.ID, &i.Hash)
|
|
return i, err
|
|
}
|
|
|
|
const insertPostImage = `-- name: InsertPostImage :exec
|
|
INSERT INTO media (url, post_id) VALUES ($1, $2)
|
|
`
|
|
|
|
type InsertPostImageParams struct {
|
|
Url string
|
|
PostID pgtype.Int4
|
|
}
|
|
|
|
func (q *Queries) InsertPostImage(ctx context.Context, arg InsertPostImageParams) error {
|
|
_, err := q.db.Exec(ctx, insertPostImage, arg.Url, arg.PostID)
|
|
return err
|
|
}
|
|
|
|
const invalidateMedia = `-- name: InvalidateMedia :exec
|
|
UPDATE media SET visible = false WHERE post_id = $1
|
|
`
|
|
|
|
func (q *Queries) InvalidateMedia(ctx context.Context, postID pgtype.Int4) error {
|
|
_, err := q.db.Exec(ctx, invalidateMedia, postID)
|
|
return err
|
|
}
|
|
|
|
const superAdminGetPost = `-- name: SuperAdminGetPost :many
|
|
SELECT id, content, signing, post_at, phase FROM posts WHERE phase = 'pending' OR phase = 'rejected' ORDER BY id DESC LIMIT 100
|
|
`
|
|
|
|
type SuperAdminGetPostRow struct {
|
|
ID int32
|
|
Content string
|
|
Signing pgtype.Text
|
|
PostAt pgtype.Timestamptz
|
|
Phase PostPhase
|
|
}
|
|
|
|
func (q *Queries) SuperAdminGetPost(ctx context.Context) ([]SuperAdminGetPostRow, error) {
|
|
rows, err := q.db.Query(ctx, superAdminGetPost)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []SuperAdminGetPostRow
|
|
for rows.Next() {
|
|
var i SuperAdminGetPostRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Content,
|
|
&i.Signing,
|
|
&i.PostAt,
|
|
&i.Phase,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const superAdminVerify = `-- name: SuperAdminVerify :one
|
|
UPDATE posts SET phase = $1 WHERE id=$2 AND (phase = 'pending' OR phase = 'rejected') RETURNING id
|
|
`
|
|
|
|
type SuperAdminVerifyParams struct {
|
|
Phase PostPhase
|
|
ID int32
|
|
}
|
|
|
|
func (q *Queries) SuperAdminVerify(ctx context.Context, arg SuperAdminVerifyParams) (int32, error) {
|
|
row := q.db.QueryRow(ctx, superAdminVerify, arg.Phase, arg.ID)
|
|
var id int32
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const updatePostIGID = `-- name: UpdatePostIGID :exec
|
|
UPDATE posts set igid = $1 WHERE id = $2
|
|
`
|
|
|
|
type UpdatePostIGIDParams struct {
|
|
Igid pgtype.Text
|
|
ID int32
|
|
}
|
|
|
|
func (q *Queries) UpdatePostIGID(ctx context.Context, arg UpdatePostIGIDParams) error {
|
|
_, err := q.db.Exec(ctx, updatePostIGID, arg.Igid, arg.ID)
|
|
return err
|
|
}
|