chiyiandDevin
834ecacdb9
Go(fun)+SQLite backend, Vue 3 frontend. Modules: dashboard, pay gateway (Epay-compatible + CDK stock), license/card system (per-app appid, domain binding), AI memory bank with built-in MCP server (/mcp, FTS5 search, signed read links), server SSH monitor + terminal + SFTP, proxy pool with protocol-level alive checks, DB manager (mysql/pg/sqlite + SQL autocomplete + import/export), disk share, vault (AES-GCM + TOTP), bookmarks, dev tools. Generated with [Devin](https://devin.ai) Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
3103 lines
70 KiB
Go
3103 lines
70 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: queries.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
)
|
|
|
|
const activateLicenseCard = `-- name: ActivateLicenseCard :exec
|
|
UPDATE license_cards SET domain = ?, activated_at = ?, expires_at = ? WHERE id = ?
|
|
`
|
|
|
|
type ActivateLicenseCardParams struct {
|
|
Domain string
|
|
ActivatedAt int64
|
|
ExpiresAt int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) ActivateLicenseCard(ctx context.Context, arg ActivateLicenseCardParams) error {
|
|
_, err := q.db.ExecContext(ctx, activateLicenseCard,
|
|
arg.Domain,
|
|
arg.ActivatedAt,
|
|
arg.ExpiresAt,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const countActiveSessions = `-- name: CountActiveSessions :one
|
|
SELECT COUNT(*) FROM sessions WHERE expires_at > ?
|
|
`
|
|
|
|
func (q *Queries) CountActiveSessions(ctx context.Context, expiresAt int64) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countActiveSessions, expiresAt)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countActiveUsers = `-- name: CountActiveUsers :one
|
|
SELECT COUNT(*) FROM users WHERE status = 'active'
|
|
`
|
|
|
|
func (q *Queries) CountActiveUsers(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countActiveUsers)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countAdmins = `-- name: CountAdmins :one
|
|
SELECT COUNT(*) FROM users WHERE role = 'admin' AND status = 'active'
|
|
`
|
|
|
|
func (q *Queries) CountAdmins(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countAdmins)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countAllUsers = `-- name: CountAllUsers :one
|
|
SELECT COUNT(*) FROM users
|
|
`
|
|
|
|
func (q *Queries) CountAllUsers(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countAllUsers)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countBookmarksByUser = `-- name: CountBookmarksByUser :one
|
|
SELECT COUNT(*) FROM bookmarks WHERE user_id = ?
|
|
`
|
|
|
|
func (q *Queries) CountBookmarksByUser(ctx context.Context, userID int64) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countBookmarksByUser, userID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countDbconns = `-- name: CountDbconns :one
|
|
SELECT COUNT(*) FROM dbconns
|
|
`
|
|
|
|
func (q *Queries) CountDbconns(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countDbconns)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countFilesAll = `-- name: CountFilesAll :one
|
|
SELECT COUNT(*) FROM files
|
|
`
|
|
|
|
func (q *Queries) CountFilesAll(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countFilesAll)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countLicenseApps = `-- name: CountLicenseApps :one
|
|
SELECT COUNT(*) FROM license_apps
|
|
`
|
|
|
|
func (q *Queries) CountLicenseApps(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countLicenseApps)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countLicenseCards = `-- name: CountLicenseCards :one
|
|
SELECT COUNT(*) FROM license_cards
|
|
WHERE app_id = ? AND (? = '' OR card LIKE '%' || ? || '%' OR domain LIKE '%' || ? || '%')
|
|
`
|
|
|
|
type CountLicenseCardsParams struct {
|
|
AppID int64
|
|
Column2 interface{}
|
|
Column3 sql.NullString
|
|
Column4 sql.NullString
|
|
}
|
|
|
|
func (q *Queries) CountLicenseCards(ctx context.Context, arg CountLicenseCardsParams) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countLicenseCards,
|
|
arg.AppID,
|
|
arg.Column2,
|
|
arg.Column3,
|
|
arg.Column4,
|
|
)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countMemories = `-- name: CountMemories :one
|
|
SELECT COUNT(*) FROM memories
|
|
`
|
|
|
|
func (q *Queries) CountMemories(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countMemories)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countPayOrders = `-- name: CountPayOrders :one
|
|
SELECT COUNT(*) FROM pay_orders
|
|
WHERE (? = -1 OR status = ?) AND (? = '' OR trade_no LIKE '%' || ? || '%' OR out_trade_no LIKE '%' || ? || '%')
|
|
`
|
|
|
|
type CountPayOrdersParams struct {
|
|
Column1 interface{}
|
|
Status int64
|
|
Column3 interface{}
|
|
Column4 sql.NullString
|
|
Column5 sql.NullString
|
|
}
|
|
|
|
func (q *Queries) CountPayOrders(ctx context.Context, arg CountPayOrdersParams) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countPayOrders,
|
|
arg.Column1,
|
|
arg.Status,
|
|
arg.Column3,
|
|
arg.Column4,
|
|
arg.Column5,
|
|
)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countProxies = `-- name: CountProxies :one
|
|
SELECT COUNT(*) FROM proxies WHERE alive = 1
|
|
`
|
|
|
|
func (q *Queries) CountProxies(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countProxies)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countProxiesAll = `-- name: CountProxiesAll :one
|
|
SELECT COUNT(*) FROM proxies
|
|
`
|
|
|
|
func (q *Queries) CountProxiesAll(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countProxiesAll)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countProxiesFiltered = `-- name: CountProxiesFiltered :one
|
|
SELECT COUNT(*) FROM proxies p WHERE (? = 0 OR p.region_id = ?) AND (? = '' OR p.protocols LIKE '%' || ? || '%')
|
|
AND (? = '' OR p.ip LIKE '%' || ? || '%') AND (? < 0 OR p.alive = ?)
|
|
`
|
|
|
|
type CountProxiesFilteredParams struct {
|
|
Column1 interface{}
|
|
RegionID int64
|
|
Column3 interface{}
|
|
Column4 sql.NullString
|
|
Column5 interface{}
|
|
Column6 sql.NullString
|
|
Column7 interface{}
|
|
Alive int64
|
|
}
|
|
|
|
func (q *Queries) CountProxiesFiltered(ctx context.Context, arg CountProxiesFilteredParams) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countProxiesFiltered,
|
|
arg.Column1,
|
|
arg.RegionID,
|
|
arg.Column3,
|
|
arg.Column4,
|
|
arg.Column5,
|
|
arg.Column6,
|
|
arg.Column7,
|
|
arg.Alive,
|
|
)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countServers = `-- name: CountServers :one
|
|
SELECT COUNT(*) FROM servers
|
|
`
|
|
|
|
func (q *Queries) CountServers(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countServers)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countTodayLogins = `-- name: CountTodayLogins :one
|
|
SELECT COUNT(*) FROM sessions
|
|
WHERE date(created_at, 'unixepoch', 'localtime') = date('now', 'localtime')
|
|
`
|
|
|
|
func (q *Queries) CountTodayLogins(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countTodayLogins)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countTools = `-- name: CountTools :one
|
|
SELECT COUNT(*) FROM tools WHERE enabled = 1
|
|
`
|
|
|
|
func (q *Queries) CountTools(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countTools)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countUsers = `-- name: CountUsers :one
|
|
SELECT COUNT(*) FROM users WHERE name LIKE '%' || ?1 || '%'
|
|
`
|
|
|
|
func (q *Queries) CountUsers(ctx context.Context, keyword sql.NullString) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countUsers, keyword)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const countVaultByUser = `-- name: CountVaultByUser :one
|
|
SELECT COUNT(*) FROM vault WHERE user_id = ?
|
|
`
|
|
|
|
func (q *Queries) CountVaultByUser(ctx context.Context, userID int64) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countVaultByUser, userID)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const createLicenseApp = `-- name: CreateLicenseApp :execlastid
|
|
INSERT INTO license_apps (appid, secret, name, created_at) VALUES (?, ?, ?, ?)
|
|
`
|
|
|
|
type CreateLicenseAppParams struct {
|
|
Appid string
|
|
Secret string
|
|
Name string
|
|
CreatedAt int64
|
|
}
|
|
|
|
func (q *Queries) CreateLicenseApp(ctx context.Context, arg CreateLicenseAppParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, createLicenseApp,
|
|
arg.Appid,
|
|
arg.Secret,
|
|
arg.Name,
|
|
arg.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const createLicenseCard = `-- name: CreateLicenseCard :exec
|
|
INSERT INTO license_cards (app_id, card, hours, created_at) VALUES (?, ?, ?, ?)
|
|
`
|
|
|
|
type CreateLicenseCardParams struct {
|
|
AppID int64
|
|
Card string
|
|
Hours int64
|
|
CreatedAt int64
|
|
}
|
|
|
|
func (q *Queries) CreateLicenseCard(ctx context.Context, arg CreateLicenseCardParams) error {
|
|
_, err := q.db.ExecContext(ctx, createLicenseCard,
|
|
arg.AppID,
|
|
arg.Card,
|
|
arg.Hours,
|
|
arg.CreatedAt,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const createPayOrder = `-- name: CreatePayOrder :execlastid
|
|
INSERT INTO pay_orders (trade_no, out_trade_no, channel, subject, money, fee, notify_url, return_url, client_ip, expired_at, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`
|
|
|
|
type CreatePayOrderParams struct {
|
|
TradeNo string
|
|
OutTradeNo string
|
|
Channel string
|
|
Subject string
|
|
Money int64
|
|
Fee int64
|
|
NotifyUrl string
|
|
ReturnUrl string
|
|
ClientIp string
|
|
ExpiredAt int64
|
|
CreatedAt int64
|
|
}
|
|
|
|
func (q *Queries) CreatePayOrder(ctx context.Context, arg CreatePayOrderParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, createPayOrder,
|
|
arg.TradeNo,
|
|
arg.OutTradeNo,
|
|
arg.Channel,
|
|
arg.Subject,
|
|
arg.Money,
|
|
arg.Fee,
|
|
arg.NotifyUrl,
|
|
arg.ReturnUrl,
|
|
arg.ClientIp,
|
|
arg.ExpiredAt,
|
|
arg.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const deleteBookmark = `-- name: DeleteBookmark :execrows
|
|
DELETE FROM bookmarks WHERE user_id = ? AND id = ?
|
|
`
|
|
|
|
type DeleteBookmarkParams struct {
|
|
UserID int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) DeleteBookmark(ctx context.Context, arg DeleteBookmarkParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteBookmark, arg.UserID, arg.ID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const deleteDbconn = `-- name: DeleteDbconn :execrows
|
|
DELETE FROM dbconns WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteDbconn(ctx context.Context, id int64) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteDbconn, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const deleteDeadProxies = `-- name: DeleteDeadProxies :execrows
|
|
DELETE FROM proxies WHERE alive = 0 AND last_checked_at < ?
|
|
`
|
|
|
|
func (q *Queries) DeleteDeadProxies(ctx context.Context, lastCheckedAt int64) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteDeadProxies, lastCheckedAt)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const deleteFile = `-- name: DeleteFile :execrows
|
|
DELETE FROM files WHERE id = ? AND user_id = ?
|
|
`
|
|
|
|
type DeleteFileParams struct {
|
|
ID int64
|
|
UserID int64
|
|
}
|
|
|
|
func (q *Queries) DeleteFile(ctx context.Context, arg DeleteFileParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteFile, arg.ID, arg.UserID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const deleteLicenseApp = `-- name: DeleteLicenseApp :exec
|
|
DELETE FROM license_apps WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteLicenseApp(ctx context.Context, id int64) error {
|
|
_, err := q.db.ExecContext(ctx, deleteLicenseApp, id)
|
|
return err
|
|
}
|
|
|
|
const deleteLicenseCard = `-- name: DeleteLicenseCard :exec
|
|
DELETE FROM license_cards WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteLicenseCard(ctx context.Context, id int64) error {
|
|
_, err := q.db.ExecContext(ctx, deleteLicenseCard, id)
|
|
return err
|
|
}
|
|
|
|
const deleteMemory = `-- name: DeleteMemory :execrows
|
|
DELETE FROM memories WHERE k = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteMemory(ctx context.Context, k string) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteMemory, k)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const deleteOtherSessions = `-- name: DeleteOtherSessions :exec
|
|
DELETE FROM sessions WHERE user_id = ? AND token != ?
|
|
`
|
|
|
|
type DeleteOtherSessionsParams struct {
|
|
UserID int64
|
|
Token string
|
|
}
|
|
|
|
func (q *Queries) DeleteOtherSessions(ctx context.Context, arg DeleteOtherSessionsParams) error {
|
|
_, err := q.db.ExecContext(ctx, deleteOtherSessions, arg.UserID, arg.Token)
|
|
return err
|
|
}
|
|
|
|
const deleteProxy = `-- name: DeleteProxy :exec
|
|
DELETE FROM proxies WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteProxy(ctx context.Context, id int64) error {
|
|
_, err := q.db.ExecContext(ctx, deleteProxy, id)
|
|
return err
|
|
}
|
|
|
|
const deleteProxyApiKey = `-- name: DeleteProxyApiKey :execrows
|
|
DELETE FROM proxy_keys WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteProxyApiKey(ctx context.Context, id int64) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteProxyApiKey, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const deleteServer = `-- name: DeleteServer :execrows
|
|
DELETE FROM servers WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteServer(ctx context.Context, id int64) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteServer, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const deleteSession = `-- name: DeleteSession :exec
|
|
DELETE FROM sessions WHERE token = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteSession(ctx context.Context, token string) error {
|
|
_, err := q.db.ExecContext(ctx, deleteSession, token)
|
|
return err
|
|
}
|
|
|
|
const deleteShare = `-- name: DeleteShare :execrows
|
|
DELETE FROM shares WHERE id = ? AND user_id = ?
|
|
`
|
|
|
|
type DeleteShareParams struct {
|
|
ID int64
|
|
UserID int64
|
|
}
|
|
|
|
func (q *Queries) DeleteShare(ctx context.Context, arg DeleteShareParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteShare, arg.ID, arg.UserID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const deleteSharesByFile = `-- name: DeleteSharesByFile :exec
|
|
DELETE FROM shares WHERE file_id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteSharesByFile(ctx context.Context, fileID int64) error {
|
|
_, err := q.db.ExecContext(ctx, deleteSharesByFile, fileID)
|
|
return err
|
|
}
|
|
|
|
const deleteTool = `-- name: DeleteTool :exec
|
|
DELETE FROM tools WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteTool(ctx context.Context, id int64) error {
|
|
_, err := q.db.ExecContext(ctx, deleteTool, id)
|
|
return err
|
|
}
|
|
|
|
const deleteUser = `-- name: DeleteUser :exec
|
|
DELETE FROM users WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) DeleteUser(ctx context.Context, id int64) error {
|
|
_, err := q.db.ExecContext(ctx, deleteUser, id)
|
|
return err
|
|
}
|
|
|
|
const deleteVault = `-- name: DeleteVault :execrows
|
|
DELETE FROM vault WHERE user_id = ? AND id = ?
|
|
`
|
|
|
|
type DeleteVaultParams struct {
|
|
UserID int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) DeleteVault(ctx context.Context, arg DeleteVaultParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteVault, arg.UserID, arg.ID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const finishProxySync = `-- name: FinishProxySync :exec
|
|
UPDATE proxy_syncs SET finished_at = ?, status = ?, total = ?, added = ?, removed = ?, updated = ?, detail = ?, error = ? WHERE id = ?
|
|
`
|
|
|
|
type FinishProxySyncParams struct {
|
|
FinishedAt int64
|
|
Status string
|
|
Total int64
|
|
Added int64
|
|
Removed int64
|
|
Updated int64
|
|
Detail string
|
|
Error string
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) FinishProxySync(ctx context.Context, arg FinishProxySyncParams) error {
|
|
_, err := q.db.ExecContext(ctx, finishProxySync,
|
|
arg.FinishedAt,
|
|
arg.Status,
|
|
arg.Total,
|
|
arg.Added,
|
|
arg.Removed,
|
|
arg.Updated,
|
|
arg.Detail,
|
|
arg.Error,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const getDbconn = `-- name: GetDbconn :one
|
|
SELECT id, name, engine, host, port, username, password_enc, "database", params, created_at, updated_at FROM dbconns WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) GetDbconn(ctx context.Context, id int64) (Dbconn, error) {
|
|
row := q.db.QueryRowContext(ctx, getDbconn, id)
|
|
var i Dbconn
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Engine,
|
|
&i.Host,
|
|
&i.Port,
|
|
&i.Username,
|
|
&i.PasswordEnc,
|
|
&i.Database,
|
|
&i.Params,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getFile = `-- name: GetFile :one
|
|
SELECT id, user_id, name, stored, size, mime, created_at FROM files WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) GetFile(ctx context.Context, id int64) (File, error) {
|
|
row := q.db.QueryRowContext(ctx, getFile, id)
|
|
var i File
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.Name,
|
|
&i.Stored,
|
|
&i.Size,
|
|
&i.Mime,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getLicenseAppByAppid = `-- name: GetLicenseAppByAppid :one
|
|
SELECT id, appid, secret, name, enabled, created_at FROM license_apps WHERE appid = ?
|
|
`
|
|
|
|
func (q *Queries) GetLicenseAppByAppid(ctx context.Context, appid string) (LicenseApp, error) {
|
|
row := q.db.QueryRowContext(ctx, getLicenseAppByAppid, appid)
|
|
var i LicenseApp
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Appid,
|
|
&i.Secret,
|
|
&i.Name,
|
|
&i.Enabled,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getLicenseCard = `-- name: GetLicenseCard :one
|
|
SELECT id, app_id, card, hours, domain, activated_at, expires_at, created_at FROM license_cards WHERE app_id = ? AND card = ?
|
|
`
|
|
|
|
type GetLicenseCardParams struct {
|
|
AppID int64
|
|
Card string
|
|
}
|
|
|
|
func (q *Queries) GetLicenseCard(ctx context.Context, arg GetLicenseCardParams) (LicenseCard, error) {
|
|
row := q.db.QueryRowContext(ctx, getLicenseCard, arg.AppID, arg.Card)
|
|
var i LicenseCard
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.AppID,
|
|
&i.Card,
|
|
&i.Hours,
|
|
&i.Domain,
|
|
&i.ActivatedAt,
|
|
&i.ExpiresAt,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getMemory = `-- name: GetMemory :one
|
|
SELECT k, content, project, tags, written_by, revision, created_at, updated_at FROM memories WHERE k = ?
|
|
`
|
|
|
|
func (q *Queries) GetMemory(ctx context.Context, k string) (Memory, error) {
|
|
row := q.db.QueryRowContext(ctx, getMemory, k)
|
|
var i Memory
|
|
err := row.Scan(
|
|
&i.K,
|
|
&i.Content,
|
|
&i.Project,
|
|
&i.Tags,
|
|
&i.WrittenBy,
|
|
&i.Revision,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getPayOrder = `-- name: GetPayOrder :one
|
|
SELECT id, trade_no, out_trade_no, channel, subject, money, fee, status, notify_url, return_url, client_ip, notified, notify_attempts, paid_at, expired_at, upstream_trade_no, goods_key, quantity, unit_price, payurl, qrcode, buyer_contact, query_pwd, cards, created_at FROM pay_orders WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) GetPayOrder(ctx context.Context, id int64) (PayOrder, error) {
|
|
row := q.db.QueryRowContext(ctx, getPayOrder, id)
|
|
var i PayOrder
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.TradeNo,
|
|
&i.OutTradeNo,
|
|
&i.Channel,
|
|
&i.Subject,
|
|
&i.Money,
|
|
&i.Fee,
|
|
&i.Status,
|
|
&i.NotifyUrl,
|
|
&i.ReturnUrl,
|
|
&i.ClientIp,
|
|
&i.Notified,
|
|
&i.NotifyAttempts,
|
|
&i.PaidAt,
|
|
&i.ExpiredAt,
|
|
&i.UpstreamTradeNo,
|
|
&i.GoodsKey,
|
|
&i.Quantity,
|
|
&i.UnitPrice,
|
|
&i.Payurl,
|
|
&i.Qrcode,
|
|
&i.BuyerContact,
|
|
&i.QueryPwd,
|
|
&i.Cards,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getPayOrderByOutNo = `-- name: GetPayOrderByOutNo :one
|
|
SELECT id, trade_no, out_trade_no, channel, subject, money, fee, status, notify_url, return_url, client_ip, notified, notify_attempts, paid_at, expired_at, upstream_trade_no, goods_key, quantity, unit_price, payurl, qrcode, buyer_contact, query_pwd, cards, created_at FROM pay_orders WHERE out_trade_no = ?
|
|
`
|
|
|
|
func (q *Queries) GetPayOrderByOutNo(ctx context.Context, outTradeNo string) (PayOrder, error) {
|
|
row := q.db.QueryRowContext(ctx, getPayOrderByOutNo, outTradeNo)
|
|
var i PayOrder
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.TradeNo,
|
|
&i.OutTradeNo,
|
|
&i.Channel,
|
|
&i.Subject,
|
|
&i.Money,
|
|
&i.Fee,
|
|
&i.Status,
|
|
&i.NotifyUrl,
|
|
&i.ReturnUrl,
|
|
&i.ClientIp,
|
|
&i.Notified,
|
|
&i.NotifyAttempts,
|
|
&i.PaidAt,
|
|
&i.ExpiredAt,
|
|
&i.UpstreamTradeNo,
|
|
&i.GoodsKey,
|
|
&i.Quantity,
|
|
&i.UnitPrice,
|
|
&i.Payurl,
|
|
&i.Qrcode,
|
|
&i.BuyerContact,
|
|
&i.QueryPwd,
|
|
&i.Cards,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getPayOrderByTradeNo = `-- name: GetPayOrderByTradeNo :one
|
|
SELECT id, trade_no, out_trade_no, channel, subject, money, fee, status, notify_url, return_url, client_ip, notified, notify_attempts, paid_at, expired_at, upstream_trade_no, goods_key, quantity, unit_price, payurl, qrcode, buyer_contact, query_pwd, cards, created_at FROM pay_orders WHERE trade_no = ?
|
|
`
|
|
|
|
func (q *Queries) GetPayOrderByTradeNo(ctx context.Context, tradeNo string) (PayOrder, error) {
|
|
row := q.db.QueryRowContext(ctx, getPayOrderByTradeNo, tradeNo)
|
|
var i PayOrder
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.TradeNo,
|
|
&i.OutTradeNo,
|
|
&i.Channel,
|
|
&i.Subject,
|
|
&i.Money,
|
|
&i.Fee,
|
|
&i.Status,
|
|
&i.NotifyUrl,
|
|
&i.ReturnUrl,
|
|
&i.ClientIp,
|
|
&i.Notified,
|
|
&i.NotifyAttempts,
|
|
&i.PaidAt,
|
|
&i.ExpiredAt,
|
|
&i.UpstreamTradeNo,
|
|
&i.GoodsKey,
|
|
&i.Quantity,
|
|
&i.UnitPrice,
|
|
&i.Payurl,
|
|
&i.Qrcode,
|
|
&i.BuyerContact,
|
|
&i.QueryPwd,
|
|
&i.Cards,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getProxyApiKey = `-- name: GetProxyApiKey :one
|
|
SELECT id, kkey, name, region_id, enabled, used_count, last_used_at, created_at FROM proxy_keys WHERE kkey = ? AND enabled = 1
|
|
`
|
|
|
|
func (q *Queries) GetProxyApiKey(ctx context.Context, kkey string) (ProxyKey, error) {
|
|
row := q.db.QueryRowContext(ctx, getProxyApiKey, kkey)
|
|
var i ProxyKey
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Kkey,
|
|
&i.Name,
|
|
&i.RegionID,
|
|
&i.Enabled,
|
|
&i.UsedCount,
|
|
&i.LastUsedAt,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getProxyRegionByCode = `-- name: GetProxyRegionByCode :one
|
|
SELECT id, code, name, zh_name, region, slug FROM proxy_regions WHERE code = ?
|
|
`
|
|
|
|
func (q *Queries) GetProxyRegionByCode(ctx context.Context, code string) (ProxyRegion, error) {
|
|
row := q.db.QueryRowContext(ctx, getProxyRegionByCode, code)
|
|
var i ProxyRegion
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Code,
|
|
&i.Name,
|
|
&i.ZhName,
|
|
&i.Region,
|
|
&i.Slug,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getServer = `-- name: GetServer :one
|
|
SELECT id, name, host, port, username, auth_type, secret_enc, note, created_at, updated_at FROM servers WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) GetServer(ctx context.Context, id int64) (Server, error) {
|
|
row := q.db.QueryRowContext(ctx, getServer, id)
|
|
var i Server
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Host,
|
|
&i.Port,
|
|
&i.Username,
|
|
&i.AuthType,
|
|
&i.SecretEnc,
|
|
&i.Note,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getSessionUser = `-- name: GetSessionUser :one
|
|
SELECT u.id, u.name, u.password_hash, u.role, u.status, u.created_at, u.updated_at, s.expires_at
|
|
FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.token = ?
|
|
`
|
|
|
|
type GetSessionUserRow struct {
|
|
ID int64
|
|
Name string
|
|
PasswordHash string
|
|
Role string
|
|
Status string
|
|
CreatedAt int64
|
|
UpdatedAt int64
|
|
ExpiresAt int64
|
|
}
|
|
|
|
func (q *Queries) GetSessionUser(ctx context.Context, token string) (GetSessionUserRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getSessionUser, token)
|
|
var i GetSessionUserRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.PasswordHash,
|
|
&i.Role,
|
|
&i.Status,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.ExpiresAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getSetting = `-- name: GetSetting :one
|
|
SELECT v FROM settings WHERE k = ?
|
|
`
|
|
|
|
func (q *Queries) GetSetting(ctx context.Context, k string) (string, error) {
|
|
row := q.db.QueryRowContext(ctx, getSetting, k)
|
|
var v string
|
|
err := row.Scan(&v)
|
|
return v, err
|
|
}
|
|
|
|
const getShareByCode = `-- name: GetShareByCode :one
|
|
SELECT sh.id, sh.code, sh.file_id, sh.user_id, sh.file_name, sh.expires_at, sh.downloads, sh.created_at,
|
|
f.name, f.stored, f.size, f.mime
|
|
FROM shares sh JOIN files f ON f.id = sh.file_id WHERE sh.code = ?
|
|
`
|
|
|
|
type GetShareByCodeRow struct {
|
|
ID int64
|
|
Code string
|
|
FileID int64
|
|
UserID int64
|
|
FileName string
|
|
ExpiresAt int64
|
|
Downloads int64
|
|
CreatedAt int64
|
|
Name string
|
|
Stored string
|
|
Size int64
|
|
Mime string
|
|
}
|
|
|
|
func (q *Queries) GetShareByCode(ctx context.Context, code string) (GetShareByCodeRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getShareByCode, code)
|
|
var i GetShareByCodeRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Code,
|
|
&i.FileID,
|
|
&i.UserID,
|
|
&i.FileName,
|
|
&i.ExpiresAt,
|
|
&i.Downloads,
|
|
&i.CreatedAt,
|
|
&i.Name,
|
|
&i.Stored,
|
|
&i.Size,
|
|
&i.Mime,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUserByID = `-- name: GetUserByID :one
|
|
SELECT id, name, password_hash, role, status, created_at, updated_at FROM users WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) GetUserByID(ctx context.Context, id int64) (User, error) {
|
|
row := q.db.QueryRowContext(ctx, getUserByID, id)
|
|
var i User
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.PasswordHash,
|
|
&i.Role,
|
|
&i.Status,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUserByName = `-- name: GetUserByName :one
|
|
SELECT id, name, password_hash, role, status, created_at, updated_at FROM users WHERE name = ? LIMIT 1
|
|
`
|
|
|
|
func (q *Queries) GetUserByName(ctx context.Context, name string) (User, error) {
|
|
row := q.db.QueryRowContext(ctx, getUserByName, name)
|
|
var i User
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.PasswordHash,
|
|
&i.Role,
|
|
&i.Status,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getVault = `-- name: GetVault :one
|
|
SELECT id, user_id, title, username, password_enc, url, note, totp_enc, created_at, updated_at FROM vault WHERE user_id = ? AND id = ?
|
|
`
|
|
|
|
type GetVaultParams struct {
|
|
UserID int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) GetVault(ctx context.Context, arg GetVaultParams) (Vault, error) {
|
|
row := q.db.QueryRowContext(ctx, getVault, arg.UserID, arg.ID)
|
|
var i Vault
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.Title,
|
|
&i.Username,
|
|
&i.PasswordEnc,
|
|
&i.Url,
|
|
&i.Note,
|
|
&i.TotpEnc,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const incPayNotifyAttempts = `-- name: IncPayNotifyAttempts :exec
|
|
UPDATE pay_orders SET notify_attempts = notify_attempts + 1 WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) IncPayNotifyAttempts(ctx context.Context, id int64) error {
|
|
_, err := q.db.ExecContext(ctx, incPayNotifyAttempts, id)
|
|
return err
|
|
}
|
|
|
|
const incShareDownloads = `-- name: IncShareDownloads :exec
|
|
UPDATE shares SET downloads = downloads + 1 WHERE code = ?
|
|
`
|
|
|
|
func (q *Queries) IncShareDownloads(ctx context.Context, code string) error {
|
|
_, err := q.db.ExecContext(ctx, incShareDownloads, code)
|
|
return err
|
|
}
|
|
|
|
const insertBookmark = `-- name: InsertBookmark :execlastid
|
|
INSERT INTO bookmarks(user_id, title, url, icon, sort, created_at) VALUES(?, ?, ?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertBookmarkParams struct {
|
|
UserID int64
|
|
Title string
|
|
Url string
|
|
Icon string
|
|
Sort int64
|
|
CreatedAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertBookmark(ctx context.Context, arg InsertBookmarkParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertBookmark,
|
|
arg.UserID,
|
|
arg.Title,
|
|
arg.Url,
|
|
arg.Icon,
|
|
arg.Sort,
|
|
arg.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertDbconn = `-- name: InsertDbconn :execlastid
|
|
INSERT INTO dbconns(name, engine, host, port, username, password_enc, database, params, created_at, updated_at)
|
|
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertDbconnParams struct {
|
|
Name string
|
|
Engine string
|
|
Host string
|
|
Port int64
|
|
Username string
|
|
PasswordEnc string
|
|
Database string
|
|
Params string
|
|
CreatedAt int64
|
|
UpdatedAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertDbconn(ctx context.Context, arg InsertDbconnParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertDbconn,
|
|
arg.Name,
|
|
arg.Engine,
|
|
arg.Host,
|
|
arg.Port,
|
|
arg.Username,
|
|
arg.PasswordEnc,
|
|
arg.Database,
|
|
arg.Params,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertFile = `-- name: InsertFile :execlastid
|
|
INSERT INTO files(user_id, name, stored, size, mime, created_at) VALUES(?, ?, ?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertFileParams struct {
|
|
UserID int64
|
|
Name string
|
|
Stored string
|
|
Size int64
|
|
Mime string
|
|
CreatedAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertFile(ctx context.Context, arg InsertFileParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertFile,
|
|
arg.UserID,
|
|
arg.Name,
|
|
arg.Stored,
|
|
arg.Size,
|
|
arg.Mime,
|
|
arg.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertProxy = `-- name: InsertProxy :execlastid
|
|
INSERT INTO proxies(ip, port, protocols, anonymity, source, region_id, latency, speed, uptime, alive, last_seen_at, created_at)
|
|
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
|
|
`
|
|
|
|
type InsertProxyParams struct {
|
|
Ip string
|
|
Port int64
|
|
Protocols string
|
|
Anonymity string
|
|
Source string
|
|
RegionID int64
|
|
Latency int64
|
|
Speed int64
|
|
Uptime int64
|
|
LastSeenAt int64
|
|
CreatedAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertProxy(ctx context.Context, arg InsertProxyParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertProxy,
|
|
arg.Ip,
|
|
arg.Port,
|
|
arg.Protocols,
|
|
arg.Anonymity,
|
|
arg.Source,
|
|
arg.RegionID,
|
|
arg.Latency,
|
|
arg.Speed,
|
|
arg.Uptime,
|
|
arg.LastSeenAt,
|
|
arg.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertProxyApiKey = `-- name: InsertProxyApiKey :execlastid
|
|
INSERT INTO proxy_keys(kkey, name, region_id, created_at) VALUES(?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertProxyApiKeyParams struct {
|
|
Kkey string
|
|
Name string
|
|
RegionID int64
|
|
CreatedAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertProxyApiKey(ctx context.Context, arg InsertProxyApiKeyParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertProxyApiKey,
|
|
arg.Kkey,
|
|
arg.Name,
|
|
arg.RegionID,
|
|
arg.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertProxySync = `-- name: InsertProxySync :execlastid
|
|
INSERT INTO proxy_syncs(started_at, source) VALUES(?, ?)
|
|
`
|
|
|
|
type InsertProxySyncParams struct {
|
|
StartedAt int64
|
|
Source string
|
|
}
|
|
|
|
func (q *Queries) InsertProxySync(ctx context.Context, arg InsertProxySyncParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertProxySync, arg.StartedAt, arg.Source)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertServer = `-- name: InsertServer :execlastid
|
|
INSERT INTO servers(name, host, port, username, auth_type, secret_enc, note, created_at, updated_at)
|
|
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertServerParams struct {
|
|
Name string
|
|
Host string
|
|
Port int64
|
|
Username string
|
|
AuthType string
|
|
SecretEnc string
|
|
Note string
|
|
CreatedAt int64
|
|
UpdatedAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertServer(ctx context.Context, arg InsertServerParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertServer,
|
|
arg.Name,
|
|
arg.Host,
|
|
arg.Port,
|
|
arg.Username,
|
|
arg.AuthType,
|
|
arg.SecretEnc,
|
|
arg.Note,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertSession = `-- name: InsertSession :exec
|
|
INSERT INTO sessions(token, user_id, created_at, expires_at) VALUES(?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertSessionParams struct {
|
|
Token string
|
|
UserID int64
|
|
CreatedAt int64
|
|
ExpiresAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertSession(ctx context.Context, arg InsertSessionParams) error {
|
|
_, err := q.db.ExecContext(ctx, insertSession,
|
|
arg.Token,
|
|
arg.UserID,
|
|
arg.CreatedAt,
|
|
arg.ExpiresAt,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertShare = `-- name: InsertShare :execlastid
|
|
INSERT INTO shares(code, file_id, user_id, file_name, expires_at, created_at) VALUES(?, ?, ?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertShareParams struct {
|
|
Code string
|
|
FileID int64
|
|
UserID int64
|
|
FileName string
|
|
ExpiresAt int64
|
|
CreatedAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertShare(ctx context.Context, arg InsertShareParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertShare,
|
|
arg.Code,
|
|
arg.FileID,
|
|
arg.UserID,
|
|
arg.FileName,
|
|
arg.ExpiresAt,
|
|
arg.CreatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertTool = `-- name: InsertTool :execlastid
|
|
INSERT INTO tools(name, icon, url, description, sort, enabled) VALUES(?, ?, ?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertToolParams struct {
|
|
Name string
|
|
Icon string
|
|
Url string
|
|
Description string
|
|
Sort int64
|
|
Enabled bool
|
|
}
|
|
|
|
func (q *Queries) InsertTool(ctx context.Context, arg InsertToolParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertTool,
|
|
arg.Name,
|
|
arg.Icon,
|
|
arg.Url,
|
|
arg.Description,
|
|
arg.Sort,
|
|
arg.Enabled,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertUser = `-- name: InsertUser :execlastid
|
|
INSERT INTO users(name, password_hash, role, status, created_at, updated_at)
|
|
VALUES(?, ?, ?, 'active', ?, ?)
|
|
`
|
|
|
|
type InsertUserParams struct {
|
|
Name string
|
|
PasswordHash string
|
|
Role string
|
|
CreatedAt int64
|
|
UpdatedAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertUser(ctx context.Context, arg InsertUserParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertUser,
|
|
arg.Name,
|
|
arg.PasswordHash,
|
|
arg.Role,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const insertVault = `-- name: InsertVault :execlastid
|
|
INSERT INTO vault(user_id, title, username, password_enc, url, note, totp_enc, created_at, updated_at)
|
|
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
`
|
|
|
|
type InsertVaultParams struct {
|
|
UserID int64
|
|
Title string
|
|
Username string
|
|
PasswordEnc string
|
|
Url string
|
|
Note string
|
|
TotpEnc string
|
|
CreatedAt int64
|
|
UpdatedAt int64
|
|
}
|
|
|
|
func (q *Queries) InsertVault(ctx context.Context, arg InsertVaultParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, insertVault,
|
|
arg.UserID,
|
|
arg.Title,
|
|
arg.Username,
|
|
arg.PasswordEnc,
|
|
arg.Url,
|
|
arg.Note,
|
|
arg.TotpEnc,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const lastProxyCheckAt = `-- name: LastProxyCheckAt :one
|
|
SELECT COALESCE(MAX(last_checked_at), 0) FROM proxies
|
|
`
|
|
|
|
func (q *Queries) LastProxyCheckAt(ctx context.Context) (interface{}, error) {
|
|
row := q.db.QueryRowContext(ctx, lastProxyCheckAt)
|
|
var coalesce interface{}
|
|
err := row.Scan(&coalesce)
|
|
return coalesce, err
|
|
}
|
|
|
|
const licenseCardStats = `-- name: LicenseCardStats :one
|
|
SELECT COUNT(*) AS total,
|
|
COALESCE(SUM(CASE WHEN activated_at = 0 THEN 1 ELSE 0 END), 0) AS unused,
|
|
COALESCE(SUM(CASE WHEN activated_at > 0 AND (expires_at = 0 OR expires_at > ?) THEN 1 ELSE 0 END), 0) AS active,
|
|
COALESCE(SUM(CASE WHEN activated_at > 0 AND expires_at > 0 AND expires_at <= ? THEN 1 ELSE 0 END), 0) AS expired
|
|
FROM license_cards WHERE app_id = ?
|
|
`
|
|
|
|
type LicenseCardStatsParams struct {
|
|
ExpiresAt int64
|
|
ExpiresAt_2 int64
|
|
AppID int64
|
|
}
|
|
|
|
type LicenseCardStatsRow struct {
|
|
Total int64
|
|
Unused interface{}
|
|
Active interface{}
|
|
Expired interface{}
|
|
}
|
|
|
|
func (q *Queries) LicenseCardStats(ctx context.Context, arg LicenseCardStatsParams) (LicenseCardStatsRow, error) {
|
|
row := q.db.QueryRowContext(ctx, licenseCardStats, arg.ExpiresAt, arg.ExpiresAt_2, arg.AppID)
|
|
var i LicenseCardStatsRow
|
|
err := row.Scan(
|
|
&i.Total,
|
|
&i.Unused,
|
|
&i.Active,
|
|
&i.Expired,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const licenseCardStatsAll = `-- name: LicenseCardStatsAll :one
|
|
SELECT COUNT(*) AS total,
|
|
COALESCE(SUM(CASE WHEN activated_at = 0 THEN 1 ELSE 0 END), 0) AS unused,
|
|
COALESCE(SUM(CASE WHEN activated_at > 0 AND (expires_at = 0 OR expires_at > ?) THEN 1 ELSE 0 END), 0) AS active
|
|
FROM license_cards
|
|
`
|
|
|
|
type LicenseCardStatsAllRow struct {
|
|
Total int64
|
|
Unused interface{}
|
|
Active interface{}
|
|
}
|
|
|
|
func (q *Queries) LicenseCardStatsAll(ctx context.Context, expiresAt int64) (LicenseCardStatsAllRow, error) {
|
|
row := q.db.QueryRowContext(ctx, licenseCardStatsAll, expiresAt)
|
|
var i LicenseCardStatsAllRow
|
|
err := row.Scan(&i.Total, &i.Unused, &i.Active)
|
|
return i, err
|
|
}
|
|
|
|
const listBookmarks = `-- name: ListBookmarks :many
|
|
SELECT id, user_id, title, url, icon, sort, created_at FROM bookmarks WHERE user_id = ? ORDER BY sort, id
|
|
`
|
|
|
|
func (q *Queries) ListBookmarks(ctx context.Context, userID int64) ([]Bookmark, error) {
|
|
rows, err := q.db.QueryContext(ctx, listBookmarks, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Bookmark{}
|
|
for rows.Next() {
|
|
var i Bookmark
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.Title,
|
|
&i.Url,
|
|
&i.Icon,
|
|
&i.Sort,
|
|
&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 listDbconns = `-- name: ListDbconns :many
|
|
SELECT id, name, engine, host, port, username, password_enc, "database", params, created_at, updated_at FROM dbconns ORDER BY id
|
|
`
|
|
|
|
func (q *Queries) ListDbconns(ctx context.Context) ([]Dbconn, error) {
|
|
rows, err := q.db.QueryContext(ctx, listDbconns)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Dbconn{}
|
|
for rows.Next() {
|
|
var i Dbconn
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Engine,
|
|
&i.Host,
|
|
&i.Port,
|
|
&i.Username,
|
|
&i.PasswordEnc,
|
|
&i.Database,
|
|
&i.Params,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); 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 listEnabledTools = `-- name: ListEnabledTools :many
|
|
SELECT id, name, icon, url, description, sort, enabled FROM tools WHERE enabled = 1 ORDER BY sort, id
|
|
`
|
|
|
|
func (q *Queries) ListEnabledTools(ctx context.Context) ([]Tool, error) {
|
|
rows, err := q.db.QueryContext(ctx, listEnabledTools)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Tool{}
|
|
for rows.Next() {
|
|
var i Tool
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Icon,
|
|
&i.Url,
|
|
&i.Description,
|
|
&i.Sort,
|
|
&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 listFiles = `-- name: ListFiles :many
|
|
SELECT id, user_id, name, stored, size, mime, created_at FROM files WHERE user_id = ? ORDER BY id DESC
|
|
`
|
|
|
|
func (q *Queries) ListFiles(ctx context.Context, userID int64) ([]File, error) {
|
|
rows, err := q.db.QueryContext(ctx, listFiles, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []File{}
|
|
for rows.Next() {
|
|
var i File
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.Name,
|
|
&i.Stored,
|
|
&i.Size,
|
|
&i.Mime,
|
|
&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 listLicenseApps = `-- name: ListLicenseApps :many
|
|
SELECT a.id, a.appid, a.secret, a.name, a.enabled, a.created_at, (SELECT COUNT(*) FROM license_cards c WHERE c.app_id = a.id) AS card_count
|
|
FROM license_apps a ORDER BY a.id DESC
|
|
`
|
|
|
|
type ListLicenseAppsRow struct {
|
|
ID int64
|
|
Appid string
|
|
Secret string
|
|
Name string
|
|
Enabled int64
|
|
CreatedAt int64
|
|
CardCount int64
|
|
}
|
|
|
|
func (q *Queries) ListLicenseApps(ctx context.Context) ([]ListLicenseAppsRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, listLicenseApps)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListLicenseAppsRow{}
|
|
for rows.Next() {
|
|
var i ListLicenseAppsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Appid,
|
|
&i.Secret,
|
|
&i.Name,
|
|
&i.Enabled,
|
|
&i.CreatedAt,
|
|
&i.CardCount,
|
|
); 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 listLicenseCards = `-- name: ListLicenseCards :many
|
|
SELECT id, app_id, card, hours, domain, activated_at, expires_at, created_at FROM license_cards
|
|
WHERE app_id = ? AND (? = '' OR card LIKE '%' || ? || '%' OR domain LIKE '%' || ? || '%')
|
|
ORDER BY id DESC LIMIT ? OFFSET ?
|
|
`
|
|
|
|
type ListLicenseCardsParams struct {
|
|
AppID int64
|
|
Column2 interface{}
|
|
Column3 sql.NullString
|
|
Column4 sql.NullString
|
|
Limit int64
|
|
Offset int64
|
|
}
|
|
|
|
func (q *Queries) ListLicenseCards(ctx context.Context, arg ListLicenseCardsParams) ([]LicenseCard, error) {
|
|
rows, err := q.db.QueryContext(ctx, listLicenseCards,
|
|
arg.AppID,
|
|
arg.Column2,
|
|
arg.Column3,
|
|
arg.Column4,
|
|
arg.Limit,
|
|
arg.Offset,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []LicenseCard{}
|
|
for rows.Next() {
|
|
var i LicenseCard
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.AppID,
|
|
&i.Card,
|
|
&i.Hours,
|
|
&i.Domain,
|
|
&i.ActivatedAt,
|
|
&i.ExpiresAt,
|
|
&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 listMemories = `-- name: ListMemories :many
|
|
SELECT k, content, project, tags, written_by, revision, created_at, updated_at FROM memories
|
|
WHERE (? = '' OR project = ?) AND (? = '' OR tags LIKE '%"' || ? || '"%')
|
|
ORDER BY updated_at DESC LIMIT ?
|
|
`
|
|
|
|
type ListMemoriesParams struct {
|
|
Column1 interface{}
|
|
Project string
|
|
Column3 interface{}
|
|
Column4 sql.NullString
|
|
Limit int64
|
|
}
|
|
|
|
func (q *Queries) ListMemories(ctx context.Context, arg ListMemoriesParams) ([]Memory, error) {
|
|
rows, err := q.db.QueryContext(ctx, listMemories,
|
|
arg.Column1,
|
|
arg.Project,
|
|
arg.Column3,
|
|
arg.Column4,
|
|
arg.Limit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Memory{}
|
|
for rows.Next() {
|
|
var i Memory
|
|
if err := rows.Scan(
|
|
&i.K,
|
|
&i.Content,
|
|
&i.Project,
|
|
&i.Tags,
|
|
&i.WrittenBy,
|
|
&i.Revision,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); 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 listPayOrders = `-- name: ListPayOrders :many
|
|
SELECT id, trade_no, out_trade_no, channel, subject, money, fee, status, notify_url, return_url, client_ip, notified, notify_attempts, paid_at, expired_at, upstream_trade_no, goods_key, quantity, unit_price, payurl, qrcode, buyer_contact, query_pwd, cards, created_at FROM pay_orders
|
|
WHERE (? = -1 OR status = ?) AND (? = '' OR trade_no LIKE '%' || ? || '%' OR out_trade_no LIKE '%' || ? || '%')
|
|
ORDER BY id DESC LIMIT ? OFFSET ?
|
|
`
|
|
|
|
type ListPayOrdersParams struct {
|
|
Column1 interface{}
|
|
Status int64
|
|
Column3 interface{}
|
|
Column4 sql.NullString
|
|
Column5 sql.NullString
|
|
Limit int64
|
|
Offset int64
|
|
}
|
|
|
|
func (q *Queries) ListPayOrders(ctx context.Context, arg ListPayOrdersParams) ([]PayOrder, error) {
|
|
rows, err := q.db.QueryContext(ctx, listPayOrders,
|
|
arg.Column1,
|
|
arg.Status,
|
|
arg.Column3,
|
|
arg.Column4,
|
|
arg.Column5,
|
|
arg.Limit,
|
|
arg.Offset,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []PayOrder{}
|
|
for rows.Next() {
|
|
var i PayOrder
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.TradeNo,
|
|
&i.OutTradeNo,
|
|
&i.Channel,
|
|
&i.Subject,
|
|
&i.Money,
|
|
&i.Fee,
|
|
&i.Status,
|
|
&i.NotifyUrl,
|
|
&i.ReturnUrl,
|
|
&i.ClientIp,
|
|
&i.Notified,
|
|
&i.NotifyAttempts,
|
|
&i.PaidAt,
|
|
&i.ExpiredAt,
|
|
&i.UpstreamTradeNo,
|
|
&i.GoodsKey,
|
|
&i.Quantity,
|
|
&i.UnitPrice,
|
|
&i.Payurl,
|
|
&i.Qrcode,
|
|
&i.BuyerContact,
|
|
&i.QueryPwd,
|
|
&i.Cards,
|
|
&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 listPendingPayOrders = `-- name: ListPendingPayOrders :many
|
|
SELECT id, trade_no, out_trade_no, channel, subject, money, fee, status, notify_url, return_url, client_ip, notified, notify_attempts, paid_at, expired_at, upstream_trade_no, goods_key, quantity, unit_price, payurl, qrcode, buyer_contact, query_pwd, cards, created_at FROM pay_orders WHERE status = 0 AND upstream_trade_no != '' ORDER BY id LIMIT 200
|
|
`
|
|
|
|
func (q *Queries) ListPendingPayOrders(ctx context.Context) ([]PayOrder, error) {
|
|
rows, err := q.db.QueryContext(ctx, listPendingPayOrders)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []PayOrder{}
|
|
for rows.Next() {
|
|
var i PayOrder
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.TradeNo,
|
|
&i.OutTradeNo,
|
|
&i.Channel,
|
|
&i.Subject,
|
|
&i.Money,
|
|
&i.Fee,
|
|
&i.Status,
|
|
&i.NotifyUrl,
|
|
&i.ReturnUrl,
|
|
&i.ClientIp,
|
|
&i.Notified,
|
|
&i.NotifyAttempts,
|
|
&i.PaidAt,
|
|
&i.ExpiredAt,
|
|
&i.UpstreamTradeNo,
|
|
&i.GoodsKey,
|
|
&i.Quantity,
|
|
&i.UnitPrice,
|
|
&i.Payurl,
|
|
&i.Qrcode,
|
|
&i.BuyerContact,
|
|
&i.QueryPwd,
|
|
&i.Cards,
|
|
&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 listProxiesDue = `-- name: ListProxiesDue :many
|
|
SELECT id, ip, port, protocols, fail_count FROM proxies WHERE alive = 1 AND last_checked_at < ? ORDER BY last_checked_at LIMIT 20000
|
|
`
|
|
|
|
type ListProxiesDueRow struct {
|
|
ID int64
|
|
Ip string
|
|
Port int64
|
|
Protocols string
|
|
FailCount int64
|
|
}
|
|
|
|
func (q *Queries) ListProxiesDue(ctx context.Context, lastCheckedAt int64) ([]ListProxiesDueRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, listProxiesDue, lastCheckedAt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListProxiesDueRow{}
|
|
for rows.Next() {
|
|
var i ListProxiesDueRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Ip,
|
|
&i.Port,
|
|
&i.Protocols,
|
|
&i.FailCount,
|
|
); 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 listProxiesFiltered = `-- name: ListProxiesFiltered :many
|
|
SELECT p.id, p.ip, p.port, p.protocols, p.anonymity, p.source, p.region_id, p.latency, p.speed, p.uptime, p.alive, p.fail_count, p.last_checked_at, p.last_alive_at, p.last_seen_at, p.created_at, r.code AS region_code, r.name AS region_name, r.zh_name AS region_zh_name
|
|
FROM proxies p JOIN proxy_regions r ON r.id = p.region_id
|
|
WHERE (? = 0 OR p.region_id = ?) AND (? = '' OR p.protocols LIKE '%' || ? || '%')
|
|
AND (? = '' OR p.ip LIKE '%' || ? || '%') AND (? < 0 OR p.alive = ?)
|
|
ORDER BY p.alive DESC, p.latency LIMIT ? OFFSET ?
|
|
`
|
|
|
|
type ListProxiesFilteredParams struct {
|
|
Column1 interface{}
|
|
RegionID int64
|
|
Column3 interface{}
|
|
Column4 sql.NullString
|
|
Column5 interface{}
|
|
Column6 sql.NullString
|
|
Column7 interface{}
|
|
Alive int64
|
|
Limit int64
|
|
Offset int64
|
|
}
|
|
|
|
type ListProxiesFilteredRow struct {
|
|
ID int64
|
|
Ip string
|
|
Port int64
|
|
Protocols string
|
|
Anonymity string
|
|
Source string
|
|
RegionID int64
|
|
Latency int64
|
|
Speed int64
|
|
Uptime int64
|
|
Alive int64
|
|
FailCount int64
|
|
LastCheckedAt int64
|
|
LastAliveAt int64
|
|
LastSeenAt int64
|
|
CreatedAt int64
|
|
RegionCode string
|
|
RegionName string
|
|
RegionZhName string
|
|
}
|
|
|
|
func (q *Queries) ListProxiesFiltered(ctx context.Context, arg ListProxiesFilteredParams) ([]ListProxiesFilteredRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, listProxiesFiltered,
|
|
arg.Column1,
|
|
arg.RegionID,
|
|
arg.Column3,
|
|
arg.Column4,
|
|
arg.Column5,
|
|
arg.Column6,
|
|
arg.Column7,
|
|
arg.Alive,
|
|
arg.Limit,
|
|
arg.Offset,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListProxiesFilteredRow{}
|
|
for rows.Next() {
|
|
var i ListProxiesFilteredRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Ip,
|
|
&i.Port,
|
|
&i.Protocols,
|
|
&i.Anonymity,
|
|
&i.Source,
|
|
&i.RegionID,
|
|
&i.Latency,
|
|
&i.Speed,
|
|
&i.Uptime,
|
|
&i.Alive,
|
|
&i.FailCount,
|
|
&i.LastCheckedAt,
|
|
&i.LastAliveAt,
|
|
&i.LastSeenAt,
|
|
&i.CreatedAt,
|
|
&i.RegionCode,
|
|
&i.RegionName,
|
|
&i.RegionZhName,
|
|
); 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 listProxyApiKeys = `-- name: ListProxyApiKeys :many
|
|
SELECT k.id, k.kkey, k.name, k.region_id, k.enabled, k.used_count, k.last_used_at, k.created_at, r.code AS region_code, r.zh_name AS region_zh_name, r.name AS region_name
|
|
FROM proxy_keys k LEFT JOIN proxy_regions r ON r.id = k.region_id
|
|
ORDER BY k.id DESC
|
|
`
|
|
|
|
type ListProxyApiKeysRow struct {
|
|
ID int64
|
|
Kkey string
|
|
Name string
|
|
RegionID int64
|
|
Enabled int64
|
|
UsedCount int64
|
|
LastUsedAt int64
|
|
CreatedAt int64
|
|
RegionCode sql.NullString
|
|
RegionZhName sql.NullString
|
|
RegionName sql.NullString
|
|
}
|
|
|
|
func (q *Queries) ListProxyApiKeys(ctx context.Context) ([]ListProxyApiKeysRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, listProxyApiKeys)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListProxyApiKeysRow{}
|
|
for rows.Next() {
|
|
var i ListProxyApiKeysRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Kkey,
|
|
&i.Name,
|
|
&i.RegionID,
|
|
&i.Enabled,
|
|
&i.UsedCount,
|
|
&i.LastUsedAt,
|
|
&i.CreatedAt,
|
|
&i.RegionCode,
|
|
&i.RegionZhName,
|
|
&i.RegionName,
|
|
); 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 listProxyKeys = `-- name: ListProxyKeys :many
|
|
SELECT id, ip, port, source FROM proxies
|
|
`
|
|
|
|
type ListProxyKeysRow struct {
|
|
ID int64
|
|
Ip string
|
|
Port int64
|
|
Source string
|
|
}
|
|
|
|
func (q *Queries) ListProxyKeys(ctx context.Context) ([]ListProxyKeysRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, listProxyKeys)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListProxyKeysRow{}
|
|
for rows.Next() {
|
|
var i ListProxyKeysRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Ip,
|
|
&i.Port,
|
|
&i.Source,
|
|
); 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 listProxyRegions = `-- name: ListProxyRegions :many
|
|
SELECT r.id, r.code, r.name, r.zh_name, r.region, r.slug, (SELECT COUNT(*) FROM proxies p WHERE p.region_id = r.id AND p.alive = 1) AS alive_count
|
|
FROM proxy_regions r ORDER BY alive_count DESC, r.code
|
|
`
|
|
|
|
type ListProxyRegionsRow struct {
|
|
ID int64
|
|
Code string
|
|
Name string
|
|
ZhName string
|
|
Region string
|
|
Slug string
|
|
AliveCount int64
|
|
}
|
|
|
|
func (q *Queries) ListProxyRegions(ctx context.Context) ([]ListProxyRegionsRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, listProxyRegions)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ListProxyRegionsRow{}
|
|
for rows.Next() {
|
|
var i ListProxyRegionsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Code,
|
|
&i.Name,
|
|
&i.ZhName,
|
|
&i.Region,
|
|
&i.Slug,
|
|
&i.AliveCount,
|
|
); 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 listProxySyncs = `-- name: ListProxySyncs :many
|
|
SELECT id, started_at, finished_at, status, source, total, added, removed, updated, detail, error FROM proxy_syncs ORDER BY id DESC LIMIT ?
|
|
`
|
|
|
|
func (q *Queries) ListProxySyncs(ctx context.Context, limit int64) ([]ProxySync, error) {
|
|
rows, err := q.db.QueryContext(ctx, listProxySyncs, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []ProxySync{}
|
|
for rows.Next() {
|
|
var i ProxySync
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.StartedAt,
|
|
&i.FinishedAt,
|
|
&i.Status,
|
|
&i.Source,
|
|
&i.Total,
|
|
&i.Added,
|
|
&i.Removed,
|
|
&i.Updated,
|
|
&i.Detail,
|
|
&i.Error,
|
|
); 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 listServers = `-- name: ListServers :many
|
|
SELECT id, name, host, port, username, auth_type, secret_enc, note, created_at, updated_at FROM servers ORDER BY id
|
|
`
|
|
|
|
func (q *Queries) ListServers(ctx context.Context) ([]Server, error) {
|
|
rows, err := q.db.QueryContext(ctx, listServers)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Server{}
|
|
for rows.Next() {
|
|
var i Server
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Host,
|
|
&i.Port,
|
|
&i.Username,
|
|
&i.AuthType,
|
|
&i.SecretEnc,
|
|
&i.Note,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); 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 listShares = `-- name: ListShares :many
|
|
SELECT id, code, file_id, user_id, file_name, expires_at, downloads, created_at FROM shares WHERE user_id = ? ORDER BY id DESC
|
|
`
|
|
|
|
func (q *Queries) ListShares(ctx context.Context, userID int64) ([]Share, error) {
|
|
rows, err := q.db.QueryContext(ctx, listShares, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Share{}
|
|
for rows.Next() {
|
|
var i Share
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Code,
|
|
&i.FileID,
|
|
&i.UserID,
|
|
&i.FileName,
|
|
&i.ExpiresAt,
|
|
&i.Downloads,
|
|
&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 listTools = `-- name: ListTools :many
|
|
SELECT id, name, icon, url, description, sort, enabled FROM tools ORDER BY sort, id
|
|
`
|
|
|
|
func (q *Queries) ListTools(ctx context.Context) ([]Tool, error) {
|
|
rows, err := q.db.QueryContext(ctx, listTools)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Tool{}
|
|
for rows.Next() {
|
|
var i Tool
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Icon,
|
|
&i.Url,
|
|
&i.Description,
|
|
&i.Sort,
|
|
&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 listUsers = `-- name: ListUsers :many
|
|
SELECT id, name, password_hash, role, status, created_at, updated_at FROM users
|
|
WHERE name LIKE '%' || ?3 || '%'
|
|
ORDER BY id LIMIT ? OFFSET ?
|
|
`
|
|
|
|
type ListUsersParams struct {
|
|
Keyword sql.NullString
|
|
Limit int64
|
|
Offset int64
|
|
}
|
|
|
|
func (q *Queries) ListUsers(ctx context.Context, arg ListUsersParams) ([]User, error) {
|
|
rows, err := q.db.QueryContext(ctx, listUsers, arg.Keyword, arg.Limit, arg.Offset)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []User{}
|
|
for rows.Next() {
|
|
var i User
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.PasswordHash,
|
|
&i.Role,
|
|
&i.Status,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); 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 listVault = `-- name: ListVault :many
|
|
SELECT id, user_id, title, username, password_enc, url, note, totp_enc, created_at, updated_at FROM vault WHERE user_id = ?
|
|
AND (title LIKE '%' || ?2 || '%'
|
|
OR username LIKE '%' || ?2 || '%'
|
|
OR url LIKE '%' || ?2 || '%')
|
|
ORDER BY updated_at DESC
|
|
`
|
|
|
|
type ListVaultParams struct {
|
|
UserID int64
|
|
Keyword sql.NullString
|
|
}
|
|
|
|
func (q *Queries) ListVault(ctx context.Context, arg ListVaultParams) ([]Vault, error) {
|
|
rows, err := q.db.QueryContext(ctx, listVault, arg.UserID, arg.Keyword)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []Vault{}
|
|
for rows.Next() {
|
|
var i Vault
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.Title,
|
|
&i.Username,
|
|
&i.PasswordEnc,
|
|
&i.Url,
|
|
&i.Note,
|
|
&i.TotpEnc,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
); 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 loginTrend = `-- name: LoginTrend :many
|
|
SELECT date(created_at, 'unixepoch', 'localtime') AS d, COUNT(*) AS c
|
|
FROM sessions WHERE created_at >= ? GROUP BY d
|
|
`
|
|
|
|
type LoginTrendRow struct {
|
|
D interface{}
|
|
C int64
|
|
}
|
|
|
|
func (q *Queries) LoginTrend(ctx context.Context, createdAt int64) ([]LoginTrendRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, loginTrend, createdAt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []LoginTrendRow{}
|
|
for rows.Next() {
|
|
var i LoginTrendRow
|
|
if err := rows.Scan(&i.D, &i.C); 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 markProxyAlive = `-- name: MarkProxyAlive :exec
|
|
UPDATE proxies SET last_checked_at = ?, alive = 1, fail_count = 0, last_alive_at = ?, latency = ? WHERE id = ?
|
|
`
|
|
|
|
type MarkProxyAliveParams struct {
|
|
LastCheckedAt int64
|
|
LastAliveAt int64
|
|
Latency int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) MarkProxyAlive(ctx context.Context, arg MarkProxyAliveParams) error {
|
|
_, err := q.db.ExecContext(ctx, markProxyAlive,
|
|
arg.LastCheckedAt,
|
|
arg.LastAliveAt,
|
|
arg.Latency,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const markProxyFailed = `-- name: MarkProxyFailed :exec
|
|
UPDATE proxies SET last_checked_at = ?, alive = 0, fail_count = ? WHERE id = ?
|
|
`
|
|
|
|
type MarkProxyFailedParams struct {
|
|
LastCheckedAt int64
|
|
FailCount int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) MarkProxyFailed(ctx context.Context, arg MarkProxyFailedParams) error {
|
|
_, err := q.db.ExecContext(ctx, markProxyFailed, arg.LastCheckedAt, arg.FailCount, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const memoryProjects = `-- name: MemoryProjects :many
|
|
SELECT project AS name, COUNT(*) AS cnt FROM memories
|
|
WHERE project != '' GROUP BY project ORDER BY MAX(updated_at) DESC
|
|
`
|
|
|
|
type MemoryProjectsRow struct {
|
|
Name string
|
|
Cnt int64
|
|
}
|
|
|
|
func (q *Queries) MemoryProjects(ctx context.Context) ([]MemoryProjectsRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, memoryProjects)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []MemoryProjectsRow{}
|
|
for rows.Next() {
|
|
var i MemoryProjectsRow
|
|
if err := rows.Scan(&i.Name, &i.Cnt); 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 payDailyPaid = `-- name: PayDailyPaid :many
|
|
SELECT CAST(strftime('%Y-%m-%d', paid_at, 'unixepoch', 'localtime') AS TEXT) AS day,
|
|
COALESCE(SUM(money), 0) AS money, COUNT(*) AS cnt
|
|
FROM pay_orders WHERE status = 1 AND paid_at >= ? GROUP BY day
|
|
`
|
|
|
|
type PayDailyPaidRow struct {
|
|
Day string
|
|
Money interface{}
|
|
Cnt int64
|
|
}
|
|
|
|
func (q *Queries) PayDailyPaid(ctx context.Context, paidAt int64) ([]PayDailyPaidRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, payDailyPaid, paidAt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []PayDailyPaidRow{}
|
|
for rows.Next() {
|
|
var i PayDailyPaidRow
|
|
if err := rows.Scan(&i.Day, &i.Money, &i.Cnt); 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 payOrderStats = `-- name: PayOrderStats :one
|
|
SELECT COUNT(*) AS cnt, COALESCE(SUM(CASE WHEN status = 1 THEN money ELSE 0 END), 0) AS money,
|
|
COALESCE(SUM(CASE WHEN status = 0 THEN 1 ELSE 0 END), 0) AS pending,
|
|
COALESCE(SUM(CASE WHEN status = 1 THEN 1 ELSE 0 END), 0) AS paid
|
|
FROM pay_orders WHERE created_at >= ?
|
|
`
|
|
|
|
type PayOrderStatsRow struct {
|
|
Cnt int64
|
|
Money interface{}
|
|
Pending interface{}
|
|
Paid interface{}
|
|
}
|
|
|
|
func (q *Queries) PayOrderStats(ctx context.Context, createdAt int64) (PayOrderStatsRow, error) {
|
|
row := q.db.QueryRowContext(ctx, payOrderStats, createdAt)
|
|
var i PayOrderStatsRow
|
|
err := row.Scan(
|
|
&i.Cnt,
|
|
&i.Money,
|
|
&i.Pending,
|
|
&i.Paid,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const randomProxies = `-- name: RandomProxies :many
|
|
SELECT p.id, p.ip, p.port, p.protocols, p.fail_count, r.code AS region_code, r.zh_name AS region_zh_name
|
|
FROM proxies p JOIN proxy_regions r ON r.id = p.region_id
|
|
WHERE p.alive = 1 AND (? = 0 OR p.region_id = ?) AND (? = '' OR p.protocols LIKE '%' || ? || '%')
|
|
AND (? = '' OR r.code = ?)
|
|
ORDER BY RANDOM() LIMIT ?
|
|
`
|
|
|
|
type RandomProxiesParams struct {
|
|
Column1 interface{}
|
|
RegionID int64
|
|
Column3 interface{}
|
|
Column4 sql.NullString
|
|
Column5 interface{}
|
|
Code string
|
|
Limit int64
|
|
}
|
|
|
|
type RandomProxiesRow struct {
|
|
ID int64
|
|
Ip string
|
|
Port int64
|
|
Protocols string
|
|
FailCount int64
|
|
RegionCode string
|
|
RegionZhName string
|
|
}
|
|
|
|
func (q *Queries) RandomProxies(ctx context.Context, arg RandomProxiesParams) ([]RandomProxiesRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, randomProxies,
|
|
arg.Column1,
|
|
arg.RegionID,
|
|
arg.Column3,
|
|
arg.Column4,
|
|
arg.Column5,
|
|
arg.Code,
|
|
arg.Limit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []RandomProxiesRow{}
|
|
for rows.Next() {
|
|
var i RandomProxiesRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Ip,
|
|
&i.Port,
|
|
&i.Protocols,
|
|
&i.FailCount,
|
|
&i.RegionCode,
|
|
&i.RegionZhName,
|
|
); 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 recentPaidOrders = `-- name: RecentPaidOrders :many
|
|
SELECT trade_no, subject, money, paid_at FROM pay_orders WHERE status = 1 ORDER BY paid_at DESC LIMIT ?
|
|
`
|
|
|
|
type RecentPaidOrdersRow struct {
|
|
TradeNo string
|
|
Subject string
|
|
Money int64
|
|
PaidAt int64
|
|
}
|
|
|
|
func (q *Queries) RecentPaidOrders(ctx context.Context, limit int64) ([]RecentPaidOrdersRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, recentPaidOrders, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
items := []RecentPaidOrdersRow{}
|
|
for rows.Next() {
|
|
var i RecentPaidOrdersRow
|
|
if err := rows.Scan(
|
|
&i.TradeNo,
|
|
&i.Subject,
|
|
&i.Money,
|
|
&i.PaidAt,
|
|
); 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 setPayNotified = `-- name: SetPayNotified :exec
|
|
UPDATE pay_orders SET notified = 1 WHERE id = ?
|
|
`
|
|
|
|
func (q *Queries) SetPayNotified(ctx context.Context, id int64) error {
|
|
_, err := q.db.ExecContext(ctx, setPayNotified, id)
|
|
return err
|
|
}
|
|
|
|
const setPayOrderQrcode = `-- name: SetPayOrderQrcode :exec
|
|
UPDATE pay_orders SET qrcode = ? WHERE id = ?
|
|
`
|
|
|
|
type SetPayOrderQrcodeParams struct {
|
|
Qrcode string
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) SetPayOrderQrcode(ctx context.Context, arg SetPayOrderQrcodeParams) error {
|
|
_, err := q.db.ExecContext(ctx, setPayOrderQrcode, arg.Qrcode, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const setPayOrderStatus = `-- name: SetPayOrderStatus :exec
|
|
UPDATE pay_orders SET status = ?, paid_at = ?, cards = ? WHERE id = ?
|
|
`
|
|
|
|
type SetPayOrderStatusParams struct {
|
|
Status int64
|
|
PaidAt int64
|
|
Cards string
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) SetPayOrderStatus(ctx context.Context, arg SetPayOrderStatusParams) error {
|
|
_, err := q.db.ExecContext(ctx, setPayOrderStatus,
|
|
arg.Status,
|
|
arg.PaidAt,
|
|
arg.Cards,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const setPayOrderUpstream = `-- name: SetPayOrderUpstream :exec
|
|
UPDATE pay_orders SET upstream_trade_no = ?, goods_key = ?, quantity = ?, unit_price = ?, payurl = ?, buyer_contact = ?, query_pwd = ? WHERE id = ?
|
|
`
|
|
|
|
type SetPayOrderUpstreamParams struct {
|
|
UpstreamTradeNo string
|
|
GoodsKey string
|
|
Quantity int64
|
|
UnitPrice int64
|
|
Payurl string
|
|
BuyerContact string
|
|
QueryPwd string
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) SetPayOrderUpstream(ctx context.Context, arg SetPayOrderUpstreamParams) error {
|
|
_, err := q.db.ExecContext(ctx, setPayOrderUpstream,
|
|
arg.UpstreamTradeNo,
|
|
arg.GoodsKey,
|
|
arg.Quantity,
|
|
arg.UnitPrice,
|
|
arg.Payurl,
|
|
arg.BuyerContact,
|
|
arg.QueryPwd,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const touchProxyApiKey = `-- name: TouchProxyApiKey :exec
|
|
UPDATE proxy_keys SET used_count = used_count + 1, last_used_at = ? WHERE id = ?
|
|
`
|
|
|
|
type TouchProxyApiKeyParams struct {
|
|
LastUsedAt int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) TouchProxyApiKey(ctx context.Context, arg TouchProxyApiKeyParams) error {
|
|
_, err := q.db.ExecContext(ctx, touchProxyApiKey, arg.LastUsedAt, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const touchSession = `-- name: TouchSession :exec
|
|
UPDATE sessions SET expires_at = ? WHERE token = ?
|
|
`
|
|
|
|
type TouchSessionParams struct {
|
|
ExpiresAt int64
|
|
Token string
|
|
}
|
|
|
|
func (q *Queries) TouchSession(ctx context.Context, arg TouchSessionParams) error {
|
|
_, err := q.db.ExecContext(ctx, touchSession, arg.ExpiresAt, arg.Token)
|
|
return err
|
|
}
|
|
|
|
const updateBookmark = `-- name: UpdateBookmark :execrows
|
|
UPDATE bookmarks SET title = ?, url = ?, icon = ?, sort = ? WHERE id = ? AND user_id = ?
|
|
`
|
|
|
|
type UpdateBookmarkParams struct {
|
|
Title string
|
|
Url string
|
|
Icon string
|
|
Sort int64
|
|
ID int64
|
|
UserID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateBookmark(ctx context.Context, arg UpdateBookmarkParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, updateBookmark,
|
|
arg.Title,
|
|
arg.Url,
|
|
arg.Icon,
|
|
arg.Sort,
|
|
arg.ID,
|
|
arg.UserID,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const updateDbconn = `-- name: UpdateDbconn :execrows
|
|
UPDATE dbconns SET name = ?, engine = ?, host = ?, port = ?, username = ?, password_enc = ?, database = ?, params = ?, updated_at = ?
|
|
WHERE id = ?
|
|
`
|
|
|
|
type UpdateDbconnParams struct {
|
|
Name string
|
|
Engine string
|
|
Host string
|
|
Port int64
|
|
Username string
|
|
PasswordEnc string
|
|
Database string
|
|
Params string
|
|
UpdatedAt int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateDbconn(ctx context.Context, arg UpdateDbconnParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, updateDbconn,
|
|
arg.Name,
|
|
arg.Engine,
|
|
arg.Host,
|
|
arg.Port,
|
|
arg.Username,
|
|
arg.PasswordEnc,
|
|
arg.Database,
|
|
arg.Params,
|
|
arg.UpdatedAt,
|
|
arg.ID,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const updateLicenseApp = `-- name: UpdateLicenseApp :exec
|
|
UPDATE license_apps SET name = ?, enabled = ? WHERE id = ?
|
|
`
|
|
|
|
type UpdateLicenseAppParams struct {
|
|
Name string
|
|
Enabled int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateLicenseApp(ctx context.Context, arg UpdateLicenseAppParams) error {
|
|
_, err := q.db.ExecContext(ctx, updateLicenseApp, arg.Name, arg.Enabled, arg.ID)
|
|
return err
|
|
}
|
|
|
|
const updateProxySeen = `-- name: UpdateProxySeen :exec
|
|
UPDATE proxies SET protocols = ?, anonymity = ?, region_id = ?, latency = ?, speed = ?, uptime = ?, last_seen_at = ?, alive = 1, fail_count = 0
|
|
WHERE id = ?
|
|
`
|
|
|
|
type UpdateProxySeenParams struct {
|
|
Protocols string
|
|
Anonymity string
|
|
RegionID int64
|
|
Latency int64
|
|
Speed int64
|
|
Uptime int64
|
|
LastSeenAt int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateProxySeen(ctx context.Context, arg UpdateProxySeenParams) error {
|
|
_, err := q.db.ExecContext(ctx, updateProxySeen,
|
|
arg.Protocols,
|
|
arg.Anonymity,
|
|
arg.RegionID,
|
|
arg.Latency,
|
|
arg.Speed,
|
|
arg.Uptime,
|
|
arg.LastSeenAt,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const updateServer = `-- name: UpdateServer :execrows
|
|
UPDATE servers SET name = ?, host = ?, port = ?, username = ?, auth_type = ?, secret_enc = ?, note = ?, updated_at = ?
|
|
WHERE id = ?
|
|
`
|
|
|
|
type UpdateServerParams struct {
|
|
Name string
|
|
Host string
|
|
Port int64
|
|
Username string
|
|
AuthType string
|
|
SecretEnc string
|
|
Note string
|
|
UpdatedAt int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateServer(ctx context.Context, arg UpdateServerParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, updateServer,
|
|
arg.Name,
|
|
arg.Host,
|
|
arg.Port,
|
|
arg.Username,
|
|
arg.AuthType,
|
|
arg.SecretEnc,
|
|
arg.Note,
|
|
arg.UpdatedAt,
|
|
arg.ID,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const updateTool = `-- name: UpdateTool :exec
|
|
UPDATE tools SET name = ?, icon = ?, url = ?, description = ?, sort = ?, enabled = ? WHERE id = ?
|
|
`
|
|
|
|
type UpdateToolParams struct {
|
|
Name string
|
|
Icon string
|
|
Url string
|
|
Description string
|
|
Sort int64
|
|
Enabled bool
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateTool(ctx context.Context, arg UpdateToolParams) error {
|
|
_, err := q.db.ExecContext(ctx, updateTool,
|
|
arg.Name,
|
|
arg.Icon,
|
|
arg.Url,
|
|
arg.Description,
|
|
arg.Sort,
|
|
arg.Enabled,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const updateUser = `-- name: UpdateUser :exec
|
|
UPDATE users SET name = ?, role = ?, status = ?, updated_at = ? WHERE id = ?
|
|
`
|
|
|
|
type UpdateUserParams struct {
|
|
Name string
|
|
Role string
|
|
Status string
|
|
UpdatedAt int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateUser(ctx context.Context, arg UpdateUserParams) error {
|
|
_, err := q.db.ExecContext(ctx, updateUser,
|
|
arg.Name,
|
|
arg.Role,
|
|
arg.Status,
|
|
arg.UpdatedAt,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const updateUserPassword = `-- name: UpdateUserPassword :exec
|
|
UPDATE users SET name = ?, role = ?, status = ?, password_hash = ?, updated_at = ? WHERE id = ?
|
|
`
|
|
|
|
type UpdateUserPasswordParams struct {
|
|
Name string
|
|
Role string
|
|
Status string
|
|
PasswordHash string
|
|
UpdatedAt int64
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateUserPassword(ctx context.Context, arg UpdateUserPasswordParams) error {
|
|
_, err := q.db.ExecContext(ctx, updateUserPassword,
|
|
arg.Name,
|
|
arg.Role,
|
|
arg.Status,
|
|
arg.PasswordHash,
|
|
arg.UpdatedAt,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const updateVault = `-- name: UpdateVault :execrows
|
|
UPDATE vault SET title = ?, username = ?, password_enc = ?, url = ?, note = ?, totp_enc = ?, updated_at = ?
|
|
WHERE id = ? AND user_id = ?
|
|
`
|
|
|
|
type UpdateVaultParams struct {
|
|
Title string
|
|
Username string
|
|
PasswordEnc string
|
|
Url string
|
|
Note string
|
|
TotpEnc string
|
|
UpdatedAt int64
|
|
ID int64
|
|
UserID int64
|
|
}
|
|
|
|
func (q *Queries) UpdateVault(ctx context.Context, arg UpdateVaultParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, updateVault,
|
|
arg.Title,
|
|
arg.Username,
|
|
arg.PasswordEnc,
|
|
arg.Url,
|
|
arg.Note,
|
|
arg.TotpEnc,
|
|
arg.UpdatedAt,
|
|
arg.ID,
|
|
arg.UserID,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const upsertMemory = `-- name: UpsertMemory :exec
|
|
INSERT INTO memories (k, content, project, tags, written_by, revision, created_at, updated_at)
|
|
VALUES (?, ?, ?, ?, ?, 1, ?, ?)
|
|
ON CONFLICT(k) DO UPDATE SET
|
|
content = excluded.content,
|
|
project = excluded.project,
|
|
tags = excluded.tags,
|
|
written_by = excluded.written_by,
|
|
revision = memories.revision + 1,
|
|
updated_at = excluded.updated_at
|
|
`
|
|
|
|
type UpsertMemoryParams struct {
|
|
K string
|
|
Content string
|
|
Project string
|
|
Tags string
|
|
WrittenBy string
|
|
CreatedAt int64
|
|
UpdatedAt int64
|
|
}
|
|
|
|
func (q *Queries) UpsertMemory(ctx context.Context, arg UpsertMemoryParams) error {
|
|
_, err := q.db.ExecContext(ctx, upsertMemory,
|
|
arg.K,
|
|
arg.Content,
|
|
arg.Project,
|
|
arg.Tags,
|
|
arg.WrittenBy,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const upsertProxyRegion = `-- name: UpsertProxyRegion :exec
|
|
INSERT INTO proxy_regions(code, name, zh_name, region, slug) VALUES(?, ?, ?, ?, ?)
|
|
ON CONFLICT(code) DO UPDATE SET name = excluded.name, zh_name = excluded.zh_name,
|
|
region = excluded.region, slug = excluded.slug
|
|
`
|
|
|
|
type UpsertProxyRegionParams struct {
|
|
Code string
|
|
Name string
|
|
ZhName string
|
|
Region string
|
|
Slug string
|
|
}
|
|
|
|
func (q *Queries) UpsertProxyRegion(ctx context.Context, arg UpsertProxyRegionParams) error {
|
|
_, err := q.db.ExecContext(ctx, upsertProxyRegion,
|
|
arg.Code,
|
|
arg.Name,
|
|
arg.ZhName,
|
|
arg.Region,
|
|
arg.Slug,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const upsertSetting = `-- name: UpsertSetting :exec
|
|
INSERT INTO settings (k, v) VALUES (?, ?) ON CONFLICT(k) DO UPDATE SET v = excluded.v
|
|
`
|
|
|
|
type UpsertSettingParams struct {
|
|
K string
|
|
V string
|
|
}
|
|
|
|
func (q *Queries) UpsertSetting(ctx context.Context, arg UpsertSettingParams) error {
|
|
_, err := q.db.ExecContext(ctx, upsertSetting, arg.K, arg.V)
|
|
return err
|
|
}
|