public/photoview
1
0
Fork 0
mirror of https://git.vectorsigma.ru/public/photoview.git synced 2026-08-03 21:59:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace database, mostly media and video

Browse Source
This commit is contained in:
viktorstrate
2020-11-26 20:48:04 +01:00
parent 177ae91500
commit 2b966aa672
7 changed files with 73 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
api/graphql/models/media.go
View File

@@ -14,9 +14,9 @@ type Media struct {
Title string
Path string
PathHash string
AlbumId uint
AlbumID uint
Album Album
ExifId *uint
ExifID *uint
Exif MediaEXIF
MediaURL []MediaURL
DateShot time.Time

44
api/graphql/models/share_token.go
View File

@@ -1,52 +1,24 @@
package models
import (
"database/sql"
"time"
"github.com/pkg/errors"
"gorm.io/gorm"
)
type ShareToken struct {
TokenID int
gorm.Model
Value string
OwnerID int
OwnerID uint
Owner User
Expire *time.Time
Password *string
AlbumID *int
MediaID *int
AlbumID *uint
Album Album
MediaID *uint
Media *Media
}
func (share *ShareToken) Token() string {
return share.Value
}
func (share *ShareToken) ID() int {
return share.TokenID
}
func NewShareTokenFromRow(row *sql.Row) (*ShareToken, error) {
token := ShareToken{}
if err := row.Scan(&token.TokenID, &token.Value, &token.OwnerID, &token.Expire, &token.Password, &token.AlbumID, &token.MediaID); err != nil {
return nil, errors.Wrap(err, "failed to scan share token from database")
}
return &token, nil
}
func NewShareTokensFromRows(rows *sql.Rows) ([]*ShareToken, error) {
tokens := make([]*ShareToken, 0)
for rows.Next() {
var token ShareToken
if err := rows.Scan(&token.TokenID, &token.Value, &token.OwnerID, &token.Expire, &token.Password, &token.AlbumID, &token.MediaID); err != nil {
return nil, errors.Wrap(err, "failed to scan share tokens from database")
}
tokens = append(tokens, &token)
}
rows.Close()
return tokens, nil
}

34
api/routes/authenticate_media.go
View File

@@ -1,7 +1,6 @@
package routes
import (
"database/sql"
"fmt"
"net/http"
@@ -15,14 +14,12 @@ func authenticateMedia(media *models.Media, db *gorm.DB, r *http.Request) (succe
user := auth.UserFromContext(r.Context())
if user != nil {
row := db.QueryRow("SELECT owner_id FROM album WHERE album.album_id = ?", media.AlbumId)
var owner_id int
if err := row.Scan(&owner_id); err != nil {
var album models.Album
if err := db.First(&album, media.AlbumID).Error; err != nil {
return false, "internal server error", http.StatusInternalServerError, err
}
if owner_id != user.UserID {
if album.OwnerID != user.ID {
return false, "invalid credentials", http.StatusForbidden, nil
}
} else {
@@ -32,10 +29,8 @@ func authenticateMedia(media *models.Media, db *gorm.DB, r *http.Request) (succe
return false, "unauthorized", http.StatusForbidden, nil
}
row := db.QueryRow("SELECT * FROM share_token WHERE value = ?", token)
shareToken, err := models.NewShareTokenFromRow(row)
if err != nil {
var shareToken models.ShareToken
if err := db.Where("value = ?", token).First(&shareToken).Error; err != nil {
return false, "internal server error", http.StatusInternalServerError, err
}
@@ -57,27 +52,28 @@ func authenticateMedia(media *models.Media, db *gorm.DB, r *http.Request) (succe
}
}
if shareToken.AlbumID != nil && media.AlbumId != *shareToken.AlbumID {
if shareToken.AlbumID != nil && media.ID != *shareToken.AlbumID {
// Check child albums
row := db.QueryRow(`
result := db.Raw(`
WITH recursive child_albums AS (
SELECT * FROM album WHERE parent_album = ?
UNION ALL
SELECT child.* FROM album child JOIN child_albums parent ON parent.album_id = child.parent_album
)
SELECT * FROM child_albums WHERE album_id = ?
`, *shareToken.AlbumID, media.AlbumId)
`, *shareToken.AlbumID, media.AlbumID)
_, err := models.NewAlbumFromRow(row)
if err != nil {
if err == sql.ErrNoRows {
return false, "unauthorized", http.StatusForbidden, nil
}
if err := result.Error; err != nil {
return false, "internal server error", http.StatusInternalServerError, err
}
if result.RowsAffected == 0 {
return false, "unauthorized", http.StatusForbidden, nil
}
}
if shareToken.MediaID != nil && media.MediaID != *shareToken.MediaID {
if shareToken.MediaID != nil && media.ID != *shareToken.MediaID {
return false, "unauthorized", http.StatusForbidden, nil
}
}

65
api/routes/photos.go
View File

@@ -17,25 +17,17 @@ import (
func RegisterPhotoRoutes(db *gorm.DB, router *mux.Router) {
router.HandleFunc("/{name}", func(w http.ResponseWriter, r *http.Request) {
media_name := mux.Vars(r)["name"]
mediaName := mux.Vars(r)["name"]
row := db.QueryRow("SELECT media_url.* FROM media_url JOIN media ON media_url.media_id = media.media_id WHERE media_url.media_name = ?", media_name)
mediaUrl, err := models.NewMediaURLFromRow(row)
if err != nil {
var mediaURL models.MediaURL
result := db.Model(&models.MediaURL{}).Select("media_urls.*").Where("media_url.media_name = ?", mediaName).Joins("JOIN media ON media_urls.media_id = media.id").Scan(&mediaURL)
if err := result.Error; err != nil {
w.WriteHeader(http.StatusNotFound)
w.Write([]byte("404"))
return
}
row = db.QueryRow("SELECT * FROM media WHERE media_id = ?", mediaUrl.MediaId)
media, err := models.NewMediaFromRow(row)
if err != nil {
log.Printf("WARN: %s", err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("internal server error"))
}
media := &mediaURL.Media
if success, response, status, err := authenticateMedia(media, db, r); !success {
if err != nil {
@@ -48,46 +40,37 @@ func RegisterPhotoRoutes(db *gorm.DB, router *mux.Router) {
var cachedPath string
if mediaUrl.Purpose == models.PhotoThumbnail || mediaUrl.Purpose == models.PhotoHighRes || mediaUrl.Purpose == models.VideoThumbnail {
cachedPath = path.Join(scanner.PhotoCache(), strconv.Itoa(media.AlbumId), strconv.Itoa(mediaUrl.MediaId), mediaUrl.MediaName)
} else if mediaUrl.Purpose == models.MediaOriginal {
if mediaURL.Purpose == models.PhotoThumbnail || mediaURL.Purpose == models.PhotoHighRes || mediaURL.Purpose == models.VideoThumbnail {
cachedPath = path.Join(scanner.PhotoCache(), strconv.Itoa(int(media.AlbumID)), strconv.Itoa(int(mediaURL.MediaID)), mediaURL.MediaName)
} else if mediaURL.Purpose == models.MediaOriginal {
cachedPath = media.Path
} else {
log.Printf("ERROR: Can not handle media_purpose for photo: %s\n", mediaUrl.Purpose)
log.Printf("ERROR: Can not handle media_purpose for photo: %s\n", mediaURL.Purpose)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("internal server error"))
return
}
_, err = os.Stat(cachedPath)
if os.IsNotExist((err)) {
tx, err := db.Begin()
if _, err := os.Stat(cachedPath); os.IsNotExist((err)) {
err := db.Transaction(func(tx *gorm.DB) error {
if _, err = scanner.ProcessMedia(tx, media); err != nil {
log.Printf("ERROR: processing image not found in cache: %s\n", err)
return err
}
if _, err = os.Stat(cachedPath); err != nil {
log.Printf("ERROR: after reprocessing image not found in cache: %s\n", err)
return err
}
return nil
})
if err != nil {
log.Printf("ERROR: %s\n", err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("internal server error"))
return
}
_, err = scanner.ProcessMedia(tx, media)
if err != nil {
log.Printf("ERROR: processing image not found in cache: %s\n", err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("internal server error"))
tx.Rollback()
return
}
_, err = os.Stat(cachedPath)
if err != nil {
log.Printf("ERROR: after reprocessing image not found in cache: %s\n", err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("internal server error"))
tx.Rollback()
return
}
tx.Commit()
}
// Allow caching the resource for 1 day

57
api/routes/videos.go
View File

@@ -16,24 +16,17 @@ import (
func RegisterVideoRoutes(db *gorm.DB, router *mux.Router) {
router.HandleFunc("/{name}", func(w http.ResponseWriter, r *http.Request) {
media_name := mux.Vars(r)["name"]
mediaName := mux.Vars(r)["name"]
row := db.QueryRow("SELECT media_url.* FROM media_url JOIN media ON media_url.media_id = media.media_id WHERE media_url.media_name = ?", media_name)
mediaURL, err := models.NewMediaURLFromRow(row)
if err != nil {
var mediaURL models.MediaURL
result := db.Model(&models.MediaURL{}).Select("media_urls.*").Where("media_url.media_name = ?", mediaName).Joins("media ON media_urls.media_id = media.id").Scan(&mediaURL)
if err := result.Error; err != nil {
w.WriteHeader(http.StatusNotFound)
w.Write([]byte("404"))
return
}
row = db.QueryRow("SELECT * FROM media WHERE media_id = ?", mediaURL.MediaId)
media, err := models.NewMediaFromRow(row)
if err != nil {
log.Printf("WARN: %s", err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("internal server error"))
}
var media = &mediaURL.Media
if success, response, status, err := authenticateMedia(media, db, r); !success {
if err != nil {
@@ -47,7 +40,7 @@ func RegisterVideoRoutes(db *gorm.DB, router *mux.Router) {
var cachedPath string
if mediaURL.Purpose == models.VideoWeb {
cachedPath = path.Join(scanner.PhotoCache(), strconv.Itoa(media.AlbumId), strconv.Itoa(mediaURL.MediaId), mediaURL.MediaName)
cachedPath = path.Join(scanner.PhotoCache(), strconv.Itoa(int(media.AlbumID)), strconv.Itoa(int(mediaURL.MediaID)), mediaURL.MediaName)
} else {
log.Printf("ERROR: Can not handle media_purpose for video: %s\n", mediaURL.Purpose)
w.WriteHeader(http.StatusInternalServerError)
@@ -55,36 +48,28 @@ func RegisterVideoRoutes(db *gorm.DB, router *mux.Router) {
return
}
_, err = os.Stat(cachedPath)
if err != nil {
if _, err := os.Stat(cachedPath); err != nil {
if os.IsNotExist(err) {
tx, err := db.Begin()
err := db.Transaction(func(tx *gorm.DB) error {
if _, err := scanner.ProcessMedia(tx, media); err != nil {
log.Printf("ERROR: processing video not found in cache: %s\n", err)
return err
}
if _, err := os.Stat(cachedPath); err != nil {
log.Printf("ERROR: after reprocessing video not found in cache: %s\n", err)
return err
}
return nil
})
if err != nil {
log.Printf("ERROR: %s\n", err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("internal server error"))
return
}
_, err = scanner.ProcessMedia(tx, media)
if err != nil {
log.Printf("ERROR: processing video not found in cache: %s\n", err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("internal server error"))
tx.Rollback()
return
}
_, err = os.Stat(cachedPath)
if err != nil {
log.Printf("ERROR: after reprocessing video not found in cache: %s\n", err)
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("internal server error"))
tx.Rollback()
return
}
tx.Commit()
}
}

4
api/scanner/exif.go
View File

@@ -20,10 +20,10 @@ func ScanEXIF(tx *gorm.DB, media *models.Media) (returnExif *models.MediaEXIF, r
{
// Check if EXIF data already exists
if media.ExifId != nil {
if media.ExifID != nil {
var exif models.MediaEXIF
if err := tx.First(&exif, media.ExifId).Error; err != nil {
if err := tx.First(&exif, media.ExifID).Error; err != nil {
return nil, errors.Wrap(err, "get EXIF for media from database")
}

2
api/scanner/scanner_media.go
View File

@@ -98,7 +98,7 @@ func ScanMedia(tx *gorm.DB, mediaPath string, albumId uint, cache *AlbumScannerC
Path: mediaPath,
SideCarPath: sideCarPath,
SideCarHash: sideCarHash,
AlbumId: albumId,
AlbumID: albumId,
Type: mediaTypeText,
DateShot: stat.ModTime(),
}