1264 lines
31 KiB
Go
1264 lines
31 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.21.0
|
|
// source: query.sql
|
|
|
|
package database
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const addActivity = `-- name: AddActivity :one
|
|
INSERT INTO activity (
|
|
user_id,
|
|
document_id,
|
|
device_id,
|
|
start_time,
|
|
duration,
|
|
current_page,
|
|
total_pages
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
RETURNING id, user_id, document_id, device_id, start_time, duration, current_page, total_pages, created_at
|
|
`
|
|
|
|
type AddActivityParams struct {
|
|
UserID string `json:"user_id"`
|
|
DocumentID string `json:"document_id"`
|
|
DeviceID string `json:"device_id"`
|
|
StartTime time.Time `json:"start_time"`
|
|
Duration int64 `json:"duration"`
|
|
CurrentPage int64 `json:"current_page"`
|
|
TotalPages int64 `json:"total_pages"`
|
|
}
|
|
|
|
func (q *Queries) AddActivity(ctx context.Context, arg AddActivityParams) (Activity, error) {
|
|
row := q.db.QueryRowContext(ctx, addActivity,
|
|
arg.UserID,
|
|
arg.DocumentID,
|
|
arg.DeviceID,
|
|
arg.StartTime,
|
|
arg.Duration,
|
|
arg.CurrentPage,
|
|
arg.TotalPages,
|
|
)
|
|
var i Activity
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.DocumentID,
|
|
&i.DeviceID,
|
|
&i.StartTime,
|
|
&i.Duration,
|
|
&i.CurrentPage,
|
|
&i.TotalPages,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const createUser = `-- name: CreateUser :execrows
|
|
INSERT INTO users (id, pass)
|
|
VALUES (?, ?)
|
|
ON CONFLICT DO NOTHING
|
|
`
|
|
|
|
type CreateUserParams struct {
|
|
ID string `json:"id"`
|
|
Pass string `json:"-"`
|
|
}
|
|
|
|
func (q *Queries) CreateUser(ctx context.Context, arg CreateUserParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, createUser, arg.ID, arg.Pass)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const deleteDocument = `-- name: DeleteDocument :execrows
|
|
UPDATE documents
|
|
SET
|
|
deleted = 1
|
|
WHERE id = ?1
|
|
`
|
|
|
|
func (q *Queries) DeleteDocument(ctx context.Context, id string) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteDocument, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const getActivity = `-- name: GetActivity :many
|
|
SELECT id, user_id, document_id, device_id, start_time, duration, current_page, total_pages, created_at FROM activity
|
|
WHERE
|
|
user_id = ?1
|
|
AND (
|
|
(?2 = TRUE AND document_id = ?3)
|
|
OR ?2 = FALSE
|
|
)
|
|
ORDER BY start_time DESC
|
|
LIMIT ?5
|
|
OFFSET ?4
|
|
`
|
|
|
|
type GetActivityParams struct {
|
|
UserID string `json:"user_id"`
|
|
DocFilter interface{} `json:"doc_filter"`
|
|
DocumentID string `json:"document_id"`
|
|
Offset int64 `json:"offset"`
|
|
Limit int64 `json:"limit"`
|
|
}
|
|
|
|
func (q *Queries) GetActivity(ctx context.Context, arg GetActivityParams) ([]Activity, error) {
|
|
rows, err := q.db.QueryContext(ctx, getActivity,
|
|
arg.UserID,
|
|
arg.DocFilter,
|
|
arg.DocumentID,
|
|
arg.Offset,
|
|
arg.Limit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Activity
|
|
for rows.Next() {
|
|
var i Activity
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.DocumentID,
|
|
&i.DeviceID,
|
|
&i.StartTime,
|
|
&i.Duration,
|
|
&i.CurrentPage,
|
|
&i.TotalPages,
|
|
&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 getDailyReadStats = `-- name: GetDailyReadStats :many
|
|
WITH RECURSIVE last_30_days (date) AS (
|
|
SELECT date('now') AS date
|
|
UNION ALL
|
|
SELECT date(date, '-1 days')
|
|
FROM last_30_days
|
|
LIMIT 30
|
|
),
|
|
activity_records AS (
|
|
SELECT
|
|
sum(duration) AS seconds_read,
|
|
date(start_time, 'localtime') AS day
|
|
FROM activity
|
|
WHERE user_id = ?1
|
|
GROUP BY day
|
|
ORDER BY day DESC
|
|
LIMIT 30
|
|
)
|
|
SELECT
|
|
CAST(date AS TEXT),
|
|
CAST(CASE
|
|
WHEN seconds_read IS NULL THEN 0
|
|
ELSE seconds_read / 60
|
|
END AS INTEGER) AS minutes_read
|
|
FROM last_30_days
|
|
LEFT JOIN activity_records ON activity_records.day == last_30_days.date
|
|
ORDER BY date DESC
|
|
LIMIT 30
|
|
`
|
|
|
|
type GetDailyReadStatsRow struct {
|
|
Date string `json:"date"`
|
|
MinutesRead int64 `json:"minutes_read"`
|
|
}
|
|
|
|
func (q *Queries) GetDailyReadStats(ctx context.Context, userID string) ([]GetDailyReadStatsRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getDailyReadStats, userID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetDailyReadStatsRow
|
|
for rows.Next() {
|
|
var i GetDailyReadStatsRow
|
|
if err := rows.Scan(&i.Date, &i.MinutesRead); 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 getDatabaseInfo = `-- name: GetDatabaseInfo :one
|
|
SELECT
|
|
(SELECT count(rowid) FROM activity WHERE activity.user_id = ?1) AS activity_size,
|
|
(SELECT count(rowid) FROM documents) AS documents_size,
|
|
(SELECT count(rowid) FROM document_progress WHERE document_progress.user_id = ?1) AS progress_size,
|
|
(SELECT count(rowid) FROM devices WHERE devices.user_id = ?1) AS devices_size
|
|
LIMIT 1
|
|
`
|
|
|
|
type GetDatabaseInfoRow struct {
|
|
ActivitySize int64 `json:"activity_size"`
|
|
DocumentsSize int64 `json:"documents_size"`
|
|
ProgressSize int64 `json:"progress_size"`
|
|
DevicesSize int64 `json:"devices_size"`
|
|
}
|
|
|
|
func (q *Queries) GetDatabaseInfo(ctx context.Context, userID string) (GetDatabaseInfoRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getDatabaseInfo, userID)
|
|
var i GetDatabaseInfoRow
|
|
err := row.Scan(
|
|
&i.ActivitySize,
|
|
&i.DocumentsSize,
|
|
&i.ProgressSize,
|
|
&i.DevicesSize,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getDeletedDocuments = `-- name: GetDeletedDocuments :many
|
|
SELECT documents.id
|
|
FROM documents
|
|
WHERE
|
|
documents.deleted = true
|
|
AND documents.id IN (/*SLICE:document_ids*/?)
|
|
`
|
|
|
|
func (q *Queries) GetDeletedDocuments(ctx context.Context, documentIds []string) ([]string, error) {
|
|
query := getDeletedDocuments
|
|
var queryParams []interface{}
|
|
if len(documentIds) > 0 {
|
|
for _, v := range documentIds {
|
|
queryParams = append(queryParams, v)
|
|
}
|
|
query = strings.Replace(query, "/*SLICE:document_ids*/?", strings.Repeat(",?", len(documentIds))[1:], 1)
|
|
} else {
|
|
query = strings.Replace(query, "/*SLICE:document_ids*/?", "NULL", 1)
|
|
}
|
|
rows, err := q.db.QueryContext(ctx, query, queryParams...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []string
|
|
for rows.Next() {
|
|
var id string
|
|
if err := rows.Scan(&id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, id)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getDevice = `-- name: GetDevice :one
|
|
SELECT id, user_id, device_name, created_at, sync FROM devices
|
|
WHERE id = ?1 LIMIT 1
|
|
`
|
|
|
|
func (q *Queries) GetDevice(ctx context.Context, deviceID string) (Device, error) {
|
|
row := q.db.QueryRowContext(ctx, getDevice, deviceID)
|
|
var i Device
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.DeviceName,
|
|
&i.CreatedAt,
|
|
&i.Sync,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getDevices = `-- name: GetDevices :many
|
|
SELECT id, user_id, device_name, created_at, sync FROM devices
|
|
WHERE user_id = ?1
|
|
ORDER BY created_at DESC
|
|
LIMIT ?3
|
|
OFFSET ?2
|
|
`
|
|
|
|
type GetDevicesParams struct {
|
|
UserID string `json:"user_id"`
|
|
Offset int64 `json:"offset"`
|
|
Limit int64 `json:"limit"`
|
|
}
|
|
|
|
func (q *Queries) GetDevices(ctx context.Context, arg GetDevicesParams) ([]Device, error) {
|
|
rows, err := q.db.QueryContext(ctx, getDevices, arg.UserID, arg.Offset, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Device
|
|
for rows.Next() {
|
|
var i Device
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.DeviceName,
|
|
&i.CreatedAt,
|
|
&i.Sync,
|
|
); 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 getDocument = `-- name: GetDocument :one
|
|
SELECT id, md5, filepath, title, author, series, series_index, lang, description, olid, synced, deleted, updated_at, created_at FROM documents
|
|
WHERE id = ?1 LIMIT 1
|
|
`
|
|
|
|
func (q *Queries) GetDocument(ctx context.Context, documentID string) (Document, error) {
|
|
row := q.db.QueryRowContext(ctx, getDocument, documentID)
|
|
var i Document
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Md5,
|
|
&i.Filepath,
|
|
&i.Title,
|
|
&i.Author,
|
|
&i.Series,
|
|
&i.SeriesIndex,
|
|
&i.Lang,
|
|
&i.Description,
|
|
&i.Olid,
|
|
&i.Synced,
|
|
&i.Deleted,
|
|
&i.UpdatedAt,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getDocumentDaysRead = `-- name: GetDocumentDaysRead :one
|
|
WITH document_days AS (
|
|
SELECT date(start_time, 'localtime') AS dates
|
|
FROM rescaled_activity
|
|
WHERE document_id = ?1
|
|
AND user_id = ?2
|
|
GROUP BY dates
|
|
)
|
|
SELECT CAST(count(*) AS INTEGER) AS days_read
|
|
FROM document_days
|
|
`
|
|
|
|
type GetDocumentDaysReadParams struct {
|
|
DocumentID string `json:"document_id"`
|
|
UserID string `json:"user_id"`
|
|
}
|
|
|
|
func (q *Queries) GetDocumentDaysRead(ctx context.Context, arg GetDocumentDaysReadParams) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, getDocumentDaysRead, arg.DocumentID, arg.UserID)
|
|
var days_read int64
|
|
err := row.Scan(&days_read)
|
|
return days_read, err
|
|
}
|
|
|
|
const getDocumentReadStats = `-- name: GetDocumentReadStats :one
|
|
SELECT
|
|
count(DISTINCT page) AS pages_read,
|
|
sum(duration) AS total_time
|
|
FROM rescaled_activity
|
|
WHERE document_id = ?1
|
|
AND user_id = ?2
|
|
AND start_time >= ?3
|
|
`
|
|
|
|
type GetDocumentReadStatsParams struct {
|
|
DocumentID string `json:"document_id"`
|
|
UserID string `json:"user_id"`
|
|
StartTime time.Time `json:"start_time"`
|
|
}
|
|
|
|
type GetDocumentReadStatsRow struct {
|
|
PagesRead int64 `json:"pages_read"`
|
|
TotalTime sql.NullFloat64 `json:"total_time"`
|
|
}
|
|
|
|
func (q *Queries) GetDocumentReadStats(ctx context.Context, arg GetDocumentReadStatsParams) (GetDocumentReadStatsRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getDocumentReadStats, arg.DocumentID, arg.UserID, arg.StartTime)
|
|
var i GetDocumentReadStatsRow
|
|
err := row.Scan(&i.PagesRead, &i.TotalTime)
|
|
return i, err
|
|
}
|
|
|
|
const getDocumentReadStatsCapped = `-- name: GetDocumentReadStatsCapped :one
|
|
WITH capped_stats AS (
|
|
SELECT min(sum(duration), CAST(?1 AS INTEGER)) AS durations
|
|
FROM rescaled_activity
|
|
WHERE document_id = ?2
|
|
AND user_id = ?3
|
|
AND start_time >= ?4
|
|
GROUP BY page
|
|
)
|
|
SELECT
|
|
CAST(count(*) AS INTEGER) AS pages_read,
|
|
CAST(sum(durations) AS INTEGER) AS total_time
|
|
FROM capped_stats
|
|
`
|
|
|
|
type GetDocumentReadStatsCappedParams struct {
|
|
PageDurationCap int64 `json:"page_duration_cap"`
|
|
DocumentID string `json:"document_id"`
|
|
UserID string `json:"user_id"`
|
|
StartTime time.Time `json:"start_time"`
|
|
}
|
|
|
|
type GetDocumentReadStatsCappedRow struct {
|
|
PagesRead int64 `json:"pages_read"`
|
|
TotalTime int64 `json:"total_time"`
|
|
}
|
|
|
|
func (q *Queries) GetDocumentReadStatsCapped(ctx context.Context, arg GetDocumentReadStatsCappedParams) (GetDocumentReadStatsCappedRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getDocumentReadStatsCapped,
|
|
arg.PageDurationCap,
|
|
arg.DocumentID,
|
|
arg.UserID,
|
|
arg.StartTime,
|
|
)
|
|
var i GetDocumentReadStatsCappedRow
|
|
err := row.Scan(&i.PagesRead, &i.TotalTime)
|
|
return i, err
|
|
}
|
|
|
|
const getDocuments = `-- name: GetDocuments :many
|
|
SELECT id, md5, filepath, title, author, series, series_index, lang, description, olid, synced, deleted, updated_at, created_at FROM documents
|
|
ORDER BY created_at DESC
|
|
LIMIT ?2
|
|
OFFSET ?1
|
|
`
|
|
|
|
type GetDocumentsParams struct {
|
|
Offset int64 `json:"offset"`
|
|
Limit int64 `json:"limit"`
|
|
}
|
|
|
|
func (q *Queries) GetDocuments(ctx context.Context, arg GetDocumentsParams) ([]Document, error) {
|
|
rows, err := q.db.QueryContext(ctx, getDocuments, arg.Offset, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Document
|
|
for rows.Next() {
|
|
var i Document
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Md5,
|
|
&i.Filepath,
|
|
&i.Title,
|
|
&i.Author,
|
|
&i.Series,
|
|
&i.SeriesIndex,
|
|
&i.Lang,
|
|
&i.Description,
|
|
&i.Olid,
|
|
&i.Synced,
|
|
&i.Deleted,
|
|
&i.UpdatedAt,
|
|
&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 getDocumentsWithStats = `-- name: GetDocumentsWithStats :many
|
|
WITH true_progress AS (
|
|
SELECT
|
|
start_time AS last_read,
|
|
SUM(duration) / 60 AS total_time_minutes,
|
|
document_id,
|
|
current_page,
|
|
total_pages,
|
|
ROUND(CAST(current_page AS REAL) / CAST(total_pages AS REAL) * 100, 2) AS percentage
|
|
FROM activity
|
|
WHERE user_id = ?3
|
|
GROUP BY document_id
|
|
HAVING MAX(start_time)
|
|
)
|
|
SELECT
|
|
documents.id, documents.md5, documents.filepath, documents.title, documents.author, documents.series, documents.series_index, documents.lang, documents.description, documents.olid, documents.synced, documents.deleted, documents.updated_at, documents.created_at,
|
|
|
|
CAST(IFNULL(current_page, 0) AS INTEGER) AS current_page,
|
|
CAST(IFNULL(total_pages, 0) AS INTEGER) AS total_pages,
|
|
CAST(IFNULL(total_time_minutes, 0) AS INTEGER) AS total_time_minutes,
|
|
|
|
CAST(
|
|
STRFTIME('%Y-%m-%dT%H:%M:%SZ', IFNULL(last_read, "1970-01-01")
|
|
) AS TEXT) AS last_read,
|
|
|
|
CAST(CASE
|
|
WHEN percentage > 97.0 THEN 100.0
|
|
WHEN percentage IS NULL THEN 0.0
|
|
ELSE percentage
|
|
END AS REAL) AS percentage
|
|
|
|
FROM documents
|
|
LEFT JOIN true_progress ON document_id = id
|
|
ORDER BY last_read DESC, created_at DESC
|
|
LIMIT ?2
|
|
OFFSET ?1
|
|
`
|
|
|
|
type GetDocumentsWithStatsParams struct {
|
|
Offset int64 `json:"offset"`
|
|
Limit int64 `json:"limit"`
|
|
UserID string `json:"user_id"`
|
|
}
|
|
|
|
type GetDocumentsWithStatsRow struct {
|
|
ID string `json:"id"`
|
|
Md5 *string `json:"md5"`
|
|
Filepath *string `json:"filepath"`
|
|
Title *string `json:"title"`
|
|
Author *string `json:"author"`
|
|
Series *string `json:"series"`
|
|
SeriesIndex *int64 `json:"series_index"`
|
|
Lang *string `json:"lang"`
|
|
Description *string `json:"description"`
|
|
Olid *string `json:"-"`
|
|
Synced bool `json:"-"`
|
|
Deleted bool `json:"-"`
|
|
UpdatedAt time.Time `json:"updated_at"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
CurrentPage int64 `json:"current_page"`
|
|
TotalPages int64 `json:"total_pages"`
|
|
TotalTimeMinutes int64 `json:"total_time_minutes"`
|
|
LastRead string `json:"last_read"`
|
|
Percentage float64 `json:"percentage"`
|
|
}
|
|
|
|
func (q *Queries) GetDocumentsWithStats(ctx context.Context, arg GetDocumentsWithStatsParams) ([]GetDocumentsWithStatsRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, getDocumentsWithStats, arg.Offset, arg.Limit, arg.UserID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []GetDocumentsWithStatsRow
|
|
for rows.Next() {
|
|
var i GetDocumentsWithStatsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Md5,
|
|
&i.Filepath,
|
|
&i.Title,
|
|
&i.Author,
|
|
&i.Series,
|
|
&i.SeriesIndex,
|
|
&i.Lang,
|
|
&i.Description,
|
|
&i.Olid,
|
|
&i.Synced,
|
|
&i.Deleted,
|
|
&i.UpdatedAt,
|
|
&i.CreatedAt,
|
|
&i.CurrentPage,
|
|
&i.TotalPages,
|
|
&i.TotalTimeMinutes,
|
|
&i.LastRead,
|
|
&i.Percentage,
|
|
); 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 getLastActivity = `-- name: GetLastActivity :one
|
|
SELECT start_time
|
|
FROM activity
|
|
WHERE device_id = ?1
|
|
AND user_id = ?2
|
|
ORDER BY start_time DESC LIMIT 1
|
|
`
|
|
|
|
type GetLastActivityParams struct {
|
|
DeviceID string `json:"device_id"`
|
|
UserID string `json:"user_id"`
|
|
}
|
|
|
|
func (q *Queries) GetLastActivity(ctx context.Context, arg GetLastActivityParams) (time.Time, error) {
|
|
row := q.db.QueryRowContext(ctx, getLastActivity, arg.DeviceID, arg.UserID)
|
|
var start_time time.Time
|
|
err := row.Scan(&start_time)
|
|
return start_time, err
|
|
}
|
|
|
|
const getMissingDocuments = `-- name: GetMissingDocuments :many
|
|
SELECT documents.id, documents.md5, documents.filepath, documents.title, documents.author, documents.series, documents.series_index, documents.lang, documents.description, documents.olid, documents.synced, documents.deleted, documents.updated_at, documents.created_at FROM documents
|
|
WHERE
|
|
documents.filepath IS NOT NULL
|
|
AND documents.deleted = false
|
|
AND documents.id NOT IN (/*SLICE:document_ids*/?)
|
|
`
|
|
|
|
func (q *Queries) GetMissingDocuments(ctx context.Context, documentIds []string) ([]Document, error) {
|
|
query := getMissingDocuments
|
|
var queryParams []interface{}
|
|
if len(documentIds) > 0 {
|
|
for _, v := range documentIds {
|
|
queryParams = append(queryParams, v)
|
|
}
|
|
query = strings.Replace(query, "/*SLICE:document_ids*/?", strings.Repeat(",?", len(documentIds))[1:], 1)
|
|
} else {
|
|
query = strings.Replace(query, "/*SLICE:document_ids*/?", "NULL", 1)
|
|
}
|
|
rows, err := q.db.QueryContext(ctx, query, queryParams...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Document
|
|
for rows.Next() {
|
|
var i Document
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Md5,
|
|
&i.Filepath,
|
|
&i.Title,
|
|
&i.Author,
|
|
&i.Series,
|
|
&i.SeriesIndex,
|
|
&i.Lang,
|
|
&i.Description,
|
|
&i.Olid,
|
|
&i.Synced,
|
|
&i.Deleted,
|
|
&i.UpdatedAt,
|
|
&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 getProgress = `-- name: GetProgress :one
|
|
SELECT
|
|
document_progress.user_id, document_progress.document_id, document_progress.device_id, document_progress.percentage, document_progress.progress, document_progress.created_at,
|
|
devices.device_name
|
|
FROM document_progress
|
|
JOIN devices ON document_progress.device_id = devices.id
|
|
WHERE
|
|
document_progress.user_id = ?1
|
|
AND document_progress.document_id = ?2
|
|
ORDER BY
|
|
document_progress.created_at
|
|
DESC
|
|
LIMIT 1
|
|
`
|
|
|
|
type GetProgressParams struct {
|
|
UserID string `json:"user_id"`
|
|
DocumentID string `json:"document_id"`
|
|
}
|
|
|
|
type GetProgressRow struct {
|
|
UserID string `json:"user_id"`
|
|
DocumentID string `json:"document_id"`
|
|
DeviceID string `json:"device_id"`
|
|
Percentage float64 `json:"percentage"`
|
|
Progress string `json:"progress"`
|
|
CreatedAt time.Time `json:"created_at"`
|
|
DeviceName string `json:"device_name"`
|
|
}
|
|
|
|
func (q *Queries) GetProgress(ctx context.Context, arg GetProgressParams) (GetProgressRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getProgress, arg.UserID, arg.DocumentID)
|
|
var i GetProgressRow
|
|
err := row.Scan(
|
|
&i.UserID,
|
|
&i.DocumentID,
|
|
&i.DeviceID,
|
|
&i.Percentage,
|
|
&i.Progress,
|
|
&i.CreatedAt,
|
|
&i.DeviceName,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUser = `-- name: GetUser :one
|
|
SELECT id, pass, admin, created_at FROM users
|
|
WHERE id = ?1 LIMIT 1
|
|
`
|
|
|
|
func (q *Queries) GetUser(ctx context.Context, userID string) (User, error) {
|
|
row := q.db.QueryRowContext(ctx, getUser, userID)
|
|
var i User
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Pass,
|
|
&i.Admin,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUserDayStreaks = `-- name: GetUserDayStreaks :one
|
|
WITH document_days AS (
|
|
SELECT date(start_time, 'localtime') AS read_day
|
|
FROM activity
|
|
WHERE user_id = ?1
|
|
GROUP BY read_day
|
|
ORDER BY read_day DESC
|
|
),
|
|
partitions AS (
|
|
SELECT
|
|
document_days.read_day,
|
|
row_number() OVER (
|
|
PARTITION BY 1 ORDER BY read_day DESC
|
|
) AS seqnum
|
|
FROM document_days
|
|
),
|
|
streaks AS (
|
|
SELECT
|
|
count(*) AS streak,
|
|
MIN(read_day) AS start_date,
|
|
MAX(read_day) AS end_date
|
|
FROM partitions
|
|
GROUP BY date(read_day, '+' || seqnum || ' day')
|
|
ORDER BY end_date DESC
|
|
),
|
|
max_streak AS (
|
|
SELECT
|
|
MAX(streak) AS max_streak,
|
|
start_date AS max_streak_start_date,
|
|
end_date AS max_streak_end_date
|
|
FROM streaks
|
|
)
|
|
SELECT
|
|
CAST(max_streak AS INTEGER),
|
|
CAST(max_streak_start_date AS TEXT),
|
|
CAST(max_streak_end_date AS TEXT),
|
|
streak AS current_streak,
|
|
CAST(start_date AS TEXT) AS current_streak_start_date,
|
|
CAST(end_date AS TEXT) AS current_streak_end_date
|
|
FROM max_streak, streaks LIMIT 1
|
|
`
|
|
|
|
type GetUserDayStreaksRow struct {
|
|
MaxStreak int64 `json:"max_streak"`
|
|
MaxStreakStartDate string `json:"max_streak_start_date"`
|
|
MaxStreakEndDate string `json:"max_streak_end_date"`
|
|
CurrentStreak int64 `json:"current_streak"`
|
|
CurrentStreakStartDate string `json:"current_streak_start_date"`
|
|
CurrentStreakEndDate string `json:"current_streak_end_date"`
|
|
}
|
|
|
|
func (q *Queries) GetUserDayStreaks(ctx context.Context, userID string) (GetUserDayStreaksRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getUserDayStreaks, userID)
|
|
var i GetUserDayStreaksRow
|
|
err := row.Scan(
|
|
&i.MaxStreak,
|
|
&i.MaxStreakStartDate,
|
|
&i.MaxStreakEndDate,
|
|
&i.CurrentStreak,
|
|
&i.CurrentStreakStartDate,
|
|
&i.CurrentStreakEndDate,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUserWeekStreaks = `-- name: GetUserWeekStreaks :one
|
|
WITH document_weeks AS (
|
|
SELECT STRFTIME('%Y-%m-%d', start_time, 'localtime', 'weekday 0', '-7 day') AS read_week
|
|
FROM activity
|
|
WHERE user_id = ?1
|
|
GROUP BY read_week
|
|
ORDER BY read_week DESC
|
|
),
|
|
partitions AS (
|
|
SELECT
|
|
document_weeks.read_week,
|
|
row_number() OVER (
|
|
PARTITION BY 1 ORDER BY read_week DESC
|
|
) AS seqnum
|
|
FROM document_weeks
|
|
),
|
|
streaks AS (
|
|
SELECT
|
|
count(*) AS streak,
|
|
MIN(read_week) AS start_date,
|
|
MAX(read_week) AS end_date
|
|
FROM partitions
|
|
GROUP BY date(read_week, '+' || (seqnum * 7) || ' day')
|
|
ORDER BY end_date DESC
|
|
),
|
|
max_streak AS (
|
|
SELECT
|
|
MAX(streak) AS max_streak,
|
|
start_date AS max_streak_start_date,
|
|
end_date AS max_streak_end_date
|
|
FROM streaks
|
|
)
|
|
SELECT
|
|
CAST(max_streak AS INTEGER),
|
|
CAST(max_streak_start_date AS TEXT),
|
|
CAST(max_streak_end_date AS TEXT),
|
|
streak AS current_streak,
|
|
CAST(start_date AS TEXT) AS current_streak_start_date,
|
|
CAST(end_date AS TEXT) AS current_streak_end_date
|
|
FROM max_streak, streaks LIMIT 1
|
|
`
|
|
|
|
type GetUserWeekStreaksRow struct {
|
|
MaxStreak int64 `json:"max_streak"`
|
|
MaxStreakStartDate string `json:"max_streak_start_date"`
|
|
MaxStreakEndDate string `json:"max_streak_end_date"`
|
|
CurrentStreak int64 `json:"current_streak"`
|
|
CurrentStreakStartDate string `json:"current_streak_start_date"`
|
|
CurrentStreakEndDate string `json:"current_streak_end_date"`
|
|
}
|
|
|
|
func (q *Queries) GetUserWeekStreaks(ctx context.Context, userID string) (GetUserWeekStreaksRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getUserWeekStreaks, userID)
|
|
var i GetUserWeekStreaksRow
|
|
err := row.Scan(
|
|
&i.MaxStreak,
|
|
&i.MaxStreakStartDate,
|
|
&i.MaxStreakEndDate,
|
|
&i.CurrentStreak,
|
|
&i.CurrentStreakStartDate,
|
|
&i.CurrentStreakEndDate,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUserWindowStreaks = `-- name: GetUserWindowStreaks :one
|
|
WITH document_windows AS (
|
|
SELECT CASE
|
|
WHEN ?2 = "WEEK" THEN STRFTIME('%Y-%m-%d', start_time, 'localtime', 'weekday 0', '-7 day')
|
|
WHEN ?2 = "DAY" THEN date(start_time, 'localtime')
|
|
END AS read_window
|
|
FROM activity
|
|
WHERE user_id = ?1
|
|
AND CAST(?2 AS TEXT) = CAST(?2 AS TEXT)
|
|
GROUP BY read_window
|
|
ORDER BY read_window DESC
|
|
),
|
|
partitions AS (
|
|
SELECT
|
|
document_windows.read_window,
|
|
row_number() OVER (
|
|
PARTITION BY 1 ORDER BY read_window DESC
|
|
) AS seqnum
|
|
FROM document_windows
|
|
),
|
|
streaks AS (
|
|
SELECT
|
|
count(*) AS streak,
|
|
MIN(read_window) AS start_date,
|
|
MAX(read_window) AS end_date
|
|
FROM partitions
|
|
GROUP BY CASE
|
|
WHEN ?2 = "DAY" THEN date(read_window, '+' || seqnum || ' day')
|
|
WHEN ?2 = "WEEK" THEN date(read_window, '+' || (seqnum * 7) || ' day')
|
|
END
|
|
ORDER BY end_date DESC
|
|
),
|
|
max_streak AS (
|
|
SELECT
|
|
MAX(streak) AS max_streak,
|
|
start_date AS max_streak_start_date,
|
|
end_date AS max_streak_end_date
|
|
FROM streaks
|
|
)
|
|
SELECT
|
|
CAST(max_streak AS INTEGER),
|
|
CAST(max_streak_start_date AS TEXT),
|
|
CAST(max_streak_end_date AS TEXT),
|
|
streak AS current_streak,
|
|
CAST(start_date AS TEXT) AS current_streak_start_date,
|
|
CAST(end_date AS TEXT) AS current_streak_end_date
|
|
FROM max_streak, streaks LIMIT 1
|
|
`
|
|
|
|
type GetUserWindowStreaksParams struct {
|
|
UserID string `json:"user_id"`
|
|
Window string `json:"window"`
|
|
}
|
|
|
|
type GetUserWindowStreaksRow struct {
|
|
MaxStreak int64 `json:"max_streak"`
|
|
MaxStreakStartDate string `json:"max_streak_start_date"`
|
|
MaxStreakEndDate string `json:"max_streak_end_date"`
|
|
CurrentStreak int64 `json:"current_streak"`
|
|
CurrentStreakStartDate string `json:"current_streak_start_date"`
|
|
CurrentStreakEndDate string `json:"current_streak_end_date"`
|
|
}
|
|
|
|
func (q *Queries) GetUserWindowStreaks(ctx context.Context, arg GetUserWindowStreaksParams) (GetUserWindowStreaksRow, error) {
|
|
row := q.db.QueryRowContext(ctx, getUserWindowStreaks, arg.UserID, arg.Window)
|
|
var i GetUserWindowStreaksRow
|
|
err := row.Scan(
|
|
&i.MaxStreak,
|
|
&i.MaxStreakStartDate,
|
|
&i.MaxStreakEndDate,
|
|
&i.CurrentStreak,
|
|
&i.CurrentStreakStartDate,
|
|
&i.CurrentStreakEndDate,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getUsers = `-- name: GetUsers :many
|
|
SELECT id, pass, admin, created_at FROM users
|
|
WHERE
|
|
users.id = ?1
|
|
OR ?1 IN (
|
|
SELECT id
|
|
FROM users
|
|
WHERE id = ?1
|
|
AND admin = 1
|
|
)
|
|
ORDER BY created_at DESC
|
|
LIMIT ?3
|
|
OFFSET ?2
|
|
`
|
|
|
|
type GetUsersParams struct {
|
|
User string `json:"user"`
|
|
Offset int64 `json:"offset"`
|
|
Limit int64 `json:"limit"`
|
|
}
|
|
|
|
func (q *Queries) GetUsers(ctx context.Context, arg GetUsersParams) ([]User, error) {
|
|
rows, err := q.db.QueryContext(ctx, getUsers, arg.User, arg.Offset, arg.Limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []User
|
|
for rows.Next() {
|
|
var i User
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Pass,
|
|
&i.Admin,
|
|
&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 getWantedDocuments = `-- name: GetWantedDocuments :many
|
|
SELECT CAST(value AS TEXT) AS id
|
|
FROM json_each(?1)
|
|
LEFT JOIN documents
|
|
ON value = documents.id
|
|
WHERE (
|
|
documents.id IS NOT NULL
|
|
AND documents.synced = false
|
|
)
|
|
OR (documents.id IS NULL)
|
|
OR CAST(?1 AS TEXT) != CAST(?1 AS TEXT)
|
|
`
|
|
|
|
func (q *Queries) GetWantedDocuments(ctx context.Context, documentIds string) ([]string, error) {
|
|
rows, err := q.db.QueryContext(ctx, getWantedDocuments, documentIds)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []string
|
|
for rows.Next() {
|
|
var id string
|
|
if err := rows.Scan(&id); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, id)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const updateDocumentDeleted = `-- name: UpdateDocumentDeleted :one
|
|
UPDATE documents
|
|
SET
|
|
deleted = ?1
|
|
WHERE id = ?2
|
|
RETURNING id, md5, filepath, title, author, series, series_index, lang, description, olid, synced, deleted, updated_at, created_at
|
|
`
|
|
|
|
type UpdateDocumentDeletedParams struct {
|
|
Deleted bool `json:"-"`
|
|
ID string `json:"id"`
|
|
}
|
|
|
|
func (q *Queries) UpdateDocumentDeleted(ctx context.Context, arg UpdateDocumentDeletedParams) (Document, error) {
|
|
row := q.db.QueryRowContext(ctx, updateDocumentDeleted, arg.Deleted, arg.ID)
|
|
var i Document
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Md5,
|
|
&i.Filepath,
|
|
&i.Title,
|
|
&i.Author,
|
|
&i.Series,
|
|
&i.SeriesIndex,
|
|
&i.Lang,
|
|
&i.Description,
|
|
&i.Olid,
|
|
&i.Synced,
|
|
&i.Deleted,
|
|
&i.UpdatedAt,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const updateDocumentSync = `-- name: UpdateDocumentSync :one
|
|
UPDATE documents
|
|
SET
|
|
synced = ?1
|
|
WHERE id = ?2
|
|
RETURNING id, md5, filepath, title, author, series, series_index, lang, description, olid, synced, deleted, updated_at, created_at
|
|
`
|
|
|
|
type UpdateDocumentSyncParams struct {
|
|
Synced bool `json:"-"`
|
|
ID string `json:"id"`
|
|
}
|
|
|
|
func (q *Queries) UpdateDocumentSync(ctx context.Context, arg UpdateDocumentSyncParams) (Document, error) {
|
|
row := q.db.QueryRowContext(ctx, updateDocumentSync, arg.Synced, arg.ID)
|
|
var i Document
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Md5,
|
|
&i.Filepath,
|
|
&i.Title,
|
|
&i.Author,
|
|
&i.Series,
|
|
&i.SeriesIndex,
|
|
&i.Lang,
|
|
&i.Description,
|
|
&i.Olid,
|
|
&i.Synced,
|
|
&i.Deleted,
|
|
&i.UpdatedAt,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const updateProgress = `-- name: UpdateProgress :one
|
|
INSERT OR REPLACE INTO document_progress (
|
|
user_id,
|
|
document_id,
|
|
device_id,
|
|
percentage,
|
|
progress
|
|
)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
RETURNING user_id, document_id, device_id, percentage, progress, created_at
|
|
`
|
|
|
|
type UpdateProgressParams struct {
|
|
UserID string `json:"user_id"`
|
|
DocumentID string `json:"document_id"`
|
|
DeviceID string `json:"device_id"`
|
|
Percentage float64 `json:"percentage"`
|
|
Progress string `json:"progress"`
|
|
}
|
|
|
|
func (q *Queries) UpdateProgress(ctx context.Context, arg UpdateProgressParams) (DocumentProgress, error) {
|
|
row := q.db.QueryRowContext(ctx, updateProgress,
|
|
arg.UserID,
|
|
arg.DocumentID,
|
|
arg.DeviceID,
|
|
arg.Percentage,
|
|
arg.Progress,
|
|
)
|
|
var i DocumentProgress
|
|
err := row.Scan(
|
|
&i.UserID,
|
|
&i.DocumentID,
|
|
&i.DeviceID,
|
|
&i.Percentage,
|
|
&i.Progress,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const upsertDevice = `-- name: UpsertDevice :one
|
|
INSERT INTO devices (id, user_id, device_name)
|
|
VALUES (?, ?, ?)
|
|
ON CONFLICT DO UPDATE
|
|
SET
|
|
device_name = COALESCE(excluded.device_name, device_name)
|
|
RETURNING id, user_id, device_name, created_at, sync
|
|
`
|
|
|
|
type UpsertDeviceParams struct {
|
|
ID string `json:"id"`
|
|
UserID string `json:"user_id"`
|
|
DeviceName string `json:"device_name"`
|
|
}
|
|
|
|
func (q *Queries) UpsertDevice(ctx context.Context, arg UpsertDeviceParams) (Device, error) {
|
|
row := q.db.QueryRowContext(ctx, upsertDevice, arg.ID, arg.UserID, arg.DeviceName)
|
|
var i Device
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.UserID,
|
|
&i.DeviceName,
|
|
&i.CreatedAt,
|
|
&i.Sync,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const upsertDocument = `-- name: UpsertDocument :one
|
|
INSERT INTO documents (
|
|
id,
|
|
md5,
|
|
filepath,
|
|
title,
|
|
author,
|
|
series,
|
|
series_index,
|
|
lang,
|
|
description,
|
|
olid
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
ON CONFLICT DO UPDATE
|
|
SET
|
|
md5 = COALESCE(excluded.md5, md5),
|
|
filepath = COALESCE(excluded.filepath, filepath),
|
|
title = COALESCE(excluded.title, title),
|
|
author = COALESCE(excluded.author, author),
|
|
series = COALESCE(excluded.series, series),
|
|
series_index = COALESCE(excluded.series_index, series_index),
|
|
lang = COALESCE(excluded.lang, lang),
|
|
description = COALESCE(excluded.description, description),
|
|
olid = COALESCE(excluded.olid, olid)
|
|
RETURNING id, md5, filepath, title, author, series, series_index, lang, description, olid, synced, deleted, updated_at, created_at
|
|
`
|
|
|
|
type UpsertDocumentParams struct {
|
|
ID string `json:"id"`
|
|
Md5 *string `json:"md5"`
|
|
Filepath *string `json:"filepath"`
|
|
Title *string `json:"title"`
|
|
Author *string `json:"author"`
|
|
Series *string `json:"series"`
|
|
SeriesIndex *int64 `json:"series_index"`
|
|
Lang *string `json:"lang"`
|
|
Description *string `json:"description"`
|
|
Olid *string `json:"-"`
|
|
}
|
|
|
|
func (q *Queries) UpsertDocument(ctx context.Context, arg UpsertDocumentParams) (Document, error) {
|
|
row := q.db.QueryRowContext(ctx, upsertDocument,
|
|
arg.ID,
|
|
arg.Md5,
|
|
arg.Filepath,
|
|
arg.Title,
|
|
arg.Author,
|
|
arg.Series,
|
|
arg.SeriesIndex,
|
|
arg.Lang,
|
|
arg.Description,
|
|
arg.Olid,
|
|
)
|
|
var i Document
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Md5,
|
|
&i.Filepath,
|
|
&i.Title,
|
|
&i.Author,
|
|
&i.Series,
|
|
&i.SeriesIndex,
|
|
&i.Lang,
|
|
&i.Description,
|
|
&i.Olid,
|
|
&i.Synced,
|
|
&i.Deleted,
|
|
&i.UpdatedAt,
|
|
&i.CreatedAt,
|
|
)
|
|
return i, err
|
|
}
|