Scan, detect & save .srt file info to DB

collections/scanner.go

@@ -9,7 +9,7 @@ import (
 	"github.com/gabriel-vasile/mimetype"
 )
 
-// MovieDirInfo keep movie directory information
+// MovieDirInfo is a holder to keep movie directory information
 type MovieDirInfo struct {
 	Dir       string
 	MovieFile string
@@ -18,36 +18,50 @@ type MovieDirInfo struct {
 	MimeType  string
 }
 
+// SubDirInfo is a holder to subtitle information
+type SubDirInfo struct {
+	Dir     string
+	SubFile string
+	Info    os.FileInfo
+}
+
 // ScanDir will return flat list of Movie directory information
-func ScanDir(path string) ([]MovieDirInfo, error) {
+func ScanDir(path string) ([]MovieDirInfo, []SubDirInfo, error) {
 	var listMovie []MovieDirInfo
+	var listSub []SubDirInfo
+
 	listItems, err := ioutil.ReadDir(path)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	for _, item := range listItems {
-		detectedMovies, err := Identify(path, item)
+		detectedMovies, detectedSubs, err := Identify(path, item)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 
 		listMovie = append(listMovie, detectedMovies...)
+		listSub = append(listSub, detectedSubs...)
 	}
 
-	return listMovie, nil
+	return listMovie, listSub, nil
 }
 
 // Identify single directory of movie
-func Identify(basePath string, file os.FileInfo) ([]MovieDirInfo, error) {
+func Identify(basePath string, file os.FileInfo) ([]MovieDirInfo, []SubDirInfo, error) {
+	path := filepath.Join(basePath, file.Name())
+
 	var listMovie []MovieDirInfo
+	var listSub []SubDirInfo
+
 	if file.IsDir() {
 		// recursive call, create other segment to continue the scan operation
-		listMovie, err := ScanDir(filepath.Join(basePath, file.Name()))
-		return listMovie, err
+		listMovie, listSub, err := ScanDir(path)
+		return listMovie, listSub, err
 	}
 
-	if mime, validVideo := isVideo(filepath.Join(basePath, file.Name())); validVideo {
+	if mime, validVideo := isVideo(path); validVideo {
 		listMovie = append(listMovie, MovieDirInfo{
 			Dir:       basePath,
 			MovieFile: file.Name(),
@@ -57,7 +71,15 @@ func Identify(basePath string, file os.FileInfo) ([]MovieDirInfo, error) {
 		})
 	}
 
-	return listMovie, nil
+	if validSub := IsTextSrt(path); validSub {
+		listSub = append(listSub, SubDirInfo{
+			Dir:     basePath,
+			SubFile: file.Name(),
+			Info:    file,
+		})
+	}
+
+	return listMovie, listSub, nil
 }
 
 func getFileSizeInMB(file os.FileInfo) float64 {
@@ -96,3 +118,16 @@ func isVideo(path string) (string, bool) {
 
 	return mime.String(), listChecker[mime.String()]
 }
+
+// IsTextSrt will return valid status detection of .srt file
+func IsTextSrt(path string) bool {
+	mime, err := mimetype.DetectFile(path)
+	if err != nil {
+		return false
+	}
+
+	validMime := mime.String() == "text/plain; charset=utf-8"
+	validExt := filepath.Ext(path) == ".srt" || filepath.Ext(path) == ".SRT"
+
+	return validMime && validExt
+}

main.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/jinzhu/gorm"
 	parsetorrentname "github.com/middelink/go-parse-torrent-name"
 	log "github.com/sirupsen/logrus"
 	"github.com/slaveofcode/voodio/collections"
@@ -106,39 +107,16 @@ func main() {
 	log.Infoln("Database prepared")
 
 	// Scan movies inside given path
-	movies, err := collections.ScanDir(*parentMoviePath)
+	log.Infoln("Scanning movies...")
+	movies, subs, err := collections.ScanDir(*parentMoviePath)
 	if err != nil {
 		cleanup()
-		panic("Error while scanning path " + err.Error())
+		panic("Error while scanning movies " + err.Error())
 	}
+	log.Infoln("Scanning movies finished")
 
-	// inserts all detected movies
-	for _, movie := range movies {
-		dirName := filepath.Base(movie.Dir)
-		dirNameParsedInfo, err := parsetorrentname.Parse(filepath.Base(movie.Dir))
-		cleanDirName := ""
-		if err == nil {
-			cleanDirName = dirNameParsedInfo.Title
-		}
-
-		baseNameParsedInfo, _ := parsetorrentname.Parse(movie.MovieFile)
-		cleanBaseName := ""
-		if err == nil {
-			cleanBaseName = baseNameParsedInfo.Title
-		}
-
-		dbConn.Create(&models.Movie{
-			DirPath:       movie.Dir,
-			DirName:       dirName,
-			CleanDirName:  cleanDirName,
-			FileSize:      movie.MovieSize,
-			BaseName:      movie.MovieFile,
-			CleanBaseName: cleanBaseName,
-			MimeType:      movie.MimeType,
-			IsGroupDir:    false,
-			IsPrepared:    false,
-		})
-	}
+	saveMovies(dbConn, movies)
+	saveSubs(dbConn, subs)
 
 	// Find duplicate directory names, kind of serial movie
 	var movieGroups []models.Movie
@@ -205,3 +183,57 @@ func main() {
 
 	log.Infoln("Server closed")
 }
+
+func saveMovies(dbConn *gorm.DB, movies []collections.MovieDirInfo) {
+	for _, movie := range movies {
+		dirName := filepath.Base(movie.Dir)
+		dirNameParsedInfo, err := parsetorrentname.Parse(filepath.Base(movie.Dir))
+		cleanDirName := ""
+		if err == nil {
+			cleanDirName = dirNameParsedInfo.Title
+		}
+
+		baseNameParsedInfo, _ := parsetorrentname.Parse(movie.MovieFile)
+		cleanBaseName := ""
+		if err == nil {
+			cleanBaseName = baseNameParsedInfo.Title
+		}
+
+		dbConn.Create(&models.Movie{
+			DirPath:       movie.Dir,
+			DirName:       dirName,
+			CleanDirName:  cleanDirName,
+			FileSize:      movie.MovieSize,
+			BaseName:      movie.MovieFile,
+			CleanBaseName: cleanBaseName,
+			MimeType:      movie.MimeType,
+			IsGroupDir:    false,
+			IsPrepared:    false,
+		})
+	}
+}
+
+func saveSubs(dbConn *gorm.DB, subs []collections.SubDirInfo) {
+	for _, sub := range subs {
+		dirName := filepath.Base(sub.Dir)
+		dirNameParsedInfo, err := parsetorrentname.Parse(filepath.Base(sub.Dir))
+		cleanDirName := ""
+		if err == nil {
+			cleanDirName = dirNameParsedInfo.Title
+		}
+
+		baseNameParsedInfo, _ := parsetorrentname.Parse(sub.SubFile)
+		cleanBaseName := ""
+		if err == nil {
+			cleanBaseName = baseNameParsedInfo.Title
+		}
+
+		dbConn.Create(&models.Subtitle{
+			DirPath:       sub.Dir,
+			DirName:       dirName,
+			CleanDirName:  cleanDirName,
+			BaseName:      sub.SubFile,
+			CleanBaseName: cleanBaseName,
+		})
+	}
+}

repository/db.go

@@ -22,5 +22,8 @@ func OpenDB(dbPath string) (*gorm.DB, error) {
 
 // Migrate will do migration of models
 func Migrate(db *gorm.DB) {
-	db.AutoMigrate(&models.Movie{})
+	db.AutoMigrate(
+		&models.Movie{},
+		&models.Subtitle{},
+	)
 }

repository/models/Subtitle.go

@@ -0,0 +1,13 @@
+package models
+
+import "github.com/jinzhu/gorm"
+
+// Subtitle is Gorm model of subtitle
+type Subtitle struct {
+	gorm.Model
+	DirPath       string `json:"dirPath"`
+	DirName       string `json:"dirName"`
+	CleanDirName  string `json:"cleanDirName"`
+	BaseName      string `json:"baseName"`
+	CleanBaseName string `json:"cleanBaseName"`
+}