Merge remote-tracking branch 'upstream/master'

common/seriesInfo.go

@@ -10,6 +10,7 @@ type SeriesInfo struct {
 	ImdbId           string
 	Name             string
 	Year             int
+	ReleaseDate 	 string
 	EpList           []EpisodeInfo
 	DirPath          string
 	SeasonDict       map[int]int

common/videoInfo.go

@@ -1,10 +1,11 @@
 package common
 
-// VideoInfo 从 movie.xml *.nfo 中解析出的视频信息
-type VideoInfo struct {
+// VideoIMDBInfo 从 movie.xml *.nfo 中解析出的视频信息
+type VideoIMDBInfo struct {
 	ImdbId string
 	TVdbId string
 	Year string
 	Title string
 	OriginalTitle string
+	ReleaseDate string
 }

model/decode.go

@@ -7,6 +7,7 @@ import (
 	PTN "github.com/middelink/go-parse-torrent-name"
 	"io/ioutil"
 	"os"
+	"path"
 	"path/filepath"
 	"regexp"
 	"strconv"
@@ -14,9 +15,9 @@ import (
 	"time"
 )
 
-func getImdbAndYearMovieXml(movieFilePath string) (common.VideoInfo, error) {
+func getImdbAndYearMovieXml(movieFilePath string) (common.VideoIMDBInfo, error) {
 
-	videoInfo := common.VideoInfo{}
+	videoInfo := common.VideoIMDBInfo{}
 	doc := etree.NewDocument()
 	if err := doc.ReadFromFile(movieFilePath); err != nil {
 		return videoInfo, err
@@ -35,8 +36,8 @@ func getImdbAndYearMovieXml(movieFilePath string) (common.VideoInfo, error) {
 	return videoInfo, common.CanNotFindIMDBID
 }
 
-func getImdbAndYearNfo(nfoFilePath string) (common.VideoInfo, error) {
-	imdbInfo := common.VideoInfo{}
+func getImdbAndYearNfo(nfoFilePath string) (common.VideoIMDBInfo, error) {
+	imdbInfo := common.VideoIMDBInfo{}
 	doc := etree.NewDocument()
 	// 这里会遇到一个梗，下面的关键词，可能是小写、大写、首字母大写
 	// 读取文件转换为全部的小写，然后在解析 xml ？ etree 在转换为小写后，某些类型的文件的内容会崩溃···
@@ -61,15 +62,131 @@ func getImdbAndYearNfo(nfoFilePath string) (common.VideoInfo, error) {
 		imdbInfo.Year = t.Text()
 		break
 	}
+	for _, t := range doc.FindElements("./movie/releasedate") {
+		imdbInfo.ReleaseDate = t.Text()
+		break
+	}
+	for _, t := range doc.FindElements("./movie/premiered") {
+		imdbInfo.ReleaseDate = t.Text()
+		break
+	}
 	if imdbInfo.ImdbId != "" {
 		return imdbInfo, nil
 	}
 	return imdbInfo, common.CanNotFindIMDBID
 }
 
-func GetImdbInfo(dirPth string) (common.VideoInfo, error) {
+func GetImdbInfo4Movie(movieFileFullPath string) (common.VideoIMDBInfo, error) {
+	imdbInfo := common.VideoIMDBInfo{}
+	// movie 当前的目录
+	dirPth := filepath.Dir(movieFileFullPath)
+	// 与 movie 文件名一致的 nfo 文件名称
+	movieNfoFileName := filepath.Base(movieFileFullPath)
+	movieNfoFileName = strings.ReplaceAll(movieNfoFileName, filepath.Ext(movieFileFullPath), "")
+	// movie.xml
+	movieXmlFPath := ""
+	// movieName.nfo 文件
+	movieNameNfoFPath := ""
+	// 通用的 *.nfo
+	nfoFilePath := ""
+	dir, err := ioutil.ReadDir(dirPth)
+	if err != nil {
+		return imdbInfo, err
+	}
+	for _, fi := range dir {
+		if fi.IsDir() == true {
+			continue
+		}
+		upperName := strings.ToLower(fi.Name())
+		if upperName == MetadataMovieXml {
+			// 找 movie.xml
+			movieXmlFPath = path.Join(dirPth, fi.Name())
+			break
+		} else if upperName == movieNfoFileName {
+			// movieName.nfo 文件
+			movieNameNfoFPath = path.Join(dirPth, fi.Name())
+			break
+		} else {
+			// 找 *.nfo，很可能是 movie.nfo
+			ok := strings.HasSuffix(fi.Name(), suffixNameNfo)
+			if ok {
+				nfoFilePath = path.Join(dirPth, fi.Name())
+			}
+		}
+	}
+	// 根据找到的开始解析
+	if movieNameNfoFPath == "" && movieXmlFPath == "" && nfoFilePath == "" {
+		return imdbInfo, common.NoMetadataFile
+	}
+	// 优先分析 movieName.nfo 文件
+	if movieNameNfoFPath != "" {
+		imdbInfo, err = getImdbAndYearNfo(movieNameNfoFPath)
+		if err != nil {
+			return common.VideoIMDBInfo{}, err
+		}
+		return imdbInfo, nil
+	}
+
+
+	if movieXmlFPath != "" {
+		imdbInfo, err = getImdbAndYearMovieXml(movieXmlFPath)
+		if err != nil {
+			GetLogger().Errorln("getImdbAndYearMovieXml error, move on:", err)
+		} else {
+			return imdbInfo, nil
+		}
+	}
+	if nfoFilePath != "" {
+		imdbInfo, err = getImdbAndYearNfo(nfoFilePath)
+		if err != nil {
+			return imdbInfo, err
+		} else {
+			return imdbInfo, nil
+		}
+	}
+
+	return imdbInfo, common.CanNotFindIMDBID
+}
+
+func GetImdbInfo4SeriesDir(seriesDir string) (common.VideoIMDBInfo, error) {
+	imdbInfo := common.VideoIMDBInfo{}
+	dir, err := ioutil.ReadDir(seriesDir)
+	if err != nil {
+		return imdbInfo, err
+	}
+	nfoFilePath := ""
+	for _, fi := range dir {
+		if fi.IsDir() == true {
+			continue
+		}
+		upperName := strings.ToUpper(fi.Name())
+		if upperName == strings.ToUpper(MetadateTVNfo) {
+			// 连续剧的 nfo 文件
+			nfoFilePath = path.Join(seriesDir, fi.Name())
+			break
+		} else {
+			// 找 *.nfo
+			ok := strings.HasSuffix(fi.Name(), suffixNameNfo)
+			if ok {
+				nfoFilePath = path.Join(seriesDir, fi.Name())
+			}
+		}
+	}
+	// 根据找到的开始解析
+	if nfoFilePath == "" {
+		return imdbInfo, common.NoMetadataFile
+	}
+	imdbInfo, err = getImdbAndYearNfo(nfoFilePath)
+	if err != nil {
+		return common.VideoIMDBInfo{}, err
+	}
+	return imdbInfo, nil
+}
+
+// TODO 需要拆分出三个方向，一个是电影，输入电影文件全路径，一个是连续剧，输入的是连续剧的目录，最后一个是连续剧的一集文件的全路径
+func GetImdbInfo(dirPth string) (common.VideoIMDBInfo, error) {
 
-	imdbInfo := common.VideoInfo{}
+	imdbInfo := common.VideoIMDBInfo{}
 	dir, err := ioutil.ReadDir(dirPth)
 	if err != nil {
 		return imdbInfo, err
@@ -86,7 +203,7 @@ func GetImdbInfo(dirPth string) (common.VideoInfo, error) {
 		}
 		upperName := strings.ToUpper(fi.Name())
 		// 找 movie.xml
-		if upperName == strings.ToUpper(MetadataFileEmby) {
+		if upperName == strings.ToUpper(MetadataMovieXml) {
 			movieFilePath = dirPth + pathSep + fi.Name()
 			break
 		} else if upperName == strings.ToUpper(MetadateTVNfo) {
@@ -212,7 +329,7 @@ func GetNumber2int(input string) (int, error) {
 }
 
 const (
-	MetadataFileEmby = "movie.xml"
+	MetadataMovieXml = "movie.xml"
 	suffixNameXml    = ".xml"
 	suffixNameNfo    = ".nfo"
 	MetadateTVNfo    = "tvshow.nfo"

movie_helper/movieHelper.go

@@ -78,7 +78,7 @@ func SkipChineseMovie(videoFullPath string, _reqParam ...common.ReqParam) (bool,
 	if len(_reqParam) > 0 {
 		reqParam = _reqParam[0]
 	}
-	imdbInfo, err := model.GetImdbInfo(filepath.Dir(videoFullPath))
+	imdbInfo, err := model.GetImdbInfo4Movie(videoFullPath)
 	if err != nil {
 		return false, err
 	}

series_helper/seriesHelper.go

@@ -1,6 +1,7 @@
 package series_helper
 
 import (
+	"github.com/StalkR/imdb"
 	"github.com/allanpk716/ChineseSubFinder/common"
 	_interface "github.com/allanpk716/ChineseSubFinder/interface"
 	"github.com/allanpk716/ChineseSubFinder/model"
@@ -9,29 +10,37 @@ import (
 	"io/ioutil"
 	"path"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"time"
 )
 
 // ReadSeriesInfoFromDir 读取剧集的信息，只有那些 Eps 需要下载字幕的 NeedDlEpsKeyList
-func ReadSeriesInfoFromDir(seriesDir string) (*common.SeriesInfo, error) {
+func ReadSeriesInfoFromDir(seriesDir string, imdbInfo *imdb.Title) (*common.SeriesInfo, error) {
 	seriesInfo := common.SeriesInfo{}
 
 	subParserHub := model.NewSubParserHub(ass.NewParser(), srt.NewParser())
 	// 只考虑 IMDB 去查询，文件名目前发现可能会跟电影重复，导致很麻烦，本来也有前置要求要削刮器处理的
-	videoInfo, err := model.GetImdbInfo(seriesDir)
+	videoInfo, err := model.GetImdbInfo4SeriesDir(seriesDir)
 	if err != nil {
 		return nil, err
 	}
 	// 使用 IMDB ID 得到通用的剧集名称
-	imdbInfo, err := model.GetVideoInfoFromIMDB(videoInfo.ImdbId)
-	if err != nil {
-		return nil, err
-	}
 	// 以 IMDB 的信息为准
-	seriesInfo.Name = imdbInfo.Name
-	seriesInfo.ImdbId = imdbInfo.ID
-	seriesInfo.Year = imdbInfo.Year
+	if imdbInfo != nil {
+		seriesInfo.Name = imdbInfo.Name
+		seriesInfo.ImdbId = imdbInfo.ID
+		seriesInfo.Year = imdbInfo.Year
+	} else {
+		seriesInfo.Name = videoInfo.Title
+		seriesInfo.ImdbId = videoInfo.ImdbId
+		iYear, err := strconv.Atoi(videoInfo.Year)
+		if err != nil {
+			return nil, err
+		}
+		seriesInfo.Year = iYear
+	}
+	seriesInfo.ReleaseDate = videoInfo.ReleaseDate
 	seriesInfo.DirPath = seriesDir
 	seriesInfo.EpList = make([]common.EpisodeInfo, 0)
 	seriesInfo.SeasonDict = make(map[int]int)
@@ -126,24 +135,24 @@ func ReadSeriesInfoFromDir(seriesDir string) (*common.SeriesInfo, error) {
 }
 
 // SkipChineseSeries 跳过中文连续剧
-func SkipChineseSeries(seriesRootPath string, _reqParam ...common.ReqParam) (bool, error) {
+func SkipChineseSeries(seriesRootPath string, _reqParam ...common.ReqParam) (bool, *imdb.Title, error) {
 	var reqParam common.ReqParam
 	if len(_reqParam) > 0 {
 		reqParam = _reqParam[0]
 	}
-	imdbInfo, err := model.GetImdbInfo(seriesRootPath)
+	imdbInfo, err := model.GetImdbInfo4SeriesDir(seriesRootPath)
 	if err != nil {
-		return false, err
+		return false, nil, err
 	}
 	t, err := model.GetVideoInfoFromIMDB(imdbInfo.ImdbId, reqParam)
 	if err != nil {
-		return false, err
+		return false, nil, err
 	}
 	if len(t.Languages) > 0 && strings.ToLower(t.Languages[0]) == "chinese" {
 		model.GetLogger().Infoln("Skip", filepath.Base(seriesRootPath), "Sub Download, because series is Chinese")
-		return true, nil
+		return true, t, nil
 	}
-	return false, nil
+	return false, nil, nil
 }
 
 // OneSeriesDlSubInAllSite 一部连续剧在所有的网站下载相应的字幕

sub_supplier/subSupplierHub.go

@@ -69,7 +69,7 @@ func (d SubSupplierHub) DownloadSub4Movie(videoFullPath string, index int) ([]st
 func (d SubSupplierHub) DownloadSub4Series(seriesDirPath string, index int) (*common.SeriesInfo, map[string][]string, error) {
 
 	// 跳过中文的连续剧，不是一定要跳过的
-	skip, err := series_helper.SkipChineseSeries(seriesDirPath, d.Suppliers[0].GetReqParam())
+	skip, idmbInfo, err := series_helper.SkipChineseSeries(seriesDirPath, d.Suppliers[0].GetReqParam())
 	if err != nil {
 		d.log.Error("SkipChineseSeries", err)
 	}
@@ -77,7 +77,7 @@ func (d SubSupplierHub) DownloadSub4Series(seriesDirPath string, index int) (*co
 		return nil, nil, nil
 	}
 	// 读取本地的视频和字幕信息
-	seriesInfo, err := series_helper.ReadSeriesInfoFromDir(seriesDirPath)
+	seriesInfo, err := series_helper.ReadSeriesInfoFromDir(seriesDirPath, idmbInfo)
 	if err != nil {
 		return nil, nil, err
 	}

sub_supplier/subhd/subhd.go

@@ -129,11 +129,10 @@ func (s Supplier) getSubListFromFile4Movie(filePath string) ([]common.SupplierSu
 	if err != nil {
 		return nil, err
 	}
-	// 找到这个视频文件，然后读取它目录下的文件，尝试得到 IMDB ID
-	fileRootDirPath := filepath.Dir(filePath)
+	// 找到这个视频文件，尝试得到 IMDB ID
 	// 目前测试来看，加入 年 这个关键词去搜索，对 2020 年后的影片有利，因为网站有统一的详细页面了，而之前的，没有，会影响识别
 	// 所以，year >= 2020 年，则可以多加一个关键词（年）去搜索影片
-	imdbInfo, err := model.GetImdbInfo(fileRootDirPath)
+	imdbInfo, err := model.GetImdbInfo4Movie(filePath)
 	if err != nil {
 		// 允许的错误，跳过，继续进行文件名的搜索
 		s.log.Errorln("model.GetImdbInfo", err)

sub_supplier/subhd/subhd_test.go

@@ -39,7 +39,7 @@ func TestSupplier_GetSubListFromFile4Series(t *testing.T) {
 
 
 	// 读取本地的视频和字幕信息
-	seriesInfo, err := series_helper.ReadSeriesInfoFromDir(ser)
+	seriesInfo, err := series_helper.ReadSeriesInfoFromDir(ser, nil)
 	if err != nil {
 		t.Fatal(err)
 	}

sub_supplier/zimuku/zimuku.go

@@ -42,7 +42,7 @@ func (s Supplier) GetReqParam() common.ReqParam{
 }
 
 func (s Supplier) GetSubListFromFile4Movie(filePath string) ([]common.SupplierSubInfo, error){
-	return s.getSubListFromFile(filePath)
+	return s.getSubListFromMovie(filePath)
 }
 
 func (s Supplier) GetSubListFromFile4Series(seriesInfo *common.SeriesInfo) ([]common.SupplierSubInfo, error) {
@@ -102,7 +102,7 @@ func (s Supplier) GetSubListFromFile4Anime(seriesInfo *common.SeriesInfo) ([]com
 	panic("not implemented")
 }
 
-func (s Supplier) getSubListFromFile(filePath string) ([]common.SupplierSubInfo, error) {
+func (s Supplier) getSubListFromMovie(fileFPath string) ([]common.SupplierSubInfo, error) {
 
 	/*
 		虽然是传入视频文件路径，但是其实需要读取对应的视频文件目录下的
@@ -111,15 +111,14 @@ func (s Supplier) getSubListFromFile(filePath string) ([]common.SupplierSubInfo,
 		如果找不到，再靠文件名提取影片名称去查找
 	*/
 	// 得到这个视频文件名中的信息
-	info, _, err := model.GetVideoInfoFromFileFullPath(filePath)
+	info, _, err := model.GetVideoInfoFromFileFullPath(fileFPath)
 	if err != nil {
 		return nil, err
 	}
-	// 找到这个视频文件，然后读取它目录下的文件，尝试得到 IMDB ID
-	fileRootDirPath := filepath.Dir(filePath)
+	// 找到这个视频文件，尝试得到 IMDB ID
 	// 目前测试来看，加入 年 这个关键词去搜索，对 2020 年后的影片有利，因为网站有统一的详细页面了，而之前的，没有，会影响识别
 	// 所以，year >= 2020 年，则可以多加一个关键词（年）去搜索影片
-	imdbInfo, err := model.GetImdbInfo(fileRootDirPath)
+	imdbInfo, err := model.GetImdbInfo4Movie(fileFPath)
 	if err != nil {
 		// 允许的错误，跳过，继续进行文件名的搜索
 		s.log.Errorln("model.GetImdbInfo", err)
@@ -132,7 +131,7 @@ func (s Supplier) getSubListFromFile(filePath string) ([]common.SupplierSubInfo,
 		if err != nil {
 			// 允许的错误，跳过，继续进行文件名的搜索
 			s.log.Errorln(s.GetSupplierName(), "keyword:", imdbInfo.ImdbId)
-			s.log.Errorln("getSubListFromKeyword", "IMDBID can not found sub", filePath, err)
+			s.log.Errorln("getSubListFromKeyword", "IMDBID can not found sub", fileFPath, err)
 		}
 		// 如果有就优先返回
 		if len(subInfoList) >0 {

sub_supplier/zimuku/zimuku_test.go

@@ -29,7 +29,7 @@ func TestSupplier_GetSubListFromFile(t *testing.T) {
 	//movie1 := "X:\\连续剧\\The Bad Batch\\Season 1\\The Bad Batch - S01E01 - Aftermath WEBDL-1080p.mkv"
 
 	s := NewSupplier()
-	outList, err := s.getSubListFromFile(movie1)
+	outList, err := s.getSubListFromMovie(movie1)
 	if err != nil {
 		t.Error(err)
 	}
@@ -46,7 +46,7 @@ func TestSupplier_GetSubListFromFile4Series(t *testing.T) {
 	//ser := "X:\\连续剧\\Money.Heist"
 
 	// 读取本地的视频和字幕信息
-	seriesInfo, err := series_helper.ReadSeriesInfoFromDir(ser)
+	seriesInfo, err := series_helper.ReadSeriesInfoFromDir(ser, nil)
 	if err != nil {
 		t.Fatal(err)
 	}