newsbot-api/database/query.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.16.0
// source: query.sql

package database

import (
	"context"
	"database/sql"
	"time"

	"github.com/google/uuid"
)

const createArticle = `-- name: CreateArticle :exec
INSERT INTO Articles 
(ID, SourceId, Tags, Title, Url, PubDate, Video, VideoHeight, VideoWidth, Thumbnail, Description, AuthorName, AuthorImage)
Values
($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
`

type CreateArticleParams struct {
	ID          uuid.UUID
	Sourceid    uuid.UUID
	Tags        string
	Title       string
	Url         string
	Pubdate     time.Time
	Video       sql.NullString
	Videoheight int32
	Videowidth  int32
	Thumbnail   string
	Description string
	Authorname  sql.NullString
	Authorimage sql.NullString
}

func (q *Queries) CreateArticle(ctx context.Context, arg CreateArticleParams) error {
	_, err := q.db.ExecContext(ctx, createArticle,
		arg.ID,
		arg.Sourceid,
		arg.Tags,
		arg.Title,
		arg.Url,
		arg.Pubdate,
		arg.Video,
		arg.Videoheight,
		arg.Videowidth,
		arg.Thumbnail,
		arg.Description,
		arg.Authorname,
		arg.Authorimage,
	)
	return err
}

const createDiscordQueue = `-- name: CreateDiscordQueue :exec
Insert into DiscordQueue
(ID, ArticleId)
Values
($1, $2)
`

type CreateDiscordQueueParams struct {
	ID        uuid.UUID
	Articleid uuid.UUID
}

// DiscordQueue
func (q *Queries) CreateDiscordQueue(ctx context.Context, arg CreateDiscordQueueParams) error {
	_, err := q.db.ExecContext(ctx, createDiscordQueue, arg.ID, arg.Articleid)
	return err
}

const createDiscordWebHook = `-- name: CreateDiscordWebHook :exec
Insert Into DiscordWebHooks
(ID, Url, Server, Channel, Enabled)
Values
($1, $2, $3, $4, $5)
`

type CreateDiscordWebHookParams struct {
	ID      uuid.UUID
	Url     string
	Server  string
	Channel string
	Enabled bool
}

// DiscordWebHooks
func (q *Queries) CreateDiscordWebHook(ctx context.Context, arg CreateDiscordWebHookParams) error {
	_, err := q.db.ExecContext(ctx, createDiscordWebHook,
		arg.ID,
		arg.Url,
		arg.Server,
		arg.Channel,
		arg.Enabled,
	)
	return err
}

const createIcon = `-- name: CreateIcon :exec

INSERT INTO Icons
(ID, FileName, Site)
VALUES
($1,$2,$3)
`

type CreateIconParams struct {
	ID       uuid.UUID
	Filename string
	Site     string
}

// Icons
func (q *Queries) CreateIcon(ctx context.Context, arg CreateIconParams) error {
	_, err := q.db.ExecContext(ctx, createIcon, arg.ID, arg.Filename, arg.Site)
	return err
}

const createSettings = `-- name: CreateSettings :one

Insert Into settings
(ID, Key, Value, OPTIONS)
Values
($1,$2,$3,$4)
RETURNING id, key, value, options
`

type CreateSettingsParams struct {
	ID      uuid.UUID
	Key     string
	Value   string
	Options sql.NullString
}

// Settings
func (q *Queries) CreateSettings(ctx context.Context, arg CreateSettingsParams) (Setting, error) {
	row := q.db.QueryRowContext(ctx, createSettings,
		arg.ID,
		arg.Key,
		arg.Value,
		arg.Options,
	)
	var i Setting
	err := row.Scan(
		&i.ID,
		&i.Key,
		&i.Value,
		&i.Options,
	)
	return i, err
}

const createSource = `-- name: CreateSource :exec

Insert Into Sources
(ID, Site, Name, Source, Type, Value, Enabled, Url, Tags)
Values
($1,$2,$3,$4,$5,$6,$7,$8,$9)
`

type CreateSourceParams struct {
	ID      uuid.UUID
	Site    string
	Name    string
	Source  string
	Type    string
	Value   sql.NullString
	Enabled bool
	Url     string
	Tags    string
}

// Sources
func (q *Queries) CreateSource(ctx context.Context, arg CreateSourceParams) error {
	_, err := q.db.ExecContext(ctx, createSource,
		arg.ID,
		arg.Site,
		arg.Name,
		arg.Source,
		arg.Type,
		arg.Value,
		arg.Enabled,
		arg.Url,
		arg.Tags,
	)
	return err
}

const createSubscription = `-- name: CreateSubscription :exec

Insert Into subscriptions (ID, DiscordWebHookId, SourceId) Values ($1, $2, $3)
`

type CreateSubscriptionParams struct {
	ID               uuid.UUID
	Discordwebhookid uuid.UUID
	Sourceid         uuid.UUID
}

// Subscriptions
func (q *Queries) CreateSubscription(ctx context.Context, arg CreateSubscriptionParams) error {
	_, err := q.db.ExecContext(ctx, createSubscription, arg.ID, arg.Discordwebhookid, arg.Sourceid)
	return err
}

const deleteDiscordQueueItem = `-- name: DeleteDiscordQueueItem :exec
Delete From DiscordQueue Where ID = $1
`

func (q *Queries) DeleteDiscordQueueItem(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteDiscordQueueItem, id)
	return err
}

const deleteDiscordWebHooks = `-- name: DeleteDiscordWebHooks :exec
Delete From discordwebhooks Where ID = $1
`

func (q *Queries) DeleteDiscordWebHooks(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteDiscordWebHooks, id)
	return err
}

const deleteIcon = `-- name: DeleteIcon :exec
Delete From Icons where ID = $1
`

func (q *Queries) DeleteIcon(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteIcon, id)
	return err
}

const deleteSetting = `-- name: DeleteSetting :exec
Delete From settings Where ID = $1
`

func (q *Queries) DeleteSetting(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteSetting, id)
	return err
}

const deleteSource = `-- name: DeleteSource :exec
UPDATE Sources Set Disabled = TRUE where id = $1
`

func (q *Queries) DeleteSource(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteSource, id)
	return err
}

const deleteSubscription = `-- name: DeleteSubscription :exec
Delete From subscriptions Where id = $1
`

func (q *Queries) DeleteSubscription(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteSubscription, id)
	return err
}

const disableDiscordWebHook = `-- name: DisableDiscordWebHook :exec
Update discordwebhooks Set Enabled = FALSE where ID = $1
`

func (q *Queries) DisableDiscordWebHook(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, disableDiscordWebHook, id)
	return err
}

const disableSource = `-- name: DisableSource :exec
Update Sources Set Enabled = FALSE where ID = $1
`

func (q *Queries) DisableSource(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, disableSource, id)
	return err
}

const enableDiscordWebHook = `-- name: EnableDiscordWebHook :exec
Update discordwebhooks Set Enabled = TRUE where ID = $1
`

func (q *Queries) EnableDiscordWebHook(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, enableDiscordWebHook, id)
	return err
}

const enableSource = `-- name: EnableSource :exec
Update Sources Set Enabled = TRUE where ID = $1
`

func (q *Queries) EnableSource(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, enableSource, id)
	return err
}

const getArticleByID = `-- name: GetArticleByID :one
Select id, sourceid, tags, title, url, pubdate, video, videoheight, videowidth, thumbnail, description, authorname, authorimage from Articles
WHERE ID = $1 LIMIT 1
`

// Articles
func (q *Queries) GetArticleByID(ctx context.Context, id uuid.UUID) (Article, error) {
	row := q.db.QueryRowContext(ctx, getArticleByID, id)
	var i Article
	err := row.Scan(
		&i.ID,
		&i.Sourceid,
		&i.Tags,
		&i.Title,
		&i.Url,
		&i.Pubdate,
		&i.Video,
		&i.Videoheight,
		&i.Videowidth,
		&i.Thumbnail,
		&i.Description,
		&i.Authorname,
		&i.Authorimage,
	)
	return i, err
}

const getArticleByUrl = `-- name: GetArticleByUrl :one
Select id, sourceid, tags, title, url, pubdate, video, videoheight, videowidth, thumbnail, description, authorname, authorimage from Articles
Where Url = $1 LIMIT 1
`

func (q *Queries) GetArticleByUrl(ctx context.Context, url string) (Article, error) {
	row := q.db.QueryRowContext(ctx, getArticleByUrl, url)
	var i Article
	err := row.Scan(
		&i.ID,
		&i.Sourceid,
		&i.Tags,
		&i.Title,
		&i.Url,
		&i.Pubdate,
		&i.Video,
		&i.Videoheight,
		&i.Videowidth,
		&i.Thumbnail,
		&i.Description,
		&i.Authorname,
		&i.Authorimage,
	)
	return i, err
}

const getArticlesBySource = `-- name: GetArticlesBySource :many
select articles.id, sourceid, articles.tags, title, articles.url, pubdate, video, videoheight, videowidth, thumbnail, description, authorname, authorimage, sources.id, site, name, source, type, value, enabled, sources.url, sources.tags, deleted from articles
INNER join sources on articles.sourceid=Sources.ID
where site = $1
`

type GetArticlesBySourceRow struct {
	ID          uuid.UUID
	Sourceid    uuid.UUID
	Tags        string
	Title       string
	Url         string
	Pubdate     time.Time
	Video       sql.NullString
	Videoheight int32
	Videowidth  int32
	Thumbnail   string
	Description string
	Authorname  sql.NullString
	Authorimage sql.NullString
	ID_2        uuid.UUID
	Site        string
	Name        string
	Source      string
	Type        string
	Value       sql.NullString
	Enabled     bool
	Url_2       string
	Tags_2      string
	Deleted     sql.NullBool
}

func (q *Queries) GetArticlesBySource(ctx context.Context, site string) ([]GetArticlesBySourceRow, error) {
	rows, err := q.db.QueryContext(ctx, getArticlesBySource, site)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetArticlesBySourceRow
	for rows.Next() {
		var i GetArticlesBySourceRow
		if err := rows.Scan(
			&i.ID,
			&i.Sourceid,
			&i.Tags,
			&i.Title,
			&i.Url,
			&i.Pubdate,
			&i.Video,
			&i.Videoheight,
			&i.Videowidth,
			&i.Thumbnail,
			&i.Description,
			&i.Authorname,
			&i.Authorimage,
			&i.ID_2,
			&i.Site,
			&i.Name,
			&i.Source,
			&i.Type,
			&i.Value,
			&i.Enabled,
			&i.Url_2,
			&i.Tags_2,
			&i.Deleted,
		); 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 getArticlesBySourceName = `-- name: GetArticlesBySourceName :many
select 
articles.ID, articles.SourceId, articles.Tags, articles.Title, articles.Url, articles.PubDate, articles.Video, articles.VideoHeight, articles.VideoWidth, articles.Thumbnail, articles.Description, articles.AuthorName, articles.AuthorImage, sources.source, sources.name
From articles
Left Join sources
On articles.sourceid = sources.id
Where name = $1
`

type GetArticlesBySourceNameRow struct {
	ID          uuid.UUID
	Sourceid    uuid.UUID
	Tags        string
	Title       string
	Url         string
	Pubdate     time.Time
	Video       sql.NullString
	Videoheight int32
	Videowidth  int32
	Thumbnail   string
	Description string
	Authorname  sql.NullString
	Authorimage sql.NullString
	Source      sql.NullString
	Name        sql.NullString
}

func (q *Queries) GetArticlesBySourceName(ctx context.Context, name string) ([]GetArticlesBySourceNameRow, error) {
	rows, err := q.db.QueryContext(ctx, getArticlesBySourceName, name)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetArticlesBySourceNameRow
	for rows.Next() {
		var i GetArticlesBySourceNameRow
		if err := rows.Scan(
			&i.ID,
			&i.Sourceid,
			&i.Tags,
			&i.Title,
			&i.Url,
			&i.Pubdate,
			&i.Video,
			&i.Videoheight,
			&i.Videowidth,
			&i.Thumbnail,
			&i.Description,
			&i.Authorname,
			&i.Authorimage,
			&i.Source,
			&i.Name,
		); 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 getDiscordQueueByID = `-- name: GetDiscordQueueByID :one
Select id, articleid from DiscordQueue
Where ID = $1 LIMIT 1
`

func (q *Queries) GetDiscordQueueByID(ctx context.Context, id uuid.UUID) (Discordqueue, error) {
	row := q.db.QueryRowContext(ctx, getDiscordQueueByID, id)
	var i Discordqueue
	err := row.Scan(&i.ID, &i.Articleid)
	return i, err
}

const getDiscordWebHookByUrl = `-- name: GetDiscordWebHookByUrl :one
Select id, url, server, channel, enabled From DiscordWebHooks Where url = $1
`

func (q *Queries) GetDiscordWebHookByUrl(ctx context.Context, url string) (Discordwebhook, error) {
	row := q.db.QueryRowContext(ctx, getDiscordWebHookByUrl, url)
	var i Discordwebhook
	err := row.Scan(
		&i.ID,
		&i.Url,
		&i.Server,
		&i.Channel,
		&i.Enabled,
	)
	return i, err
}

const getDiscordWebHooksByID = `-- name: GetDiscordWebHooksByID :one
Select id, url, server, channel, enabled from DiscordWebHooks
Where ID = $1 LIMIT 1
`

func (q *Queries) GetDiscordWebHooksByID(ctx context.Context, id uuid.UUID) (Discordwebhook, error) {
	row := q.db.QueryRowContext(ctx, getDiscordWebHooksByID, id)
	var i Discordwebhook
	err := row.Scan(
		&i.ID,
		&i.Url,
		&i.Server,
		&i.Channel,
		&i.Enabled,
	)
	return i, err
}

const getDiscordWebHooksByServerAndChannel = `-- name: GetDiscordWebHooksByServerAndChannel :many
SELECT id, url, server, channel, enabled FROM DiscordWebHooks
WHERE Server = $1 and Channel = $2
`

type GetDiscordWebHooksByServerAndChannelParams struct {
	Server  string
	Channel string
}

func (q *Queries) GetDiscordWebHooksByServerAndChannel(ctx context.Context, arg GetDiscordWebHooksByServerAndChannelParams) ([]Discordwebhook, error) {
	rows, err := q.db.QueryContext(ctx, getDiscordWebHooksByServerAndChannel, arg.Server, arg.Channel)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Discordwebhook
	for rows.Next() {
		var i Discordwebhook
		if err := rows.Scan(
			&i.ID,
			&i.Url,
			&i.Server,
			&i.Channel,
			&i.Enabled,
		); 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 getIconByID = `-- name: GetIconByID :one
Select id, filename, site FROM Icons
Where ID = $1 Limit 1
`

func (q *Queries) GetIconByID(ctx context.Context, id uuid.UUID) (Icon, error) {
	row := q.db.QueryRowContext(ctx, getIconByID, id)
	var i Icon
	err := row.Scan(&i.ID, &i.Filename, &i.Site)
	return i, err
}

const getIconBySite = `-- name: GetIconBySite :one
Select id, filename, site FROM Icons
Where Site = $1 Limit 1
`

func (q *Queries) GetIconBySite(ctx context.Context, site string) (Icon, error) {
	row := q.db.QueryRowContext(ctx, getIconBySite, site)
	var i Icon
	err := row.Scan(&i.ID, &i.Filename, &i.Site)
	return i, err
}

const getSettingByID = `-- name: GetSettingByID :one
Select id, key, value, options From settings
Where ID = $1 Limit 1
`

func (q *Queries) GetSettingByID(ctx context.Context, id uuid.UUID) (Setting, error) {
	row := q.db.QueryRowContext(ctx, getSettingByID, id)
	var i Setting
	err := row.Scan(
		&i.ID,
		&i.Key,
		&i.Value,
		&i.Options,
	)
	return i, err
}

const getSettingByKey = `-- name: GetSettingByKey :one
Select id, key, value, options From settings Where 
Key = $1 Limit 1
`

func (q *Queries) GetSettingByKey(ctx context.Context, key string) (Setting, error) {
	row := q.db.QueryRowContext(ctx, getSettingByKey, key)
	var i Setting
	err := row.Scan(
		&i.ID,
		&i.Key,
		&i.Value,
		&i.Options,
	)
	return i, err
}

const getSettingByValue = `-- name: GetSettingByValue :one
Select id, key, value, options From settings Where 
Value = $1 Limit 1
`

func (q *Queries) GetSettingByValue(ctx context.Context, value string) (Setting, error) {
	row := q.db.QueryRowContext(ctx, getSettingByValue, value)
	var i Setting
	err := row.Scan(
		&i.ID,
		&i.Key,
		&i.Value,
		&i.Options,
	)
	return i, err
}

const getSourceByID = `-- name: GetSourceByID :one
Select id, site, name, source, type, value, enabled, url, tags, deleted From Sources where ID = $1 Limit 1
`

func (q *Queries) GetSourceByID(ctx context.Context, id uuid.UUID) (Source, error) {
	row := q.db.QueryRowContext(ctx, getSourceByID, id)
	var i Source
	err := row.Scan(
		&i.ID,
		&i.Site,
		&i.Name,
		&i.Source,
		&i.Type,
		&i.Value,
		&i.Enabled,
		&i.Url,
		&i.Tags,
		&i.Deleted,
	)
	return i, err
}

const getSourceByName = `-- name: GetSourceByName :one
Select id, site, name, source, type, value, enabled, url, tags, deleted from Sources where name = $1 Limit 1
`

func (q *Queries) GetSourceByName(ctx context.Context, name string) (Source, error) {
	row := q.db.QueryRowContext(ctx, getSourceByName, name)
	var i Source
	err := row.Scan(
		&i.ID,
		&i.Site,
		&i.Name,
		&i.Source,
		&i.Type,
		&i.Value,
		&i.Enabled,
		&i.Url,
		&i.Tags,
		&i.Deleted,
	)
	return i, err
}

const getSourceByNameAndSource = `-- name: GetSourceByNameAndSource :one
Select id, site, name, source, type, value, enabled, url, tags, deleted from Sources WHERE name = $1 and source = $2
`

type GetSourceByNameAndSourceParams struct {
	Name   string
	Source string
}

func (q *Queries) GetSourceByNameAndSource(ctx context.Context, arg GetSourceByNameAndSourceParams) (Source, error) {
	row := q.db.QueryRowContext(ctx, getSourceByNameAndSource, arg.Name, arg.Source)
	var i Source
	err := row.Scan(
		&i.ID,
		&i.Site,
		&i.Name,
		&i.Source,
		&i.Type,
		&i.Value,
		&i.Enabled,
		&i.Url,
		&i.Tags,
		&i.Deleted,
	)
	return i, err
}

const getSubscriptionsByDiscordWebHookId = `-- name: GetSubscriptionsByDiscordWebHookId :many
Select id, discordwebhookid, sourceid from subscriptions Where discordwebhookid = $1
`

func (q *Queries) GetSubscriptionsByDiscordWebHookId(ctx context.Context, discordwebhookid uuid.UUID) ([]Subscription, error) {
	rows, err := q.db.QueryContext(ctx, getSubscriptionsByDiscordWebHookId, discordwebhookid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Subscription
	for rows.Next() {
		var i Subscription
		if err := rows.Scan(&i.ID, &i.Discordwebhookid, &i.Sourceid); 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 getSubscriptionsBySourceID = `-- name: GetSubscriptionsBySourceID :many
Select id, discordwebhookid, sourceid From subscriptions Where sourceid = $1
`

func (q *Queries) GetSubscriptionsBySourceID(ctx context.Context, sourceid uuid.UUID) ([]Subscription, error) {
	rows, err := q.db.QueryContext(ctx, getSubscriptionsBySourceID, sourceid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Subscription
	for rows.Next() {
		var i Subscription
		if err := rows.Scan(&i.ID, &i.Discordwebhookid, &i.Sourceid); 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 listArticles = `-- name: ListArticles :many
Select id, sourceid, tags, title, url, pubdate, video, videoheight, videowidth, thumbnail, description, authorname, authorimage From articles 
Order By PubDate DESC
offset $2
fetch next $1 rows only
`

type ListArticlesParams struct {
	Limit  int32
	Offset int32
}

func (q *Queries) ListArticles(ctx context.Context, arg ListArticlesParams) ([]Article, error) {
	rows, err := q.db.QueryContext(ctx, listArticles, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Article
	for rows.Next() {
		var i Article
		if err := rows.Scan(
			&i.ID,
			&i.Sourceid,
			&i.Tags,
			&i.Title,
			&i.Url,
			&i.Pubdate,
			&i.Video,
			&i.Videoheight,
			&i.Videowidth,
			&i.Thumbnail,
			&i.Description,
			&i.Authorname,
			&i.Authorimage,
		); 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 listArticlesByDate = `-- name: ListArticlesByDate :many
Select id, sourceid, tags, title, url, pubdate, video, videoheight, videowidth, thumbnail, description, authorname, authorimage From articles 
ORDER BY pubdate desc 
Limit $1
`

func (q *Queries) ListArticlesByDate(ctx context.Context, limit int32) ([]Article, error) {
	rows, err := q.db.QueryContext(ctx, listArticlesByDate, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Article
	for rows.Next() {
		var i Article
		if err := rows.Scan(
			&i.ID,
			&i.Sourceid,
			&i.Tags,
			&i.Title,
			&i.Url,
			&i.Pubdate,
			&i.Video,
			&i.Videoheight,
			&i.Videowidth,
			&i.Thumbnail,
			&i.Description,
			&i.Authorname,
			&i.Authorimage,
		); 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 listArticlesByPage = `-- name: ListArticlesByPage :many
select id, sourceid, tags, title, url, pubdate, video, videoheight, videowidth, thumbnail, description, authorname, authorimage from articles
order by pubdate desc
offset $2
fetch next $1 rows only
`

type ListArticlesByPageParams struct {
	Limit  int32
	Offset int32
}

func (q *Queries) ListArticlesByPage(ctx context.Context, arg ListArticlesByPageParams) ([]Article, error) {
	rows, err := q.db.QueryContext(ctx, listArticlesByPage, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Article
	for rows.Next() {
		var i Article
		if err := rows.Scan(
			&i.ID,
			&i.Sourceid,
			&i.Tags,
			&i.Title,
			&i.Url,
			&i.Pubdate,
			&i.Video,
			&i.Videoheight,
			&i.Videowidth,
			&i.Thumbnail,
			&i.Description,
			&i.Authorname,
			&i.Authorimage,
		); 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 listArticlesBySourceId = `-- name: ListArticlesBySourceId :many
Select id, sourceid, tags, title, url, pubdate, video, videoheight, videowidth, thumbnail, description, authorname, authorimage From articles
Where sourceid = $1 
Limit 50
`

func (q *Queries) ListArticlesBySourceId(ctx context.Context, sourceid uuid.UUID) ([]Article, error) {
	rows, err := q.db.QueryContext(ctx, listArticlesBySourceId, sourceid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Article
	for rows.Next() {
		var i Article
		if err := rows.Scan(
			&i.ID,
			&i.Sourceid,
			&i.Tags,
			&i.Title,
			&i.Url,
			&i.Pubdate,
			&i.Video,
			&i.Videoheight,
			&i.Videowidth,
			&i.Thumbnail,
			&i.Description,
			&i.Authorname,
			&i.Authorimage,
		); 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 listDiscordQueueItems = `-- name: ListDiscordQueueItems :many
Select id, articleid from DiscordQueue LIMIT $1
`

func (q *Queries) ListDiscordQueueItems(ctx context.Context, limit int32) ([]Discordqueue, error) {
	rows, err := q.db.QueryContext(ctx, listDiscordQueueItems, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Discordqueue
	for rows.Next() {
		var i Discordqueue
		if err := rows.Scan(&i.ID, &i.Articleid); 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 listDiscordWebHooksByServer = `-- name: ListDiscordWebHooksByServer :many
Select id, url, server, channel, enabled From DiscordWebHooks
Where Server = $1
`

func (q *Queries) ListDiscordWebHooksByServer(ctx context.Context, server string) ([]Discordwebhook, error) {
	rows, err := q.db.QueryContext(ctx, listDiscordWebHooksByServer, server)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Discordwebhook
	for rows.Next() {
		var i Discordwebhook
		if err := rows.Scan(
			&i.ID,
			&i.Url,
			&i.Server,
			&i.Channel,
			&i.Enabled,
		); 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 listDiscordWebhooks = `-- name: ListDiscordWebhooks :many
Select id, url, server, channel, enabled From discordwebhooks LIMIT $1
`

func (q *Queries) ListDiscordWebhooks(ctx context.Context, limit int32) ([]Discordwebhook, error) {
	rows, err := q.db.QueryContext(ctx, listDiscordWebhooks, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Discordwebhook
	for rows.Next() {
		var i Discordwebhook
		if err := rows.Scan(
			&i.ID,
			&i.Url,
			&i.Server,
			&i.Channel,
			&i.Enabled,
		); 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 listNewArticlesBySourceId = `-- name: ListNewArticlesBySourceId :many
SELECT id, sourceid, tags, title, url, pubdate, video, videoheight, videowidth, thumbnail, description, authorname, authorimage FROM articles
Where sourceid = $1
ORDER BY pubdate desc
offset $3
fetch next $2 rows only
`

type ListNewArticlesBySourceIdParams struct {
	Sourceid uuid.UUID
	Limit    int32
	Offset   int32
}

func (q *Queries) ListNewArticlesBySourceId(ctx context.Context, arg ListNewArticlesBySourceIdParams) ([]Article, error) {
	rows, err := q.db.QueryContext(ctx, listNewArticlesBySourceId, arg.Sourceid, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Article
	for rows.Next() {
		var i Article
		if err := rows.Scan(
			&i.ID,
			&i.Sourceid,
			&i.Tags,
			&i.Title,
			&i.Url,
			&i.Pubdate,
			&i.Video,
			&i.Videoheight,
			&i.Videowidth,
			&i.Thumbnail,
			&i.Description,
			&i.Authorname,
			&i.Authorimage,
		); 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 listSources = `-- name: ListSources :many
Select id, site, name, source, type, value, enabled, url, tags, deleted From Sources Limit $1
`

func (q *Queries) ListSources(ctx context.Context, limit int32) ([]Source, error) {
	rows, err := q.db.QueryContext(ctx, listSources, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Source
	for rows.Next() {
		var i Source
		if err := rows.Scan(
			&i.ID,
			&i.Site,
			&i.Name,
			&i.Source,
			&i.Type,
			&i.Value,
			&i.Enabled,
			&i.Url,
			&i.Tags,
			&i.Deleted,
		); 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 listSourcesBySource = `-- name: ListSourcesBySource :many
Select id, site, name, source, type, value, enabled, url, tags, deleted From Sources where Source = $1
`

func (q *Queries) ListSourcesBySource(ctx context.Context, source string) ([]Source, error) {
	rows, err := q.db.QueryContext(ctx, listSourcesBySource, source)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Source
	for rows.Next() {
		var i Source
		if err := rows.Scan(
			&i.ID,
			&i.Site,
			&i.Name,
			&i.Source,
			&i.Type,
			&i.Value,
			&i.Enabled,
			&i.Url,
			&i.Tags,
			&i.Deleted,
		); 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 listSubscriptions = `-- name: ListSubscriptions :many
Select id, discordwebhookid, sourceid From subscriptions Limit $1
`

func (q *Queries) ListSubscriptions(ctx context.Context, limit int32) ([]Subscription, error) {
	rows, err := q.db.QueryContext(ctx, listSubscriptions, limit)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Subscription
	for rows.Next() {
		var i Subscription
		if err := rows.Scan(&i.ID, &i.Discordwebhookid, &i.Sourceid); 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 listSubscriptionsBySourceId = `-- name: ListSubscriptionsBySourceId :many
Select id, discordwebhookid, sourceid From subscriptions where sourceid = $1
`

func (q *Queries) ListSubscriptionsBySourceId(ctx context.Context, sourceid uuid.UUID) ([]Subscription, error) {
	rows, err := q.db.QueryContext(ctx, listSubscriptionsBySourceId, sourceid)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Subscription
	for rows.Next() {
		var i Subscription
		if err := rows.Scan(&i.ID, &i.Discordwebhookid, &i.Sourceid); 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 querySubscriptions = `-- name: QuerySubscriptions :one
Select id, discordwebhookid, sourceid From subscriptions Where discordwebhookid = $1 and sourceid = $2 Limit 1
`

type QuerySubscriptionsParams struct {
	Discordwebhookid uuid.UUID
	Sourceid         uuid.UUID
}

func (q *Queries) QuerySubscriptions(ctx context.Context, arg QuerySubscriptionsParams) (Subscription, error) {
	row := q.db.QueryRowContext(ctx, querySubscriptions, arg.Discordwebhookid, arg.Sourceid)
	var i Subscription
	err := row.Scan(&i.ID, &i.Discordwebhookid, &i.Sourceid)
	return i, err
}