146 lines
3.2 KiB
Go
146 lines
3.2 KiB
Go
package content
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"mediarr/database"
|
|
"mediarr/document"
|
|
"mediarr/ident"
|
|
"mediarr/permission"
|
|
"mediarr/storage"
|
|
)
|
|
|
|
type Service struct {
|
|
db database.DatabaseClient
|
|
store storage.Store
|
|
backendID ident.UUID
|
|
authorizer document.Authorizer
|
|
}
|
|
|
|
func NewService(db database.DatabaseClient, store storage.Store, backendID ident.UUID, authorizer document.Authorizer) *Service {
|
|
return &Service{
|
|
db: db,
|
|
store: store,
|
|
backendID: backendID,
|
|
authorizer: authorizer,
|
|
}
|
|
}
|
|
|
|
func (s *Service) withTx(ctx context.Context, fn func(*database.Queries) error) error {
|
|
tx, err := s.db.WriteDB.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() {
|
|
_ = tx.Rollback()
|
|
}()
|
|
|
|
if err := fn(s.db.WriteQueries.WithTx(tx)); err != nil {
|
|
return err
|
|
}
|
|
|
|
return tx.Commit()
|
|
}
|
|
|
|
func (s *Service) getDocument(ctx context.Context, id ident.UUID) (*database.Document, error) {
|
|
row, err := s.db.Queries.GetDocument(ctx, id)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, fmt.Errorf("%w: %s", document.ErrDocumentNotFound, id)
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return &row, nil
|
|
}
|
|
|
|
func (s *Service) getVersion(ctx context.Context, id ident.UUID) (*database.DocumentVersion, error) {
|
|
row, err := s.db.Queries.GetDocumentVersion(ctx, id)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, fmt.Errorf("%w: %s", ErrVersionNotFound, id)
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return &row, nil
|
|
}
|
|
|
|
func (s *Service) can(ctx context.Context, principalID, documentID ident.UUID, required permission.Permission) error {
|
|
allowed, err := s.authorizer.Can(ctx, principalID, documentID, required)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !allowed {
|
|
return fmt.Errorf("%w: %s sur %s", document.ErrPermissionDenied, principalID, documentID)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s *Service) setStagingState(ctx context.Context, id ident.UUID, state string) error {
|
|
return s.db.WriteQueries.UpdateStagingItemState(ctx, database.UpdateStagingItemStateParams{
|
|
State: state,
|
|
UpdatedAt: nowMillis(),
|
|
ID: id,
|
|
})
|
|
}
|
|
|
|
func versionFromDB(version database.DocumentVersion) *Version {
|
|
var mime string
|
|
if version.Mime.Valid {
|
|
mime = version.Mime.String
|
|
}
|
|
|
|
var message string
|
|
if version.Message.Valid {
|
|
message = version.Message.String
|
|
}
|
|
|
|
var purgedAt *int64
|
|
if version.ContentPurgedAt.Valid {
|
|
value := version.ContentPurgedAt.Int64
|
|
purgedAt = &value
|
|
}
|
|
|
|
return &Version{
|
|
ID: version.ID,
|
|
DocumentID: version.DocumentID,
|
|
Seq: version.Seq,
|
|
ContentRoot: version.ContentRoot,
|
|
Size: version.Size,
|
|
Mime: mime,
|
|
AuthorID: version.AuthorID,
|
|
DeviceID: version.DeviceID,
|
|
Origin: version.Origin,
|
|
Message: message,
|
|
Pinned: version.Pinned != 0,
|
|
ContentPurgedAt: purgedAt,
|
|
CreatedAt: version.CreatedAt,
|
|
}
|
|
}
|
|
|
|
func validOrigin(origin string) bool {
|
|
switch origin {
|
|
case OriginUpload, OriginImport, OriginMerge, OriginRestore, OriginSystem:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func stagingOrigin(origin string) string {
|
|
if origin == OriginImport {
|
|
return OriginImport
|
|
}
|
|
return OriginUpload
|
|
}
|
|
|
|
func nowMillis() int64 {
|
|
return time.Now().UnixMilli()
|
|
}
|