300 lines
9.0 KiB
Go
300 lines
9.0 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"fmt"
|
|
"mime"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"verstak/internal/core/activity"
|
|
"verstak/internal/core/files"
|
|
"verstak/internal/core/nodes"
|
|
syncsvc "verstak/internal/core/sync"
|
|
"verstak/internal/core/templates"
|
|
"verstak/internal/core/util"
|
|
)
|
|
|
|
func (a *App) CaptureText(text string) (*InboxNodeDTO, error) {
|
|
if err := a.requireVault(); err != nil {
|
|
return nil, err
|
|
}
|
|
text = strings.TrimSpace(text)
|
|
if text == "" {
|
|
return nil, fmt.Errorf("text required")
|
|
}
|
|
title := firstLineTitle(text, "Captured text")
|
|
content := "# " + title + "\n\n" + text + "\n"
|
|
return a.createCaptureNote(title, content, "text", "clipboard")
|
|
}
|
|
|
|
func (a *App) CaptureURL(rawURL, title string) (*InboxNodeDTO, error) {
|
|
if err := a.requireVault(); err != nil {
|
|
return nil, err
|
|
}
|
|
rawURL = strings.TrimSpace(rawURL)
|
|
if rawURL == "" {
|
|
return nil, fmt.Errorf("url required")
|
|
}
|
|
title = strings.TrimSpace(title)
|
|
if title == "" {
|
|
title = rawURL
|
|
}
|
|
title = firstLineTitle(title, rawURL)
|
|
content := "# " + title + "\n\n" + rawURL + "\n"
|
|
return a.createCaptureNote(title, content, "url", "clipboard")
|
|
}
|
|
|
|
func (a *App) CapturePath(sourcePath string) (*InboxNodeDTO, error) {
|
|
if err := a.requireVault(); err != nil {
|
|
return nil, err
|
|
}
|
|
sourcePath = strings.TrimSpace(sourcePath)
|
|
if sourcePath == "" {
|
|
return nil, fmt.Errorf("path required")
|
|
}
|
|
absPath, err := filepath.Abs(sourcePath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("abs path: %w", err)
|
|
}
|
|
info, err := os.Stat(absPath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("stat: %w", err)
|
|
}
|
|
|
|
nodeType := nodes.TypeFile
|
|
kind := captureKindForFilename(absPath)
|
|
if info.IsDir() {
|
|
nodeType = nodes.TypeFolder
|
|
kind = "folder"
|
|
}
|
|
node, err := a.nodes.Create(nil, nodeType, filepath.Base(absPath), 0, "", "")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create capture node: %w", err)
|
|
}
|
|
stagingRel, _, err := a.captureStagingDir(node)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if info.IsDir() {
|
|
if err := a.nodes.UpdateFsPath(node.ID, stagingRel); err != nil {
|
|
return nil, fmt.Errorf("set capture folder path: %w", err)
|
|
}
|
|
entries, err := os.ReadDir(absPath)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("read source dir: %w", err)
|
|
}
|
|
for _, entry := range entries {
|
|
if _, err := a.files.AddPathCopy(node.ID, filepath.Join(absPath, entry.Name())); err != nil {
|
|
return nil, fmt.Errorf("copy capture child %s: %w", entry.Name(), err)
|
|
}
|
|
}
|
|
} else {
|
|
if _, err := a.files.CopyIntoVault(node.ID, absPath, stagingRel); err != nil {
|
|
return nil, fmt.Errorf("copy capture file: %w", err)
|
|
}
|
|
}
|
|
|
|
if err := a.setCaptureMeta(node.ID, kind, "drop"); err != nil {
|
|
return nil, err
|
|
}
|
|
target := activity.TargetFile
|
|
evType := activity.TypeFileAdded
|
|
entity := syncsvc.EntityFile
|
|
if info.IsDir() {
|
|
target = activity.TargetFolder
|
|
evType = activity.TypeFolderAdded
|
|
entity = syncsvc.EntityFolder
|
|
}
|
|
_ = a.activity.Record("", target, node.ID, "", evType, node.Title, `{"capture":true}`)
|
|
_ = a.sync.RecordOp(entity, node.ID, syncsvc.OpCreate, a.filePayload(node))
|
|
return a.inboxNodeDTO(node)
|
|
}
|
|
|
|
func (a *App) CaptureFileData(filename, dataBase64 string) (*InboxNodeDTO, error) {
|
|
if err := a.requireVault(); err != nil {
|
|
return nil, err
|
|
}
|
|
filename = filepath.Base(strings.TrimSpace(filename))
|
|
if filename == "." || filename == "" {
|
|
filename = "clipboard.bin"
|
|
}
|
|
if err := files.ValidateName(filename); err != nil {
|
|
return nil, err
|
|
}
|
|
if comma := strings.Index(dataBase64, ","); comma >= 0 {
|
|
dataBase64 = dataBase64[comma+1:]
|
|
}
|
|
data, err := base64.StdEncoding.DecodeString(strings.TrimSpace(dataBase64))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("decode file data: %w", err)
|
|
}
|
|
if len(data) == 0 {
|
|
return nil, fmt.Errorf("file data required")
|
|
}
|
|
|
|
node, err := a.nodes.Create(nil, nodes.TypeFile, filename, 0, "", "")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create capture file node: %w", err)
|
|
}
|
|
stagingRel, stagingAbs, err := a.captureStagingDir(node)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
absPath := filepath.Join(stagingAbs, filename)
|
|
if err := os.WriteFile(absPath, data, 0o640); err != nil {
|
|
return nil, fmt.Errorf("write capture data: %w", err)
|
|
}
|
|
relPath := filepath.Join(stagingRel, filename)
|
|
fileRec := &files.Record{
|
|
ID: util.UUID7(),
|
|
NodeID: node.ID,
|
|
Filename: filename,
|
|
Path: relPath,
|
|
StorageMode: "vault",
|
|
Size: int64(len(data)),
|
|
MIME: mimeForFilename(filename),
|
|
CreatedAt: time.Now().UTC(),
|
|
UpdatedAt: time.Now().UTC(),
|
|
}
|
|
if _, err := a.db.Exec(
|
|
`INSERT INTO files (id,node_id,filename,path,storage_mode,size,mime,created_at,updated_at,missing)
|
|
VALUES (?,?,?,?,?,?,?,?,?,0)`,
|
|
fileRec.ID, fileRec.NodeID, fileRec.Filename, fileRec.Path, fileRec.StorageMode,
|
|
fileRec.Size, fileRec.MIME, fileRec.CreatedAt.Format(time.RFC3339), fileRec.UpdatedAt.Format(time.RFC3339)); err != nil {
|
|
return nil, fmt.Errorf("insert capture file data: %w", err)
|
|
}
|
|
if err := a.setCaptureMeta(node.ID, captureKindForFilename(filename), "clipboard"); err != nil {
|
|
return nil, err
|
|
}
|
|
_ = a.activity.Record("", activity.TargetFile, node.ID, "", activity.TypeFileAdded, filename, `{"capture":true}`)
|
|
_ = a.sync.RecordOp(syncsvc.EntityFile, node.ID, syncsvc.OpCreate, a.filePayload(node))
|
|
return a.inboxNodeDTO(node)
|
|
}
|
|
|
|
func (a *App) createCaptureNote(title, content, kind, source string) (*InboxNodeDTO, error) {
|
|
node, err := a.nodes.Create(nil, nodes.TypeNote, title, 0, "", "")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create node: %w", err)
|
|
}
|
|
|
|
inboxDir := filepath.Join(a.vault, ".verstak", "inbox")
|
|
if err := os.MkdirAll(inboxDir, 0o750); err != nil {
|
|
return nil, fmt.Errorf("create inbox dir: %w", err)
|
|
}
|
|
filename := node.ID + ".md"
|
|
absPath := filepath.Join(inboxDir, filename)
|
|
if err := os.WriteFile(absPath, []byte(content), 0o640); err != nil {
|
|
return nil, fmt.Errorf("write capture note: %w", err)
|
|
}
|
|
relPath, _ := filepath.Rel(a.vault, absPath)
|
|
now := time.Now().UTC()
|
|
fileRec := &files.Record{
|
|
ID: util.UUID7(),
|
|
NodeID: node.ID,
|
|
Filename: filename,
|
|
Path: relPath,
|
|
StorageMode: "vault",
|
|
Size: int64(len(content)),
|
|
MIME: "text/markdown",
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
}
|
|
if _, err := a.db.Exec(
|
|
`INSERT INTO files (id,node_id,filename,path,storage_mode,size,mime,created_at,updated_at,missing)
|
|
VALUES (?,?,?,?,?,?,?,?,?,0)`,
|
|
fileRec.ID, fileRec.NodeID, fileRec.Filename, fileRec.Path, fileRec.StorageMode,
|
|
fileRec.Size, fileRec.MIME, fileRec.CreatedAt.Format(time.RFC3339), fileRec.UpdatedAt.Format(time.RFC3339)); err != nil {
|
|
return nil, fmt.Errorf("insert capture file: %w", err)
|
|
}
|
|
if _, err := a.db.Exec(`INSERT INTO notes (node_id, file_id, format) VALUES (?,?,?)`, node.ID, fileRec.ID, "markdown"); err != nil {
|
|
return nil, fmt.Errorf("insert capture note: %w", err)
|
|
}
|
|
if err := a.setCaptureMeta(node.ID, kind, source); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
_ = a.activity.Record("", activity.TargetNote, node.ID, "", activity.TypeNoteCreated, title, `{"capture":true}`)
|
|
_ = a.sync.RecordOp(syncsvc.EntityNote, node.ID, syncsvc.OpCreate, notePayload(node, fileRec, content))
|
|
|
|
return a.inboxNodeDTO(node)
|
|
}
|
|
|
|
func (a *App) captureStagingDir(node *nodes.Node) (string, string, error) {
|
|
segment := node.ID + "_" + templates.SafeDisplayNameToPathSegment(node.Title)
|
|
rel := filepath.Join(".verstak", "inbox", segment)
|
|
abs := filepath.Join(a.vault, rel)
|
|
if err := os.MkdirAll(abs, 0o750); err != nil {
|
|
return "", "", fmt.Errorf("create inbox staging dir: %w", err)
|
|
}
|
|
return rel, abs, nil
|
|
}
|
|
|
|
func (a *App) setCaptureMeta(nodeID, kind, source string) error {
|
|
if err := a.nodes.MetaSet(nodeID, "capture.inbox", "true"); err != nil {
|
|
return err
|
|
}
|
|
if err := a.nodes.MetaSet(nodeID, "capture.kind", kind); err != nil {
|
|
return err
|
|
}
|
|
if err := a.nodes.MetaSet(nodeID, "capture.source", source); err != nil {
|
|
return err
|
|
}
|
|
return a.nodes.MetaSet(nodeID, "capture.created_at", time.Now().UTC().Format(time.RFC3339))
|
|
}
|
|
|
|
func (a *App) inboxNodeDTO(n *nodes.Node) (*InboxNodeDTO, error) {
|
|
dto := &InboxNodeDTO{NodeDTO: toNodeDTO(n)}
|
|
if kind, ok, err := a.nodes.MetaGet(n.ID, "capture.kind"); err == nil && ok {
|
|
dto.CaptureKind = kind
|
|
}
|
|
if source, ok, err := a.nodes.MetaGet(n.ID, "capture.source"); err == nil && ok {
|
|
dto.CaptureSource = source
|
|
}
|
|
return dto, nil
|
|
}
|
|
|
|
func captureKindForFilename(filename string) string {
|
|
if strings.HasPrefix(mimeForFilename(filename), "image/") {
|
|
return "image"
|
|
}
|
|
return "file"
|
|
}
|
|
|
|
func mimeForFilename(filename string) string {
|
|
ext := strings.ToLower(filepath.Ext(filename))
|
|
switch ext {
|
|
case ".png":
|
|
return "image/png"
|
|
case ".jpg", ".jpeg":
|
|
return "image/jpeg"
|
|
case ".gif":
|
|
return "image/gif"
|
|
case ".webp":
|
|
return "image/webp"
|
|
}
|
|
if mimeType := mime.TypeByExtension(ext); mimeType != "" {
|
|
if semi := strings.Index(mimeType, ";"); semi >= 0 {
|
|
return mimeType[:semi]
|
|
}
|
|
return mimeType
|
|
}
|
|
return "application/octet-stream"
|
|
}
|
|
|
|
func firstLineTitle(text, fallback string) string {
|
|
for _, line := range strings.Split(text, "\n") {
|
|
line = strings.TrimSpace(line)
|
|
if line != "" {
|
|
if len(line) > 80 {
|
|
return line[:80]
|
|
}
|
|
return line
|
|
}
|
|
}
|
|
return fallback
|
|
}
|