feat: add basic workings

internal/server/service/fileservice.go

@@ -2,10 +2,12 @@ package service
 
 import (
 	"io"
+	"log/slog"
 	"orbits-server/internal/server/api/assets"
 	"orbits-server/internal/server/bootstrap"
 	"orbits-server/internal/server/database"
 	"os"
+	"path/filepath"
 
 	"gorm.io/gorm"
 )
@@ -19,6 +21,35 @@ func NewFileService(db *gorm.DB, env bootstrap.Environment) *FileService {
 	return &FileService{db: db, env: env}
 }
 
+func (s *FileService) SyncFile(fp string) {
+	f, err := os.Open(fp)
+	if err != nil {
+		slog.Error("failed to open the file", "file", fp, "error", err)
+		return
+	}
+	defer f.Close()
+
+	fileData, err := database.BuildFileRecord(f, filepath.Base(fp), s.env.ContentDirectory)
+	if err != nil {
+		slog.Error("failed to build file record", "error", err)
+		return
+	}
+
+	if err := database.CreateFile(s.db, &fileData); err != nil {
+		slog.Error("failed to create file record", "error", err)
+		return
+	}
+
+	if err := os.Rename(fp, fileData.FilePath); err != nil {
+		// if this fails across mounts then try copy + delete
+		slog.Error("failed to move file", "error", err)
+
+		database.DeleteFileByID(s.db, fileData.ID)
+
+		return
+	}
+}
+
 func (s *FileService) ListFiles() ([]assets.FileResponse, error) {
 	fileRecords, err := database.ListFiles(s.db)
 	if err != nil {
@@ -32,7 +63,7 @@ func (s *FileService) ListFiles() ([]assets.FileResponse, error) {
 			ID:        f.ID,
 			MetaName:  f.MetaName,
 			MediaType: string(f.MediaType),
-			FileName:  f.FileName,
+			FileID:    f.FileID,
 			FilePath:  f.FilePath,
 			Checksum:  f.Checksum,
 			CreatedAt: f.CreatedAt,
@@ -57,7 +88,7 @@ func (s *FileService) Create(r io.Reader, filename string) (assets.FileResponse,
 		ID:        f.ID,
 		MetaName:  f.MetaName,
 		MediaType: string(f.MediaType),
-		FileName:  f.FileName,
+		FileID:    f.FileID,
 		FilePath:  f.FilePath,
 		Checksum:  f.Checksum,
 		CreatedAt: f.CreatedAt,
@@ -68,7 +99,7 @@ func (s *FileService) Create(r io.Reader, filename string) (assets.FileResponse,
 }
 
 func (s *FileService) DeleteByName(filename string) error {
-	fileRecord, err := database.FindFileByName(s.db, filename)
+	fileRecord, err := database.FindFileByFileID(s.db, filename)
 	if err != nil {
 		return err
 	}

internal/server/service/keyservice.go

@@ -4,6 +4,7 @@ import (
 	"orbits-server/internal/server/api/assets"
 	"orbits-server/internal/server/database"
 	"orbits-server/internal/shared/security"
+	"strings"
 	"time"
 
 	"gorm.io/gorm"
@@ -23,20 +24,6 @@ func NewKeyService(db *gorm.DB) *KeyService {
 	}
 }
 
-func (s *KeyService) ListValidKeyHashes() ([]string, error) {
-	keyRecords, err := database.ListKeys(s.db)
-	if err != nil {
-		return nil, err
-	}
-
-	hashList := make([]string, 0, len(keyRecords))
-	for _, k := range keyRecords {
-		hashList = append(hashList, k.KeyHash)
-	}
-
-	return hashList, nil
-}
-
 func (s *KeyService) Create(name string, expiresAt time.Time) (assets.KeyResponse, error) {
 	keyContent := security.GenerateChars(accessKeyLen)
 
@@ -45,27 +32,55 @@ func (s *KeyService) Create(name string, expiresAt time.Time) (assets.KeyRespons
 		return assets.KeyResponse{}, err
 	}
 
-	keyRecord := database.BuildKeyRecord(hash, name, expiresAt)
+	keyRecord, err := database.BuildKeyRecord(hash, name, expiresAt)
+	if err != nil {
+		return assets.KeyResponse{}, err
+	}
 
 	if err := database.CreateKey(s.db, &keyRecord); err != nil {
 		return assets.KeyResponse{}, err
 	}
 
 	keyResponse := assets.KeyResponse{
-		ID:         keyRecord.ID,
-		MetaName:   keyRecord.MetaName,
-		KeyName:    keyRecord.KeyName,
-		KeyContent: keyContent,
-		CreatedAt:  keyRecord.CreatedAt,
-		UpdatedAt:  keyRecord.UpdatedAt,
-		ExpiresAt:  keyRecord.ExpiresAt,
+		ID:        keyRecord.ID,
+		MetaName:  keyRecord.MetaName,
+		KeyID:     keyRecord.KeyID,
+		KeySecret: keyContent,
+		CreatedAt: keyRecord.CreatedAt,
+		UpdatedAt: keyRecord.UpdatedAt,
+		ExpiresAt: keyRecord.ExpiresAt,
 	}
 
 	return keyResponse, nil
 }
 
+func (s *KeyService) Validate(token string) bool {
+	parts := strings.SplitN(token, ".", 2)
+	if len(parts) != 2 {
+		return false
+	}
+
+	keyID := parts[0]
+	secret := parts[1]
+
+	key, err := database.FindKeyByKeyID(s.db, keyID)
+	if err != nil {
+		return false
+	}
+
+	if key.Revoked || time.Now().After(key.ExpiresAt) {
+		return false
+	}
+
+	if !security.CompareKey(key.KeyHash, secret) {
+		return false
+	}
+
+	return true
+}
+
 func (s *KeyService) DeleteByName(name string) error {
-	keyRecord, err := database.FindKeyByName(s.db, name)
+	keyRecord, err := database.FindKeyByKeyID(s.db, name)
 	if err != nil {
 		return err
 	}