mirror of
https://codeberg.org/shroff/phylum.git
synced 2026-01-15 16:40:30 -06:00
495 lines
12 KiB
Go
495 lines
12 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.26.0
|
|
// source: fs.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
const childResourceIDByName = `-- name: ChildResourceIDByName :one
|
|
SELECT id FROM resources WHERE parent = $1::uuid AND name = $2::text AND deleted IS NULL
|
|
`
|
|
|
|
type ChildResourceIDByNameParams struct {
|
|
Parent uuid.UUID
|
|
Name string
|
|
}
|
|
|
|
func (q *Queries) ChildResourceIDByName(ctx context.Context, arg ChildResourceIDByNameParams) (uuid.UUID, error) {
|
|
row := q.db.QueryRow(ctx, childResourceIDByName, arg.Parent, arg.Name)
|
|
var id uuid.UUID
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const createResource = `-- name: CreateResource :one
|
|
INSERT INTO resources(
|
|
id, parent, name, dir, content_type, content_sha256
|
|
) VALUES (
|
|
$1::uuid, $2::uuid, $3::text, $4::boolean,
|
|
CASE $4 WHEN TRUE THEN '' ELSE 'text/plain' END,
|
|
CASE $4 WhEN TRUE THEN '' ELSE 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' END
|
|
) RETURNING id, permissions, name, parent, dir, created, modified, deleted, content_size, content_type, content_sha256
|
|
`
|
|
|
|
type CreateResourceParams struct {
|
|
ID uuid.UUID
|
|
Parent *uuid.UUID
|
|
Name string
|
|
Dir bool
|
|
}
|
|
|
|
func (q *Queries) CreateResource(ctx context.Context, arg CreateResourceParams) (Resource, error) {
|
|
row := q.db.QueryRow(ctx, createResource,
|
|
arg.ID,
|
|
arg.Parent,
|
|
arg.Name,
|
|
arg.Dir,
|
|
)
|
|
var i Resource
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Permissions,
|
|
&i.Name,
|
|
&i.Parent,
|
|
&i.Dir,
|
|
&i.Created,
|
|
&i.Modified,
|
|
&i.Deleted,
|
|
&i.ContentSize,
|
|
&i.ContentType,
|
|
&i.ContentSha256,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
type CreateResourcesParams struct {
|
|
ID uuid.UUID
|
|
Parent uuid.UUID
|
|
Name string
|
|
Dir bool
|
|
ContentSize int64
|
|
ContentType string
|
|
ContentSha256 string
|
|
}
|
|
|
|
const deleteRecursive = `-- name: DeleteRecursive :many
|
|
WITH RECURSIVE nodes(id, parent, dir) AS (
|
|
SELECT r.id, r.parent, r.dir
|
|
FROM resources r WHERE r.id = $1::uuid
|
|
UNION ALL
|
|
SELECT r.id, r.parent, r.dir
|
|
FROM resources r JOIN nodes n on r.parent = n.id
|
|
WHERE deleted IS NULL
|
|
)
|
|
UPDATE resources
|
|
SET modified = NOW(), deleted = NOW()
|
|
WHERE id in (SELECT id FROM nodes)
|
|
RETURNING id, dir
|
|
`
|
|
|
|
type DeleteRecursiveRow struct {
|
|
ID uuid.UUID
|
|
Dir bool
|
|
}
|
|
|
|
func (q *Queries) DeleteRecursive(ctx context.Context, id uuid.UUID) ([]DeleteRecursiveRow, error) {
|
|
rows, err := q.db.Query(ctx, deleteRecursive, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []DeleteRecursiveRow
|
|
for rows.Next() {
|
|
var i DeleteRecursiveRow
|
|
if err := rows.Scan(&i.ID, &i.Dir); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const diskUsage = `-- name: DiskUsage :one
|
|
WITH RECURSIVE nodes(id, parent, content_size, dir) AS (
|
|
SELECT r.id, r.parent, r.content_size, r.dir
|
|
FROM resources r WHERE r.id = $1::uuid
|
|
UNION ALL
|
|
SELECT r.id, r.parent, r.content_size, r.dir
|
|
FROM resources r JOIN nodes n on r.parent = n.id
|
|
WHERE deleted IS NULL
|
|
)
|
|
SELECT
|
|
SUM(content_size) AS size,
|
|
COUNT(*) AS entities,
|
|
COUNT(CASE dir WHEN true THEN 1 ELSE NULL END) AS dirs,
|
|
COUNT(CASE dir WHEN false THEN 1 ELSE NULL END) AS files
|
|
FROM nodes
|
|
`
|
|
|
|
type DiskUsageRow struct {
|
|
Size int64
|
|
Entities int64
|
|
Dirs int64
|
|
Files int64
|
|
}
|
|
|
|
func (q *Queries) DiskUsage(ctx context.Context, id uuid.UUID) (DiskUsageRow, error) {
|
|
row := q.db.QueryRow(ctx, diskUsage, id)
|
|
var i DiskUsageRow
|
|
err := row.Scan(
|
|
&i.Size,
|
|
&i.Entities,
|
|
&i.Dirs,
|
|
&i.Files,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const readDir = `-- name: ReadDir :many
|
|
SELECT id, permissions, name, parent, dir, created, modified, deleted, content_size, content_type, content_sha256, publinks from readdir($1::uuid, $2::int, $3::int)
|
|
`
|
|
|
|
type ReadDirParams struct {
|
|
ResourceID uuid.UUID
|
|
MinDepth int32
|
|
MaxDepth int32
|
|
}
|
|
|
|
func (q *Queries) ReadDir(ctx context.Context, arg ReadDirParams) ([]PublinkedResource, error) {
|
|
rows, err := q.db.Query(ctx, readDir, arg.ResourceID, arg.MinDepth, arg.MaxDepth)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []PublinkedResource
|
|
for rows.Next() {
|
|
var i PublinkedResource
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Permissions,
|
|
&i.Name,
|
|
&i.Parent,
|
|
&i.Dir,
|
|
&i.Created,
|
|
&i.Modified,
|
|
&i.Deleted,
|
|
&i.ContentSize,
|
|
&i.ContentType,
|
|
&i.ContentSha256,
|
|
&i.Publinks,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const removeUserPermissionForResource = `-- name: RemoveUserPermissionForResource :one
|
|
UPDATE resources
|
|
SET
|
|
permissions = permissions - $1::text,
|
|
modified = NOW()
|
|
WHERE id = $2::uuid
|
|
RETURNING permissions
|
|
`
|
|
|
|
type RemoveUserPermissionForResourceParams struct {
|
|
Username string
|
|
ResourceID uuid.UUID
|
|
}
|
|
|
|
func (q *Queries) RemoveUserPermissionForResource(ctx context.Context, arg RemoveUserPermissionForResourceParams) ([]byte, error) {
|
|
row := q.db.QueryRow(ctx, removeUserPermissionForResource, arg.Username, arg.ResourceID)
|
|
var permissions []byte
|
|
err := row.Scan(&permissions)
|
|
return permissions, err
|
|
}
|
|
|
|
const resourceByID = `-- name: ResourceByID :many
|
|
SELECT id, permissions, name, parent, dir, created, modified, deleted, content_size, content_type, content_sha256, publinks FROM resource_by_id($1::uuid)
|
|
`
|
|
|
|
func (q *Queries) ResourceByID(ctx context.Context, resourceID uuid.UUID) ([]PublinkedResource, error) {
|
|
rows, err := q.db.Query(ctx, resourceByID, resourceID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []PublinkedResource
|
|
for rows.Next() {
|
|
var i PublinkedResource
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Permissions,
|
|
&i.Name,
|
|
&i.Parent,
|
|
&i.Dir,
|
|
&i.Created,
|
|
&i.Modified,
|
|
&i.Deleted,
|
|
&i.ContentSize,
|
|
&i.ContentType,
|
|
&i.ContentSha256,
|
|
&i.Publinks,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const resourceByPath = `-- name: ResourceByPath :many
|
|
SELECT id, permissions, name, parent, dir, created, modified, deleted, content_size, content_type, content_sha256, publinks FROM resource_by_id(resource_id_by_path($1::text, $2::uuid))
|
|
`
|
|
|
|
type ResourceByPathParams struct {
|
|
Path string
|
|
Root *uuid.UUID
|
|
}
|
|
|
|
func (q *Queries) ResourceByPath(ctx context.Context, arg ResourceByPathParams) ([]PublinkedResource, error) {
|
|
rows, err := q.db.Query(ctx, resourceByPath, arg.Path, arg.Root)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []PublinkedResource
|
|
for rows.Next() {
|
|
var i PublinkedResource
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Permissions,
|
|
&i.Name,
|
|
&i.Parent,
|
|
&i.Dir,
|
|
&i.Created,
|
|
&i.Modified,
|
|
&i.Deleted,
|
|
&i.ContentSize,
|
|
&i.ContentType,
|
|
&i.ContentSha256,
|
|
&i.Publinks,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const sharedResources = `-- name: SharedResources :many
|
|
SELECT id, permissions, name, parent, dir, created, modified, deleted, content_size, content_type, content_sha256 FROM resources WHERE permissions ? $1::text AND id <> $2::uuid AND deleted IS NULL
|
|
`
|
|
|
|
type SharedResourcesParams struct {
|
|
Username string
|
|
UserHome uuid.UUID
|
|
}
|
|
|
|
func (q *Queries) SharedResources(ctx context.Context, arg SharedResourcesParams) ([]Resource, error) {
|
|
rows, err := q.db.Query(ctx, sharedResources, arg.Username, arg.UserHome)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Resource
|
|
for rows.Next() {
|
|
var i Resource
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Permissions,
|
|
&i.Name,
|
|
&i.Parent,
|
|
&i.Dir,
|
|
&i.Created,
|
|
&i.Modified,
|
|
&i.Deleted,
|
|
&i.ContentSize,
|
|
&i.ContentType,
|
|
&i.ContentSha256,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const updateResourceContents = `-- name: UpdateResourceContents :exec
|
|
UPDATE resources
|
|
SET
|
|
content_size = $1,
|
|
content_type = $2,
|
|
content_sha256 = $3,
|
|
modified = NOW()
|
|
WHERE id = $4
|
|
`
|
|
|
|
type UpdateResourceContentsParams struct {
|
|
ContentSize int64
|
|
ContentType string
|
|
ContentSha256 string
|
|
ID uuid.UUID
|
|
}
|
|
|
|
func (q *Queries) UpdateResourceContents(ctx context.Context, arg UpdateResourceContentsParams) error {
|
|
_, err := q.db.Exec(ctx, updateResourceContents,
|
|
arg.ContentSize,
|
|
arg.ContentType,
|
|
arg.ContentSha256,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const updateResourceModified = `-- name: UpdateResourceModified :exec
|
|
UPDATE resources
|
|
SET
|
|
modified = NOW()
|
|
WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) UpdateResourceModified(ctx context.Context, id uuid.UUID) error {
|
|
_, err := q.db.Exec(ctx, updateResourceModified, id)
|
|
return err
|
|
}
|
|
|
|
const updateResourceName = `-- name: UpdateResourceName :one
|
|
UPDATE resources
|
|
SET
|
|
name = CASE WHEN ($1::text = '') THEN name ELSE $1::text END,
|
|
modified = NOW()
|
|
WHERE id = $2::uuid
|
|
RETURNING id, permissions, name, parent, dir, created, modified, deleted, content_size, content_type, content_sha256
|
|
`
|
|
|
|
type UpdateResourceNameParams struct {
|
|
Name string
|
|
ID uuid.UUID
|
|
}
|
|
|
|
func (q *Queries) UpdateResourceName(ctx context.Context, arg UpdateResourceNameParams) (Resource, error) {
|
|
row := q.db.QueryRow(ctx, updateResourceName, arg.Name, arg.ID)
|
|
var i Resource
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Permissions,
|
|
&i.Name,
|
|
&i.Parent,
|
|
&i.Dir,
|
|
&i.Created,
|
|
&i.Modified,
|
|
&i.Deleted,
|
|
&i.ContentSize,
|
|
&i.ContentType,
|
|
&i.ContentSha256,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const updateResourceNameParent = `-- name: UpdateResourceNameParent :one
|
|
UPDATE resources
|
|
SET
|
|
name = CASE WHEN ($1::text = '') THEN name ELSE $1::text END,
|
|
parent = $2::uuid,
|
|
modified = NOW()
|
|
WHERE id = $3::uuid
|
|
RETURNING name, parent
|
|
`
|
|
|
|
type UpdateResourceNameParentParams struct {
|
|
Name string
|
|
Parent uuid.UUID
|
|
ID uuid.UUID
|
|
}
|
|
|
|
type UpdateResourceNameParentRow struct {
|
|
Name string
|
|
Parent *uuid.UUID
|
|
}
|
|
|
|
func (q *Queries) UpdateResourceNameParent(ctx context.Context, arg UpdateResourceNameParentParams) (UpdateResourceNameParentRow, error) {
|
|
row := q.db.QueryRow(ctx, updateResourceNameParent, arg.Name, arg.Parent, arg.ID)
|
|
var i UpdateResourceNameParentRow
|
|
err := row.Scan(&i.Name, &i.Parent)
|
|
return i, err
|
|
}
|
|
|
|
const updateResourceParent = `-- name: UpdateResourceParent :one
|
|
UPDATE resources
|
|
SET
|
|
parent = $1::uuid,
|
|
modified = NOW()
|
|
WHERE id = $2::uuid
|
|
RETURNING id, permissions, name, parent, dir, created, modified, deleted, content_size, content_type, content_sha256
|
|
`
|
|
|
|
type UpdateResourceParentParams struct {
|
|
Parent uuid.UUID
|
|
ID uuid.UUID
|
|
}
|
|
|
|
func (q *Queries) UpdateResourceParent(ctx context.Context, arg UpdateResourceParentParams) (Resource, error) {
|
|
row := q.db.QueryRow(ctx, updateResourceParent, arg.Parent, arg.ID)
|
|
var i Resource
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Permissions,
|
|
&i.Name,
|
|
&i.Parent,
|
|
&i.Dir,
|
|
&i.Created,
|
|
&i.Modified,
|
|
&i.Deleted,
|
|
&i.ContentSize,
|
|
&i.ContentType,
|
|
&i.ContentSha256,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const updateUserPermissionsForResource = `-- name: UpdateUserPermissionsForResource :one
|
|
UPDATE resources
|
|
SET
|
|
permissions[$1::text] = to_json($2::int),
|
|
modified = NOW()
|
|
WHERE id = $3::uuid
|
|
RETURNING permissions
|
|
`
|
|
|
|
type UpdateUserPermissionsForResourceParams struct {
|
|
Username string
|
|
Permission int32
|
|
ResourceID uuid.UUID
|
|
}
|
|
|
|
func (q *Queries) UpdateUserPermissionsForResource(ctx context.Context, arg UpdateUserPermissionsForResourceParams) ([]byte, error) {
|
|
row := q.db.QueryRow(ctx, updateUserPermissionsForResource, arg.Username, arg.Permission, arg.ResourceID)
|
|
var permissions []byte
|
|
err := row.Scan(&permissions)
|
|
return permissions, err
|
|
}
|