1
0
Эх сурвалжийг харах

重构 IMDB Helper

Signed-off-by: allan716 <[email protected]>
allan716 3 жил өмнө
parent
commit
7a13afe4bb

+ 1 - 1
internal/backend/controllers/base/check_emby_settings.go

@@ -32,7 +32,7 @@ func (cb *ControllerBase) CheckEmbySettingsHandler(c *gin.Context) {
 		SeriesPathsMapping:    make(map[string]string, 0),
 	}
 
-	emHelper := emby_helper.NewEmbyHelper(cb.fileDownloader.Log, &settings.Settings{EmbySettings: &emSettings})
+	emHelper := emby_helper.NewEmbyHelper(cb.fileDownloader.MediaInfoDealers, &settings.Settings{EmbySettings: &emSettings})
 	userList, err := emHelper.EmbyApi.GetUserIdList()
 	if err != nil {
 		return

+ 1 - 1
internal/backend/controllers/base/path_things.go

@@ -66,7 +66,7 @@ func (cb *ControllerBase) CheckEmbyPathHandler(c *gin.Context) {
 		emSettings.SeriesPathsMapping[reqCheckPath.CFSMediaPath] = reqCheckPath.EmbyMediaPath
 	}
 
-	emHelper := emby_helper.NewEmbyHelper(cb.fileDownloader.Log, &settings.Settings{EmbySettings: &emSettings})
+	emHelper := emby_helper.NewEmbyHelper(cb.fileDownloader.MediaInfoDealers, &settings.Settings{EmbySettings: &emSettings})
 
 	outList, err := emHelper.CheckPath(reqCheckPath.PathType)
 	if err != nil {

+ 1 - 1
pkg/downloader/download_processer.go

@@ -81,7 +81,7 @@ func (d *Downloader) seriesDlFunc(ctx context.Context, job taskQueue2.OneJob, do
 	epsMap[job.Season] = []int{job.Episode}
 	// 这里拿到了这一部连续剧的所有的剧集信息,以及所有下载到的字幕信息
 	seriesInfo, err := series_helper.ReadSeriesInfoFromDir(
-		d.log, job.SeriesRootDirPath,
+		d.fileDownloader.MediaInfoDealers, job.SeriesRootDirPath,
 		d.settings.AdvancedSettings.TaskQueue.ExpirationTime,
 		false,
 		false,

+ 1 - 1
pkg/downloader/downloader.go

@@ -94,7 +94,7 @@ func NewDownloader(inSubFormatter ifaces.ISubFormatter, fileDownloader *file_dow
 	downloader.ctx, downloader.cancel = context.WithCancel(context.Background())
 	// 用于字幕下载后的刷新
 	if downloader.settings.EmbySettings.Enable == true {
-		downloader.embyHelper = embyHelper.NewEmbyHelper(downloader.log, downloader.settings)
+		downloader.embyHelper = embyHelper.NewEmbyHelper(downloader.fileDownloader.MediaInfoDealers, downloader.settings)
 	}
 
 	downloader.ScanLogic = scan_logic.NewScanLogic(downloader.log)

+ 4 - 2
pkg/downloader/queue_local.go

@@ -169,7 +169,7 @@ func (d *Downloader) queueDownloaderLocal() {
 		if oneJob.TaskPriority > task_queue.HighTaskPriorityLevel {
 			// 优先级大于 3,那么就不是很急的任务,才需要判断
 			if oneJob.VideoType == common2.Movie {
-				if d.subSupplierHub.MovieNeedDlSub(oneJob.VideoFPath, false) == false {
+				if d.subSupplierHub.MovieNeedDlSub(d.fileDownloader.MediaInfoDealers, oneJob.VideoFPath, false) == false {
 					// 需要标记忽略
 					oneJob.JobStatus = taskQueue2.Ignore
 					bok, err = d.downloadQueue.Update(oneJob)
@@ -186,7 +186,9 @@ func (d *Downloader) queueDownloaderLocal() {
 				}
 			} else if oneJob.VideoType == common2.Series {
 
-				bNeedDlSub, seriesInfo, err := d.subSupplierHub.SeriesNeedDlSub(oneJob.SeriesRootDirPath,
+				bNeedDlSub, seriesInfo, err := d.subSupplierHub.SeriesNeedDlSub(
+					d.fileDownloader.MediaInfoDealers,
+					oneJob.SeriesRootDirPath,
 					false, false)
 				if err != nil {
 					d.log.Errorln("SeriesNeedDlSub", err)

+ 30 - 63
pkg/imdb_helper/imdb.go

@@ -4,29 +4,22 @@ import (
 	"errors"
 	"strconv"
 	"strings"
-	"sync"
 
 	"github.com/allanpk716/ChineseSubFinder/pkg"
+	"github.com/allanpk716/ChineseSubFinder/pkg/media_info_dealers"
 
 	"github.com/allanpk716/ChineseSubFinder/pkg/decode"
 
-	"github.com/allanpk716/ChineseSubFinder/pkg/subtitle_best_api"
-
-	"github.com/allanpk716/ChineseSubFinder/pkg/random_auth_key"
-
 	"github.com/StalkR/imdb"
 	"github.com/allanpk716/ChineseSubFinder/internal/dao"
 	"github.com/allanpk716/ChineseSubFinder/internal/models"
 	"github.com/allanpk716/ChineseSubFinder/pkg/notify_center"
 	"github.com/allanpk716/ChineseSubFinder/pkg/settings"
 	"github.com/allanpk716/ChineseSubFinder/pkg/types"
-	"github.com/sirupsen/logrus"
 )
 
 // GetIMDBInfoFromVideoFile 先从本地拿缓存,如果没有就从 Web 获取
-func GetIMDBInfoFromVideoFile(log *logrus.Logger, videoFPath string, isMovie bool, _proxySettings *settings.ProxySettings) (*models.IMDBInfo, error) {
-
-	getReady(log, _proxySettings)
+func GetIMDBInfoFromVideoFile(dealers *media_info_dealers.Dealers, videoFPath string, isMovie bool, _proxySettings *settings.ProxySettings) (*models.IMDBInfo, error) {
 
 	var err error
 	var videoNfoInfo types.VideoNfoInfo
@@ -37,12 +30,12 @@ func GetIMDBInfoFromVideoFile(log *logrus.Logger, videoFPath string, isMovie boo
 	}
 	if err != nil {
 		// 如果找不到当前电影的 IMDB Info 本地文件,那么就跳过
-		log.Warningln("getSubListFromFile", videoFPath, err)
+		dealers.Logger.Warningln("getSubListFromFile", videoFPath, err)
 		return nil, err
 	}
-	imdbInfo, err := GetIMDBInfoFromVideoNfoInfo(log, videoNfoInfo, _proxySettings)
+	imdbInfo, err := GetIMDBInfoFromVideoNfoInfo(dealers, videoNfoInfo, _proxySettings)
 	if err != nil {
-		log.Warningln("GetIMDBInfoFromVideoNfoInfo", videoFPath, err)
+		dealers.Logger.Warningln("GetIMDBInfoFromVideoNfoInfo", videoFPath, err)
 		return nil, err
 	}
 	if len(imdbInfo.Description) <= 0 {
@@ -53,7 +46,7 @@ func GetIMDBInfoFromVideoFile(log *logrus.Logger, videoFPath string, isMovie boo
 		}
 		t, err := getVideoInfoFromIMDBWeb(videoNfoInfo, _proxySettings)
 		if err != nil {
-			log.Errorln("getVideoInfoFromIMDBWeb,", videoNfoInfo.Title, err)
+			dealers.Logger.Errorln("getVideoInfoFromIMDBWeb,", videoNfoInfo.Title, err)
 			return nil, err
 		}
 		imdbInfo.Year = t.Year
@@ -68,9 +61,8 @@ func GetIMDBInfoFromVideoFile(log *logrus.Logger, videoFPath string, isMovie boo
 }
 
 // GetIMDBInfoFromVideoNfoInfo 从本地获取 IMDB 信息,注意,如果需要跳过,那么返回 Error == common.SkipCreateInDB
-func GetIMDBInfoFromVideoNfoInfo(log *logrus.Logger, videoNfoInfo types.VideoNfoInfo, _proxySettings *settings.ProxySettings) (*models.IMDBInfo, error) {
+func GetIMDBInfoFromVideoNfoInfo(dealers *media_info_dealers.Dealers, videoNfoInfo types.VideoNfoInfo, _proxySettings *settings.ProxySettings) (*models.IMDBInfo, error) {
 
-	getReady(log, _proxySettings)
 	/*
 		这里需要注意一个细节,之前理想情况下是从 Web 获取完整的 IMDB Info 回来,放入本地存储
 		获取的时候如果本地有就拿本地的,没有则从 Web 获取,然后写入本地存储
@@ -81,8 +73,8 @@ func GetIMDBInfoFromVideoNfoInfo(log *logrus.Logger, videoNfoInfo types.VideoNfo
 		3. 因为现在默认是不跳过中文视频扫描的,所以如果开启后,则会再判断的时候访问外网获取,然后写入本地,过程会比较慢
 		4. 同时,再发送字幕和 IMDB Info 到服务器的时候,也需要判断是否 IMDB Info 信息是否齐全,否则就需要从外网获取齐全后再上传
 	*/
-	log.Debugln("GetIMDBInfoFromVideoNfoInfo", "IMDBID:", videoNfoInfo.ImdbId, "TMDBID:", videoNfoInfo.TmdbId, videoNfoInfo.Title, videoNfoInfo.Season, videoNfoInfo.Episode)
-	log.Debugln("GetIMDBInfoFromVideoNfoInfo", 0)
+	dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", "IMDBID:", videoNfoInfo.ImdbId, "TMDBID:", videoNfoInfo.TmdbId, videoNfoInfo.Title, videoNfoInfo.Season, videoNfoInfo.Episode)
+	dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 0)
 
 	if videoNfoInfo.ImdbId != "" {
 		// 优先从 IMDB ID 去查找本地的信息
@@ -93,21 +85,21 @@ func GetIMDBInfoFromVideoNfoInfo(log *logrus.Logger, videoNfoInfo types.VideoNfo
 			Preload("VideoSubInfos").
 			Limit(1).Where(&models.IMDBInfo{IMDBID: videoNfoInfo.ImdbId}).Find(&imdbInfos)
 
-		log.Debugln("GetIMDBInfoFromVideoNfoInfo", 1)
+		dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 1)
 
 		if len(imdbInfos) <= 0 {
 			// 没有找到,新增,存储本地,但是信息肯定是不完整的,需要在判断是否是中文的时候再次去外网获取补全信息
-			log.Debugln("GetIMDBInfoFromVideoNfoInfo", 2)
+			dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 2)
 			// 存入数据库
 			nowIMDBInfo := models.NewIMDBInfo(videoNfoInfo.ImdbId, "", 0, "", []string{}, []string{})
 			dao.GetDb().Create(nowIMDBInfo)
 
-			log.Debugln("GetIMDBInfoFromVideoNfoInfo", 3)
+			dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 3)
 
 			return nowIMDBInfo, nil
 		} else {
 
-			log.Debugln("GetIMDBInfoFromVideoNfoInfo", 4)
+			dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 4)
 			// 找到
 			return &imdbInfos[0], nil
 		}
@@ -119,7 +111,7 @@ func GetIMDBInfoFromVideoNfoInfo(log *logrus.Logger, videoNfoInfo types.VideoNfo
 			Preload("VideoSubInfos").
 			Limit(1).Where(&models.IMDBInfo{TmdbId: videoNfoInfo.TmdbId}).Find(&imdbInfos)
 
-		log.Debugln("GetIMDBInfoFromVideoNfoInfo", 1)
+		dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 1)
 
 		if len(imdbInfos) <= 0 {
 			// 没有找到那么就从 Web 端获取 imdb id 信息
@@ -127,60 +119,54 @@ func GetIMDBInfoFromVideoNfoInfo(log *logrus.Logger, videoNfoInfo types.VideoNfo
 			// 如果找到多个,那么就应该删除这些,因为这些都是重复的,然后再次从 Web 去获取 imdb id 信息
 			dao.GetDb().Where(&models.IMDBInfo{TmdbId: videoNfoInfo.TmdbId}).Delete(&models.IMDBInfo{})
 		} else {
-			log.Debugln("GetIMDBInfoFromVideoNfoInfo", 4)
+			dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 4)
 			// 找到
 			return &imdbInfos[0], nil
 		}
 		// 确定需要从 Web 端获取 imdb id 信息
-		log.Debugln("GetIMDBInfoFromVideoNfoInfo", 2)
-		videoType := ""
-		if videoNfoInfo.IsMovie == true {
-			videoType = "movie"
-		} else {
-			videoType = "series"
-		}
+		dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 2)
 		// 联网查询
-		idConvertReply, err := subtitleBestApi.ConvertId(videoNfoInfo.TmdbId, "tmdb", videoType)
+		idConvertReply, err := dealers.ConvertId(videoNfoInfo.TmdbId, "tmdb", videoNfoInfo.IsMovie)
 		if err != nil {
 			return nil, err
 		}
-		log.Debugln("GetIMDBInfoFromVideoNfoInfo", 3)
+		dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 3)
 		// 存入数据库
-		nowIMDBInfo := models.NewIMDBInfo(idConvertReply.IMDBId, "", 0, "", []string{}, []string{})
+		nowIMDBInfo := models.NewIMDBInfo(idConvertReply.ImdbID, "", 0, "", []string{}, []string{})
 		dao.GetDb().Create(nowIMDBInfo)
-		log.Debugln("GetIMDBInfoFromVideoNfoInfo", 4)
+		dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo", 4)
 		return nowIMDBInfo, nil
 
 	} else {
 		// 都没有,那么就报错
-		log.Debugln("GetIMDBInfoFromVideoNfoInfo IMDB TMDB ID is empty")
+		dealers.Logger.Debugln("GetIMDBInfoFromVideoNfoInfo IMDB TMDB ID is empty")
 		return nil, errors.New("IMDB TMDB ID is empty")
 	}
 }
 
 // IsChineseVideo 从 imdbID 去查询判断是否是中文视频
-func IsChineseVideo(log *logrus.Logger, videoNfoInfo types.VideoNfoInfo, _proxySettings *settings.ProxySettings) (bool, *models.IMDBInfo, error) {
+func IsChineseVideo(dealers *media_info_dealers.Dealers, videoNfoInfo types.VideoNfoInfo, _proxySettings *settings.ProxySettings) (bool, *models.IMDBInfo, error) {
 
 	const chName0 = "chinese"
 	const chName1 = "mandarin"
 
-	log.Debugln("IsChineseVideo", 0)
+	dealers.Logger.Debugln("IsChineseVideo", 0)
 
-	localIMDBInfo, err := GetIMDBInfoFromVideoNfoInfo(log, videoNfoInfo, _proxySettings)
+	localIMDBInfo, err := GetIMDBInfoFromVideoNfoInfo(dealers, videoNfoInfo, _proxySettings)
 	if err != nil {
 		return false, nil, err
 	}
 	if len(localIMDBInfo.Description) <= 0 {
 		// 需要去外网获去补全信息,然后更新本地的信息
-		log.Debugln("IsChineseVideo", 1)
+		dealers.Logger.Debugln("IsChineseVideo", 1)
 
 		t, err := getVideoInfoFromIMDBWeb(videoNfoInfo, _proxySettings)
 		if err != nil {
-			log.Errorln("IsChineseVideo.getVideoInfoFromIMDBWeb,", videoNfoInfo.Title, err)
+			dealers.Logger.Errorln("IsChineseVideo.getVideoInfoFromIMDBWeb,", videoNfoInfo.Title, err)
 			return false, nil, err
 		}
 
-		log.Debugln("IsChineseVideo", 2)
+		dealers.Logger.Debugln("IsChineseVideo", 2)
 		localIMDBInfo.Year = t.Year
 		localIMDBInfo.Name = t.Name
 		localIMDBInfo.Year = t.Year
@@ -188,11 +174,11 @@ func IsChineseVideo(log *logrus.Logger, videoNfoInfo types.VideoNfoInfo, _proxyS
 		localIMDBInfo.Description = t.Description
 		localIMDBInfo.Languages = t.Languages
 
-		log.Debugln("IsChineseVideo", 3)
+		dealers.Logger.Debugln("IsChineseVideo", 3)
 
 		dao.GetDb().Save(localIMDBInfo)
 
-		log.Debugln("IsChineseVideo", 4)
+		dealers.Logger.Debugln("IsChineseVideo", 4)
 	}
 
 	if len(localIMDBInfo.Languages) < 1 {
@@ -201,7 +187,7 @@ func IsChineseVideo(log *logrus.Logger, videoNfoInfo types.VideoNfoInfo, _proxyS
 
 	firstLangLowCase := strings.ToLower(localIMDBInfo.Languages[0])
 
-	log.Debugln("IsChineseVideo", 5)
+	dealers.Logger.Debugln("IsChineseVideo", 5)
 
 	// 判断第一语言是否是中文
 	switch firstLangLowCase {
@@ -238,22 +224,3 @@ func getVideoInfoFromIMDBWeb(videoNfoInfo types.VideoNfoInfo, _proxySettings ...
 
 	return t, nil
 }
-
-func getReady(log *logrus.Logger, proxySettings *settings.ProxySettings) {
-
-	locker.Lock()
-	if randomAuthKey == nil {
-		randomAuthKey = &random_auth_key.AuthKey{
-			BaseKey:  pkg.BaseKey(),
-			AESKey16: pkg.AESKey16(),
-			AESIv16:  pkg.AESIv16(),
-		}
-
-		subtitleBestApi = subtitle_best_api.NewSubtitleBestApi(log, *randomAuthKey, proxySettings)
-	}
-	locker.Unlock()
-}
-
-var locker sync.Mutex
-var randomAuthKey *random_auth_key.AuthKey
-var subtitleBestApi *subtitle_best_api.SubtitleBestApi

+ 7 - 4
pkg/logic/emby_helper/embyhelper.go

@@ -8,6 +8,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/allanpk716/ChineseSubFinder/pkg/media_info_dealers"
+
 	"github.com/allanpk716/ChineseSubFinder/pkg"
 
 	"github.com/allanpk716/ChineseSubFinder/pkg/types"
@@ -30,13 +32,14 @@ type EmbyHelper struct {
 	EmbyApi  *embyHelper.EmbyApi
 	log      *logrus.Logger
 	settings *settings.Settings
+	dealers  *media_info_dealers.Dealers
 	timeOut  time.Duration
 	listLock sync.Mutex
 }
 
-func NewEmbyHelper(_log *logrus.Logger, _settings *settings.Settings) *EmbyHelper {
-	em := EmbyHelper{log: _log, settings: _settings}
-	em.EmbyApi = embyHelper.NewEmbyApi(_log, _settings.EmbySettings)
+func NewEmbyHelper(dealers *media_info_dealers.Dealers, _settings *settings.Settings) *EmbyHelper {
+	em := EmbyHelper{log: dealers.Logger, settings: _settings, dealers: dealers}
+	em.EmbyApi = embyHelper.NewEmbyApi(dealers.Logger, _settings.EmbySettings)
 	em.timeOut = 60 * time.Second
 	return &em
 }
@@ -501,7 +504,7 @@ func (em *EmbyHelper) autoFindMappingPathWithMixInfoByIMDBId(mixInfo *emby2.Emby
 
 	// 获取 IMDB 信息
 	imdbInfo, err := imdb_helper.GetIMDBInfoFromVideoNfoInfo(
-		em.log,
+		em.dealers,
 		types.VideoNfoInfo{
 			ImdbId: mixInfo.IMDBId,
 			TmdbId: mixInfo.TMDBId,

+ 26 - 24
pkg/logic/movie_helper/moviehelper.go

@@ -6,6 +6,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/allanpk716/ChineseSubFinder/pkg/media_info_dealers"
+
 	"github.com/allanpk716/ChineseSubFinder/pkg/ifaces"
 	"github.com/allanpk716/ChineseSubFinder/pkg/types/common"
 	"github.com/allanpk716/ChineseSubFinder/pkg/types/supplier"
@@ -23,44 +25,44 @@ import (
 )
 
 // OneMovieDlSubInAllSite 一部电影在所有的网站下载相应的字幕
-func OneMovieDlSubInAllSite(log *logrus.Logger, Suppliers []ifaces.ISupplier, oneVideoFullPath string, i int64) []supplier.SubInfo {
+func OneMovieDlSubInAllSite(logger *logrus.Logger, Suppliers []ifaces.ISupplier, oneVideoFullPath string, i int64) []supplier.SubInfo {
 
 	defer func() {
-		log.Infoln(common.QueueName, i, "DlSub End", oneVideoFullPath)
+		logger.Infoln(common.QueueName, i, "DlSub End", oneVideoFullPath)
 	}()
 
 	var outSUbInfos = make([]supplier.SubInfo, 0)
-	log.Infoln(common.QueueName, i, "DlSub Start", oneVideoFullPath)
+	logger.Infoln(common.QueueName, i, "DlSub Start", oneVideoFullPath)
 	for _, oneSupplier := range Suppliers {
 
-		log.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), oneVideoFullPath)
+		logger.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), oneVideoFullPath)
 
 		if oneSupplier.OverDailyDownloadLimit() == true {
-			log.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), "Over Daily Download Limit")
+			logger.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), "Over Daily Download Limit")
 			continue
 		}
 
-		subInfos, err := OneMovieDlSubInOneSite(log, oneVideoFullPath, i, oneSupplier)
+		subInfos, err := OneMovieDlSubInOneSite(logger, oneVideoFullPath, i, oneSupplier)
 		if err != nil {
-			log.Errorln(common.QueueName, i, oneSupplier.GetSupplierName(), "oneMovieDlSubInOneSite", err)
+			logger.Errorln(common.QueueName, i, oneSupplier.GetSupplierName(), "oneMovieDlSubInOneSite", err)
 			continue
 		}
 		outSUbInfos = append(outSUbInfos, subInfos...)
 	}
 
 	for index, info := range outSUbInfos {
-		log.Debugln(common.QueueName, i, "OneMovieDlSubInAllSite get sub", index, "Name:", info.Name, "FileUrl:", info.FileUrl)
+		logger.Debugln(common.QueueName, i, "OneMovieDlSubInAllSite get sub", index, "Name:", info.Name, "FileUrl:", info.FileUrl)
 	}
 
 	return outSUbInfos
 }
 
 // OneMovieDlSubInOneSite 一部电影在一个站点下载字幕
-func OneMovieDlSubInOneSite(log *logrus.Logger, oneVideoFullPath string, i int64, supplier ifaces.ISupplier) ([]supplier.SubInfo, error) {
+func OneMovieDlSubInOneSite(logger *logrus.Logger, oneVideoFullPath string, i int64, supplier ifaces.ISupplier) ([]supplier.SubInfo, error) {
 	defer func() {
-		log.Infoln(common.QueueName, i, supplier.GetSupplierName(), "End...")
+		logger.Infoln(common.QueueName, i, supplier.GetSupplierName(), "End...")
 	}()
-	log.Infoln(common.QueueName, i, supplier.GetSupplierName(), "Start...")
+	logger.Infoln(common.QueueName, i, supplier.GetSupplierName(), "Start...")
 	subInfos, err := supplier.GetSubListFromFile4Movie(oneVideoFullPath)
 	if err != nil {
 		return nil, err
@@ -72,7 +74,7 @@ func OneMovieDlSubInOneSite(log *logrus.Logger, oneVideoFullPath string, i int64
 }
 
 // MovieHasChineseSub 这个视频文件的目录下面有字幕文件了没有
-func MovieHasChineseSub(log *logrus.Logger, videoFilePath string) (bool, []string, []string, error) {
+func MovieHasChineseSub(logger *logrus.Logger, videoFilePath string) (bool, []string, []string, error) {
 	dir := filepath.Dir(videoFilePath)
 	videoFileName := filepath.Base(videoFilePath)
 	videoFileName = strings.ReplaceAll(videoFileName, filepath.Ext(videoFileName), "")
@@ -95,14 +97,14 @@ func MovieHasChineseSub(log *logrus.Logger, videoFilePath string) (bool, []strin
 			}
 			// 字幕文件是否包含中文
 			subFileFullPath := filepath.Join(dir, curFile.Name())
-			subParserHub := sub_parser_hub.NewSubParserHub(log, ass.NewParser(log), srt.NewParser(log))
+			subParserHub := sub_parser_hub.NewSubParserHub(logger, ass.NewParser(logger), srt.NewParser(logger))
 			bFind, subParserFileInfo, err := subParserHub.DetermineFileTypeFromFile(subFileFullPath)
 			if err != nil {
-				log.Errorln("DetermineFileTypeFromFile", subFileFullPath, err)
+				logger.Errorln("DetermineFileTypeFromFile", subFileFullPath, err)
 				continue
 			}
 			if bFind == false {
-				log.Warnln("DetermineFileTypeFromFile", subFileFullPath, "not support SubType")
+				logger.Warnln("DetermineFileTypeFromFile", subFileFullPath, "not support SubType")
 				continue
 			}
 			if subParserHub.IsSubHasChinese(subParserFileInfo) == true {
@@ -122,27 +124,27 @@ func MovieHasChineseSub(log *logrus.Logger, videoFilePath string) (bool, []strin
 }
 
 // SkipChineseMovie 跳过中文的电影
-func SkipChineseMovie(log *logrus.Logger, videoFullPath string, _proxySettings *settings.ProxySettings) (bool, error) {
+func SkipChineseMovie(dealers *media_info_dealers.Dealers, videoFullPath string, _proxySettings *settings.ProxySettings) (bool, error) {
 
 	imdbInfo, err := decode.GetVideoNfoInfo4Movie(videoFullPath)
 	if err != nil {
 		return false, err
 	}
-	isChineseVideo, _, err := imdb_helper.IsChineseVideo(log, imdbInfo, _proxySettings)
+	isChineseVideo, _, err := imdb_helper.IsChineseVideo(dealers, imdbInfo, _proxySettings)
 	if err != nil {
 		return false, err
 	}
 	if isChineseVideo == true {
-		log.Infoln("Skip", videoFullPath, "Sub Download, because movie is Chinese")
+		dealers.Logger.Infoln("Skip", videoFullPath, "Sub Download, because movie is Chinese")
 		return true, nil
 	} else {
 		return false, nil
 	}
 }
 
-func MovieNeedDlSub(log *logrus.Logger, videoFullPath string, ExpirationTime int) (bool, error) {
+func MovieNeedDlSub(logger *logrus.Logger, videoFullPath string, ExpirationTime int) (bool, error) {
 	// 视频下面有不有字幕
-	found, _, _, err := MovieHasChineseSub(log, videoFullPath)
+	found, _, _, err := MovieHasChineseSub(logger, videoFullPath)
 	if err != nil {
 		return false, err
 	}
@@ -159,7 +161,7 @@ func MovieNeedDlSub(log *logrus.Logger, videoFullPath string, ExpirationTime int
 			return true, nil
 		} else {
 			// 有字幕了,没必要每次都刷新,跳过
-			log.Infoln("Skip", filepath.Base(videoFullPath), "Sub Download, because movie has sub and published more than 2 years")
+			logger.Infoln("Skip", filepath.Base(videoFullPath), "Sub Download, because movie has sub and published more than 2 years")
 			return false, nil
 		}
 	} else {
@@ -169,7 +171,7 @@ func MovieNeedDlSub(log *logrus.Logger, videoFullPath string, ExpirationTime int
 		if videoNfoInfo4Movie.ReleaseDate != "" {
 			baseTime, err = now.Parse(videoNfoInfo4Movie.ReleaseDate)
 			if err != nil {
-				log.Errorln("Movie parse AiredTime", err)
+				logger.Errorln("Movie parse AiredTime", err)
 				baseTime = modifyTime
 			}
 		} else {
@@ -182,11 +184,11 @@ func MovieNeedDlSub(log *logrus.Logger, videoFullPath string, ExpirationTime int
 			return true, nil
 		} else {
 			if baseTime.AddDate(0, 0, ExpirationTime).After(currentTime) == false {
-				log.Infoln("Skip", filepath.Base(videoFullPath), "Sub Download, because movie has sub and downloaded or aired more than 3 months")
+				logger.Infoln("Skip", filepath.Base(videoFullPath), "Sub Download, because movie has sub and downloaded or aired more than 3 months")
 				return false, nil
 			}
 			if found == true {
-				log.Infoln("Skip", filepath.Base(videoFullPath), "Sub Download, because sub file found")
+				logger.Infoln("Skip", filepath.Base(videoFullPath), "Sub Download, because sub file found")
 				return false, nil
 			}
 

+ 2 - 2
pkg/logic/scan_played_video_subinfo/scan_played_video_subinfo.go

@@ -72,7 +72,7 @@ func NewScanPlayedVideoSubInfo(log *logrus.Logger, _settings *settings.Settings,
 	if scanPlayedVideoSubInfo.settings.EmbySettings.Enable == true && scanPlayedVideoSubInfo.settings.EmbySettings.AddressUrl != "" &&
 		scanPlayedVideoSubInfo.settings.EmbySettings.APIKey != "" {
 
-		scanPlayedVideoSubInfo.embyHelper = embyHelper.NewEmbyHelper(log, scanPlayedVideoSubInfo.settings)
+		scanPlayedVideoSubInfo.embyHelper = embyHelper.NewEmbyHelper(fileDownloader.MediaInfoDealers, scanPlayedVideoSubInfo.settings)
 		scanPlayedVideoSubInfo.embyHelper.SetMaxRequestVideoNumber(common2.EmbyApiGetItemsLimitMax)
 	}
 
@@ -360,7 +360,7 @@ func (s *ScanPlayedVideoSubInfo) dealOneVideo(index int, videoFPath, orgSubFPath
 
 	// 通过视频的绝对路径,从本地的视频文件对应的 nfo 获取到这个视频的 IMDB ID,
 	var err error
-	imdbInfoFromVideoFile, err := imdb_helper.GetIMDBInfoFromVideoFile(s.log, videoFPath, isMovie, s.settings.AdvancedSettings.ProxySettings)
+	imdbInfoFromVideoFile, err := imdb_helper.GetIMDBInfoFromVideoFile(s.fileDownloader.MediaInfoDealers, videoFPath, isMovie, s.settings.AdvancedSettings.ProxySettings)
 	if err != nil {
 		s.log.Errorln("GetIMDBInfoFromVideoFile", err)
 		return

+ 48 - 47
pkg/logic/series_helper/seriesHelper.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/allanpk716/ChineseSubFinder/pkg/media_info_dealers"
 	"github.com/allanpk716/ChineseSubFinder/pkg/search"
 
 	"github.com/allanpk716/ChineseSubFinder/pkg"
@@ -29,9 +30,9 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-func readSeriesInfo(log *logrus.Logger, seriesDir string, need2AnalyzeSub bool, _proxySettings *settings.ProxySettings) (*series.SeriesInfo, map[string][]series.SubInfo, error) {
+func readSeriesInfo(dealers *media_info_dealers.Dealers, seriesDir string, need2AnalyzeSub bool, _proxySettings *settings.ProxySettings) (*series.SeriesInfo, map[string][]series.SubInfo, error) {
 
-	seriesInfo, err := GetSeriesInfoFromDir(log, seriesDir, _proxySettings)
+	seriesInfo, err := GetSeriesInfoFromDir(dealers, seriesDir, _proxySettings)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -45,22 +46,22 @@ func readSeriesInfo(log *logrus.Logger, seriesDir string, need2AnalyzeSub bool,
 		return seriesInfo, SubDict, nil
 	}
 
-	subParserHub := sub_parser_hub.NewSubParserHub(log, ass.NewParser(log), srt.NewParser(log))
+	subParserHub := sub_parser_hub.NewSubParserHub(dealers.Logger, ass.NewParser(dealers.Logger), srt.NewParser(dealers.Logger))
 	// 先搜索这个目录下,所有符合条件的视频
-	matchedVideoFile, err := search.MatchedVideoFile(log, seriesDir)
+	matchedVideoFile, err := search.MatchedVideoFile(dealers.Logger, seriesDir)
 	if err != nil {
 		return nil, nil, err
 	}
 	// 然后再从这个视频找到对用匹配的字幕
 	for _, oneVideoFPath := range matchedVideoFile {
 
-		subFiles, err := sub_helper.SearchMatchedSubFileByOneVideo(log, oneVideoFPath)
+		subFiles, err := sub_helper.SearchMatchedSubFileByOneVideo(dealers.Logger, oneVideoFPath)
 		if err != nil {
 			return nil, nil, err
 		}
 		epsVideoNfoInfo, err := decode.GetVideoNfoInfo4OneSeriesEpisode(oneVideoFPath)
 		if err != nil {
-			log.Errorln(err)
+			dealers.Logger.Errorln(err)
 			continue
 		}
 
@@ -68,11 +69,11 @@ func readSeriesInfo(log *logrus.Logger, seriesDir string, need2AnalyzeSub bool,
 
 			bFind, subParserFileInfo, err := subParserHub.DetermineFileTypeFromFile(subFile)
 			if err != nil {
-				log.Errorln("DetermineFileTypeFromFile", subFile, err)
+				dealers.Logger.Errorln("DetermineFileTypeFromFile", subFile, err)
 				continue
 			}
 			if bFind == false {
-				log.Warnln("DetermineFileTypeFromFile", subFile, "not support SubType")
+				dealers.Logger.Warnln("DetermineFileTypeFromFile", subFile, "not support SubType")
 				continue
 			}
 			// 判断这个字幕是否包含中文
@@ -101,7 +102,7 @@ func readSeriesInfo(log *logrus.Logger, seriesDir string, need2AnalyzeSub bool,
 }
 
 // ReadSeriesInfoFromDir 读取剧集的信息,只有那些 Eps 需要下载字幕的 NeedDlEpsKeyList
-func ReadSeriesInfoFromDir(log *logrus.Logger,
+func ReadSeriesInfoFromDir(dealers *media_info_dealers.Dealers,
 	seriesDir string,
 	ExpirationTime int,
 	forcedScanAndDownloadSub bool,
@@ -109,19 +110,19 @@ func ReadSeriesInfoFromDir(log *logrus.Logger,
 	_proxySettings *settings.ProxySettings,
 	epsMap ...map[int][]int) (*series.SeriesInfo, error) {
 
-	seriesInfo, SubDict, err := readSeriesInfo(log, seriesDir, need2AnalyzeSub, _proxySettings)
+	seriesInfo, SubDict, err := readSeriesInfo(dealers, seriesDir, need2AnalyzeSub, _proxySettings)
 	if err != nil {
 		return nil, err
 	}
 	// 搜索所有的视频
-	videoFiles, err := search.MatchedVideoFile(log, seriesDir)
+	videoFiles, err := search.MatchedVideoFile(dealers.Logger, seriesDir)
 	if err != nil {
 		return nil, err
 	}
 	// 视频字典 S01E01 - EpisodeInfo
 	EpisodeDict := make(map[string]series.EpisodeInfo)
 	for _, videoFile := range videoFiles {
-		getEpsInfoAndSubDic(log, videoFile, EpisodeDict, SubDict, epsMap...)
+		getEpsInfoAndSubDic(dealers.Logger, videoFile, EpisodeDict, SubDict, epsMap...)
 	}
 
 	for _, episodeInfo := range EpisodeDict {
@@ -129,22 +130,22 @@ func ReadSeriesInfoFromDir(log *logrus.Logger,
 		seriesInfo.SeasonDict[episodeInfo.Season] = episodeInfo.Season
 	}
 
-	seriesInfo.NeedDlEpsKeyList, seriesInfo.NeedDlSeasonDict = whichSeasonEpsNeedDownloadSub(log, seriesInfo, ExpirationTime, forcedScanAndDownloadSub)
+	seriesInfo.NeedDlEpsKeyList, seriesInfo.NeedDlSeasonDict = whichSeasonEpsNeedDownloadSub(dealers.Logger, seriesInfo, ExpirationTime, forcedScanAndDownloadSub)
 
 	return seriesInfo, nil
 }
 
 // ReadSeriesInfoFromEmby 将 Emby API 读取到的数据进行转换到通用的结构中,需要填充那些剧集需要下载,这样要的是一个连续剧的,不是所有的传入(只有那些 Eps 需要下载字幕的 NeedDlEpsKeyList)
-func ReadSeriesInfoFromEmby(log *logrus.Logger, seriesDir string, seriesVideoList []emby.EmbyMixInfo, ExpirationTime int, forcedScanAndDownloadSub bool, need2AnalyzeSub bool, _proxySettings *settings.ProxySettings) (*series.SeriesInfo, error) {
+func ReadSeriesInfoFromEmby(dealers *media_info_dealers.Dealers, seriesDir string, seriesVideoList []emby.EmbyMixInfo, ExpirationTime int, forcedScanAndDownloadSub bool, need2AnalyzeSub bool, _proxySettings *settings.ProxySettings) (*series.SeriesInfo, error) {
 
-	seriesInfo, SubDict, err := readSeriesInfo(log, seriesDir, need2AnalyzeSub, _proxySettings)
+	seriesInfo, SubDict, err := readSeriesInfo(dealers, seriesDir, need2AnalyzeSub, _proxySettings)
 	if err != nil {
 		return nil, err
 	}
 
 	EpisodeDict := make(map[string]series.EpisodeInfo)
 	for _, info := range seriesVideoList {
-		getEpsInfoAndSubDic(log, info.PhysicalVideoFileFullPath, EpisodeDict, SubDict)
+		getEpsInfoAndSubDic(dealers.Logger, info.PhysicalVideoFileFullPath, EpisodeDict, SubDict)
 	}
 
 	for _, episodeInfo := range EpisodeDict {
@@ -152,25 +153,25 @@ func ReadSeriesInfoFromEmby(log *logrus.Logger, seriesDir string, seriesVideoLis
 		seriesInfo.SeasonDict[episodeInfo.Season] = episodeInfo.Season
 	}
 
-	seriesInfo.NeedDlEpsKeyList, seriesInfo.NeedDlSeasonDict = whichSeasonEpsNeedDownloadSub(log, seriesInfo, ExpirationTime, forcedScanAndDownloadSub)
+	seriesInfo.NeedDlEpsKeyList, seriesInfo.NeedDlSeasonDict = whichSeasonEpsNeedDownloadSub(dealers.Logger, seriesInfo, ExpirationTime, forcedScanAndDownloadSub)
 
 	return seriesInfo, nil
 }
 
 // SkipChineseSeries 跳过中文连续剧
-func SkipChineseSeries(log *logrus.Logger, seriesRootPath string, _proxySettings *settings.ProxySettings) (bool, *models.IMDBInfo, error) {
+func SkipChineseSeries(dealers *media_info_dealers.Dealers, seriesRootPath string, _proxySettings *settings.ProxySettings) (bool, *models.IMDBInfo, error) {
 
 	imdbInfo, err := decode.GetVideoNfoInfo4SeriesDir(seriesRootPath)
 	if err != nil {
 		return false, nil, err
 	}
 
-	isChineseVideo, t, err := imdb_helper.IsChineseVideo(log, imdbInfo, _proxySettings)
+	isChineseVideo, t, err := imdb_helper.IsChineseVideo(dealers, imdbInfo, _proxySettings)
 	if err != nil {
 		return false, nil, err
 	}
 	if isChineseVideo == true {
-		log.Infoln("Skip", filepath.Base(seriesRootPath), "Sub Download, because series is Chinese")
+		dealers.Logger.Infoln("Skip", filepath.Base(seriesRootPath), "Sub Download, because series is Chinese")
 		return true, t, nil
 	} else {
 		return false, t, nil
@@ -178,43 +179,43 @@ func SkipChineseSeries(log *logrus.Logger, seriesRootPath string, _proxySettings
 }
 
 // DownloadSubtitleInAllSiteByOneSeries 一部连续剧,在所有的网站,下载相应的字幕
-func DownloadSubtitleInAllSiteByOneSeries(log *logrus.Logger, Suppliers []ifaces.ISupplier, seriesInfo *series.SeriesInfo, i int64) []supplier.SubInfo {
+func DownloadSubtitleInAllSiteByOneSeries(logger *logrus.Logger, Suppliers []ifaces.ISupplier, seriesInfo *series.SeriesInfo, i int64) []supplier.SubInfo {
 
 	defer func() {
-		log.Infoln(common.QueueName, i, "DlSub End", seriesInfo.DirPath)
-		log.Infoln("------------------------------------------")
+		logger.Infoln(common.QueueName, i, "DlSub End", seriesInfo.DirPath)
+		logger.Infoln("------------------------------------------")
 	}()
-	log.Infoln(common.QueueName, i, "DlSub Start", seriesInfo.DirPath)
-	log.Infoln(common.QueueName, i, "IMDB ID:", seriesInfo.ImdbId, "NeedDownloadSubs:", len(seriesInfo.NeedDlEpsKeyList))
+	logger.Infoln(common.QueueName, i, "DlSub Start", seriesInfo.DirPath)
+	logger.Infoln(common.QueueName, i, "IMDB ID:", seriesInfo.ImdbId, "NeedDownloadSubs:", len(seriesInfo.NeedDlEpsKeyList))
 	var outSUbInfos = make([]supplier.SubInfo, 0)
 	if len(seriesInfo.NeedDlEpsKeyList) < 1 {
 		return outSUbInfos
 	}
 	for key := range seriesInfo.NeedDlEpsKeyList {
-		log.Infoln(common.QueueName, i, "NeedDownloadEps", "-", key)
+		logger.Infoln(common.QueueName, i, "NeedDownloadEps", "-", key)
 	}
 
 	for _, oneSupplier := range Suppliers {
 
 		oneSupplierFunc := func() {
 			defer func() {
-				log.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), "End")
-				log.Infoln("------------------------------------------")
+				logger.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), "End")
+				logger.Infoln("------------------------------------------")
 			}()
 
 			var subInfos []supplier.SubInfo
-			log.Infoln("------------------------------------------")
-			log.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), "Start...")
+			logger.Infoln("------------------------------------------")
+			logger.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), "Start...")
 
 			if oneSupplier.OverDailyDownloadLimit() == true {
-				log.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), "Over Daily Download Limit")
+				logger.Infoln(common.QueueName, i, oneSupplier.GetSupplierName(), "Over Daily Download Limit")
 				return
 			}
 
 			// 一次性把这一部连续剧的所有字幕下载完
 			subInfos, err := oneSupplier.GetSubListFromFile4Series(seriesInfo)
 			if err != nil {
-				log.Errorln(common.QueueName, i, oneSupplier.GetSupplierName(), "GetSubListFromFile4Series", err)
+				logger.Errorln(common.QueueName, i, oneSupplier.GetSupplierName(), "GetSubListFromFile4Series", err)
 				return
 			}
 			// 把后缀名给改好
@@ -230,20 +231,20 @@ func DownloadSubtitleInAllSiteByOneSeries(log *logrus.Logger, Suppliers []ifaces
 }
 
 // GetSeriesListFromDirs 获取这个目录下的所有文件夹名称,默认为一个连续剧的目录的List
-func GetSeriesListFromDirs(log *logrus.Logger, dirs []string) (*treemap.Map, error) {
+func GetSeriesListFromDirs(logger *logrus.Logger, dirs []string) (*treemap.Map, error) {
 
 	defer func() {
-		log.Infoln("GetSeriesListFromDirs End")
-		log.Infoln("------------------------------------------")
+		logger.Infoln("GetSeriesListFromDirs End")
+		logger.Infoln("------------------------------------------")
 	}()
 
-	log.Infoln("------------------------------------------")
-	log.Infoln("GetSeriesListFromDirs Start...")
+	logger.Infoln("------------------------------------------")
+	logger.Infoln("GetSeriesListFromDirs Start...")
 
 	var fileFullPathMap = treemap.NewWithStringComparator()
 	for _, dir := range dirs {
 
-		seriesList, err := GetSeriesList(log, dir)
+		seriesList, err := GetSeriesList(logger, dir)
 		if err != nil {
 			return nil, err
 		}
@@ -278,7 +279,7 @@ func GetSeriesList(log *logrus.Logger, dir string) ([]string, error) {
 }
 
 // whichSeasonEpsNeedDownloadSub 有那些 Eps 需要下载的,按 SxEx 反回 epsKey
-func whichSeasonEpsNeedDownloadSub(log *logrus.Logger, seriesInfo *series.SeriesInfo, ExpirationTime int, forcedScanAndDownloadSub bool) (map[string]series.EpisodeInfo, map[int]int) {
+func whichSeasonEpsNeedDownloadSub(logger *logrus.Logger, seriesInfo *series.SeriesInfo, ExpirationTime int, forcedScanAndDownloadSub bool) (map[string]series.EpisodeInfo, map[int]int) {
 	var needDlSubEpsList = make(map[string]series.EpisodeInfo, 0)
 	var needDlSeasonList = make(map[int]int, 0)
 	currentTime := time.Now()
@@ -303,7 +304,7 @@ func whichSeasonEpsNeedDownloadSub(log *logrus.Logger, seriesInfo *series.Series
 		if epsInfo.AiredTime != "" {
 			baseTime, err = now.Parse(epsInfo.AiredTime)
 			if err != nil {
-				log.Errorln("SeriesInfo parse AiredTime", epsInfo.Title, epsInfo.Season, epsInfo.Episode, err)
+				logger.Errorln("SeriesInfo parse AiredTime", epsInfo.Title, epsInfo.Season, epsInfo.Episode, err)
 				baseTime = epsInfo.ModifyTime
 			}
 		} else {
@@ -317,16 +318,16 @@ func whichSeasonEpsNeedDownloadSub(log *logrus.Logger, seriesInfo *series.Series
 			needDlSeasonList[epsInfo.Season] = epsInfo.Season
 		} else {
 			if len(epsInfo.SubAlreadyDownloadedList) > 0 {
-				log.Infoln("Skip because find sub file and downloaded or aired over 3 months,", epsInfo.Title, epsInfo.Season, epsInfo.Episode)
+				logger.Infoln("Skip because find sub file and downloaded or aired over 3 months,", epsInfo.Title, epsInfo.Season, epsInfo.Episode)
 			} else if baseTime.AddDate(0, 0, ExpirationTime).After(currentTime) == false {
-				log.Infoln("Skip because 3 months pass,", epsInfo.Title, epsInfo.Season, epsInfo.Episode)
+				logger.Infoln("Skip because 3 months pass,", epsInfo.Title, epsInfo.Season, epsInfo.Episode)
 			}
 		}
 	}
 	return needDlSubEpsList, needDlSeasonList
 }
 
-func GetSeriesInfoFromDir(log *logrus.Logger, seriesDir string, _proxySettings *settings.ProxySettings) (*series.SeriesInfo, error) {
+func GetSeriesInfoFromDir(dealers *media_info_dealers.Dealers, seriesDir string, _proxySettings *settings.ProxySettings) (*series.SeriesInfo, error) {
 	seriesInfo := series.SeriesInfo{}
 	// 只考虑 IMDB 去查询,文件名目前发现可能会跟电影重复,导致很麻烦,本来也有前置要求要削刮器处理的
 	videoInfo, err := decode.GetVideoNfoInfo4SeriesDir(seriesDir)
@@ -334,7 +335,7 @@ func GetSeriesInfoFromDir(log *logrus.Logger, seriesDir string, _proxySettings *
 		return nil, err
 	}
 
-	imdbInfo, err := imdb_helper.GetIMDBInfoFromVideoNfoInfo(log, videoInfo, _proxySettings)
+	imdbInfo, err := imdb_helper.GetIMDBInfoFromVideoNfoInfo(dealers, videoInfo, _proxySettings)
 	if err != nil {
 		return nil, err
 	}
@@ -363,7 +364,7 @@ func GetSeriesInfoFromDir(log *logrus.Logger, seriesDir string, _proxySettings *
 		if err != nil {
 			// 不是必须的
 			seriesInfo.Year = 0
-			log.Warnln("ReadSeriesInfoFromDir.GetVideoNfoInfo4SeriesDir.strconv.Atoi", seriesDir, err)
+			dealers.Logger.Warnln("ReadSeriesInfoFromDir.GetVideoNfoInfo4SeriesDir.strconv.Atoi", seriesDir, err)
 		} else {
 			seriesInfo.Year = iYear
 		}
@@ -376,7 +377,7 @@ func GetSeriesInfoFromDir(log *logrus.Logger, seriesDir string, _proxySettings *
 	return &seriesInfo, nil
 }
 
-func getEpsInfoAndSubDic(log *logrus.Logger,
+func getEpsInfoAndSubDic(logger *logrus.Logger,
 	videoFile string,
 	EpisodeDict map[string]series.EpisodeInfo,
 	SubDict map[string][]series.SubInfo,
@@ -384,7 +385,7 @@ func getEpsInfoAndSubDic(log *logrus.Logger,
 	// 正常来说,一集只有一个格式的视频,也就是 S01E01 只有一个,如果有多个则会只保存第一个
 	episodeInfo, modifyTime, err := decode.GetVideoInfoFromFileFullPath(videoFile, false)
 	if err != nil {
-		log.Errorln("model.GetVideoInfoFromFileFullPath", videoFile, err)
+		logger.Errorln("model.GetVideoInfoFromFileFullPath", videoFile, err)
 		return
 	}
 

+ 10 - 8
pkg/logic/sub_supplier/subSupplierHub.go

@@ -3,6 +3,8 @@ package sub_supplier
 import (
 	"path/filepath"
 
+	"github.com/allanpk716/ChineseSubFinder/pkg/media_info_dealers"
+
 	"github.com/allanpk716/ChineseSubFinder/pkg/ifaces"
 	"github.com/allanpk716/ChineseSubFinder/pkg/types/backend"
 	"github.com/allanpk716/ChineseSubFinder/pkg/types/emby"
@@ -54,7 +56,7 @@ func (d *SubSupplierHub) DelSubSupplier(one ifaces.ISupplier) {
 }
 
 // MovieNeedDlSub 电影是否符合要求需要下载字幕,比如
-func (d *SubSupplierHub) MovieNeedDlSub(videoFullPath string, forcedScanAndDownloadSub bool) bool {
+func (d *SubSupplierHub) MovieNeedDlSub(dealers *media_info_dealers.Dealers, videoFullPath string, forcedScanAndDownloadSub bool) bool {
 
 	if forcedScanAndDownloadSub == true {
 		return true
@@ -64,7 +66,7 @@ func (d *SubSupplierHub) MovieNeedDlSub(videoFullPath string, forcedScanAndDownl
 	if d.settings.AdvancedSettings.ScanLogic.SkipChineseMovie == true {
 		var skip bool
 		// 跳过中文的电影,不是一定要跳过的
-		skip, err = movieHelper.SkipChineseMovie(d.log, videoFullPath, d.settings.AdvancedSettings.ProxySettings)
+		skip, err = movieHelper.SkipChineseMovie(dealers, videoFullPath, d.settings.AdvancedSettings.ProxySettings)
 		if err != nil {
 			d.log.Warnln("SkipChineseMovie", videoFullPath, err)
 		}
@@ -89,14 +91,14 @@ func (d *SubSupplierHub) MovieNeedDlSub(videoFullPath string, forcedScanAndDownl
 }
 
 // SeriesNeedDlSub 连续剧是否符合要求需要下载字幕
-func (d *SubSupplierHub) SeriesNeedDlSub(seriesRootPath string, forcedScanAndDownloadSub bool, need2AnalyzeSub bool) (bool, *series.SeriesInfo, error) {
+func (d *SubSupplierHub) SeriesNeedDlSub(dealers *media_info_dealers.Dealers, seriesRootPath string, forcedScanAndDownloadSub bool, need2AnalyzeSub bool) (bool, *series.SeriesInfo, error) {
 
 	if forcedScanAndDownloadSub == false {
 		if d.settings.AdvancedSettings.ScanLogic.SkipChineseSeries == true {
 			var skip bool
 			var err error
 			// 跳过中文的电影,不是一定要跳过的
-			skip, _, err = seriesHelper.SkipChineseSeries(d.log, seriesRootPath, d.settings.AdvancedSettings.ProxySettings)
+			skip, _, err = seriesHelper.SkipChineseSeries(dealers, seriesRootPath, d.settings.AdvancedSettings.ProxySettings)
 			if err != nil {
 				d.log.Warnln("SkipChineseMovie", seriesRootPath, err)
 			}
@@ -107,7 +109,7 @@ func (d *SubSupplierHub) SeriesNeedDlSub(seriesRootPath string, forcedScanAndDow
 	}
 
 	// 读取本地的视频和字幕信息
-	seriesInfo, err := seriesHelper.ReadSeriesInfoFromDir(d.log, seriesRootPath,
+	seriesInfo, err := seriesHelper.ReadSeriesInfoFromDir(dealers, seriesRootPath,
 		d.settings.AdvancedSettings.TaskQueue.ExpirationTime,
 		forcedScanAndDownloadSub,
 		need2AnalyzeSub,
@@ -120,13 +122,13 @@ func (d *SubSupplierHub) SeriesNeedDlSub(seriesRootPath string, forcedScanAndDow
 }
 
 // SeriesNeedDlSubFromEmby 连续剧是否符合要求需要下载字幕
-func (d *SubSupplierHub) SeriesNeedDlSubFromEmby(seriesRootPath string, seriesVideoList []emby.EmbyMixInfo, ExpirationTime int, skipChineseMovie, forcedScanAndDownloadSub bool) (bool, *series.SeriesInfo, error) {
+func (d *SubSupplierHub) SeriesNeedDlSubFromEmby(dealers *media_info_dealers.Dealers, seriesRootPath string, seriesVideoList []emby.EmbyMixInfo, ExpirationTime int, skipChineseMovie, forcedScanAndDownloadSub bool) (bool, *series.SeriesInfo, error) {
 
 	if skipChineseMovie == true {
 		var skip bool
 		var err error
 		// 跳过中文的电影,不是一定要跳过的
-		skip, _, err = seriesHelper.SkipChineseSeries(d.log, seriesRootPath, d.settings.AdvancedSettings.ProxySettings)
+		skip, _, err = seriesHelper.SkipChineseSeries(dealers, seriesRootPath, d.settings.AdvancedSettings.ProxySettings)
 		if err != nil {
 			d.log.Warnln("SkipChineseMovie", seriesRootPath, err)
 		}
@@ -135,7 +137,7 @@ func (d *SubSupplierHub) SeriesNeedDlSubFromEmby(seriesRootPath string, seriesVi
 		}
 	}
 	// 读取本地的视频和字幕信息
-	seriesInfo, err := seriesHelper.ReadSeriesInfoFromEmby(d.log, seriesRootPath, seriesVideoList, ExpirationTime, forcedScanAndDownloadSub, false, d.settings.AdvancedSettings.ProxySettings)
+	seriesInfo, err := seriesHelper.ReadSeriesInfoFromEmby(dealers, seriesRootPath, seriesVideoList, ExpirationTime, forcedScanAndDownloadSub, false, d.settings.AdvancedSettings.ProxySettings)
 	if err != nil {
 		return false, nil, errors.Newf("ReadSeriesInfoFromDir %v %v", seriesRootPath, err)
 	}

+ 27 - 0
pkg/media_info_dealers/dealers.go

@@ -27,6 +27,33 @@ func (d *Dealers) SetTmdbHelperInstance(tmdbHelper *tmdb_api.TmdbApi) {
 	d.tmdbHelper = tmdbHelper
 }
 
+// ConvertId 目前仅仅支持 TMDB ID 转 IMDB ID
+func (d *Dealers) ConvertId(iD string, idType string, isMovieOrSeries bool) (convertIdResult *tmdb_api.ConvertIdResult, err error) {
+
+	if d.tmdbHelper != nil && d.settings.AdvancedSettings.TmdbApiSettings.Enable == true && d.settings.AdvancedSettings.TmdbApiSettings.ApiKey != "" {
+		// 优先使用用户自己的 tmdb api
+		return d.tmdbHelper.ConvertId(iD, idType, isMovieOrSeries)
+	} else {
+		// 使用默认的公用服务器 tmdb api
+		videoType := ""
+		if isMovieOrSeries == true {
+			videoType = "movie"
+		} else {
+			videoType = "series"
+		}
+		idConvertReply, err := d.SubtitleBestApi.ConvertId(iD, idType, videoType)
+		if err != nil {
+			return nil, err
+		}
+
+		return &tmdb_api.ConvertIdResult{
+			ImdbID: idConvertReply.IMDBId,
+			TmdbID: iD,
+			TvdbID: idConvertReply.TVDBId,
+		}, nil
+	}
+}
+
 func (d *Dealers) GetMediaInfo(id, source, videoType string) (*models.MediaInfo, error) {
 
 	if d.tmdbHelper != nil && d.settings.AdvancedSettings.TmdbApiSettings.Enable == true && d.settings.AdvancedSettings.TmdbApiSettings.ApiKey != "" {

+ 1 - 1
pkg/mix_media_info/mix_media_info.go

@@ -21,7 +21,7 @@ func GetMixMediaInfo(
 	dealers *media_info_dealers.Dealers,
 	videoFPath string, isMovie bool, _proxySettings *settings.ProxySettings) (*models.MediaInfo, error) {
 
-	imdbInfo, err := imdb_helper.GetIMDBInfoFromVideoFile(dealers.Logger, videoFPath, isMovie, _proxySettings)
+	imdbInfo, err := imdb_helper.GetIMDBInfoFromVideoFile(dealers, videoFPath, isMovie, _proxySettings)
 	if err != nil {
 		return nil, err
 	}

+ 1 - 0
pkg/subtitle_best_api/subtitle_best_api.go

@@ -599,6 +599,7 @@ func (s *SubtitleBestApi) DownloadSub(SubSha256, DownloadToken, ApiKey, download
 	return &downloadReply, nil
 }
 
+// ConvertId 目前仅仅支持 TMDB ID 转 IMDB ID
 func (s *SubtitleBestApi) ConvertId(id, source, videoType string) (*IdConvertReply, error) {
 
 	if s.authKey.BaseKey == random_auth_key.BaseKey || s.authKey.AESKey16 == random_auth_key.AESKey16 || s.authKey.AESIv16 == random_auth_key.AESIv16 {

+ 3 - 2
pkg/tmdb_api/tmdb.go

@@ -156,7 +156,8 @@ func (t *TmdbApi) GetInfo(iD string, idType string, isMovieOrSeries, isQueryEnOr
 	return outFindByID, nil
 }
 
-func (t *TmdbApi) CovertId(iD string, idType string, isMovieOrSeries bool) (convertIdResult *ConvertIdResult, err error) {
+// ConvertId 目前仅仅支持 TMDB ID 转 IMDB ID
+func (t *TmdbApi) ConvertId(iD string, idType string, isMovieOrSeries bool) (convertIdResult *ConvertIdResult, err error) {
 
 	if idType == ImdbID {
 		return nil, fmt.Errorf("imdb id type is not supported")
@@ -193,7 +194,7 @@ func (t *TmdbApi) CovertId(iD string, idType string, isMovieOrSeries bool) (conv
 			return convertIdResult, nil
 		}
 	} else {
-		return nil, fmt.Errorf("id type is not supported")
+		return nil, fmt.Errorf("id type is not supported: " + idType)
 	}
 }
 

+ 14 - 10
pkg/video_scan_and_refresh_helper/video_scan_and_refresh_helper.go

@@ -266,12 +266,12 @@ func (v *VideoScanAndRefreshHelper) ScanEmbyMovieAndSeries(scanVideoResult *Scan
 			v.log.Infoln("Forced Scan And DownSub, tmpSetting.EmbySettings.MaxRequestVideoNumber = 1000000")
 			// 如果是强制,那么就临时修改 Setting 的 Emby MaxRequestVideoNumber 参数为 1000000
 			//tmpSetting := clone.Clone(v.settings).(*settings.Settings)
-			v.embyHelper = embyHelper.NewEmbyHelper(v.log, v.settings)
+			v.embyHelper = embyHelper.NewEmbyHelper(v.fileDownloader.MediaInfoDealers, v.settings)
 			v.embyHelper.SetMaxRequestVideoNumber(common2.EmbyApiGetItemsLimitMax)
 			v.embyHelper.SetSkipWatched(false)
 		} else {
 			v.log.Infoln("Not Forced Scan And DownSub")
-			v.embyHelper = embyHelper.NewEmbyHelper(v.log, v.settings)
+			v.embyHelper = embyHelper.NewEmbyHelper(v.fileDownloader.MediaInfoDealers, v.settings)
 		}
 	}
 	var err error
@@ -341,7 +341,7 @@ func (v *VideoScanAndRefreshHelper) RefreshMediaServerSubList() error {
 	v.log.Infoln("tmpSetting.EmbySettings.MaxRequestVideoNumber = 1000000")
 	// 如果是强制,那么就临时修改 Setting 的 Emby MaxRequestVideoNumber 参数为 1000000
 	//tmpSetting := clone.Clone(v.settings).(*settings.Settings)
-	v.embyHelper = embyHelper.NewEmbyHelper(v.log, v.settings)
+	v.embyHelper = embyHelper.NewEmbyHelper(v.fileDownloader.MediaInfoDealers, v.settings)
 	v.embyHelper.SetMaxRequestVideoNumber(common2.EmbyApiGetItemsLimitMax)
 	v.embyHelper.SetSkipWatched(false)
 	var err error
@@ -430,7 +430,7 @@ func (v *VideoScanAndRefreshHelper) scanLowVideoSubInfo(scanVideoResult *ScanVid
 		seriesDirRootFPathLisst := seriesFPath.([]string)
 		for seriesDirIndex, seriesDirRootFPath := range seriesDirRootFPathLisst {
 
-			seriesInfo, err := seriesHelper.ReadSeriesInfoFromDir(v.log, seriesDirRootFPath, 90, true, true, v.settings.AdvancedSettings.ProxySettings)
+			seriesInfo, err := seriesHelper.ReadSeriesInfoFromDir(v.fileDownloader.MediaInfoDealers, seriesDirRootFPath, 90, true, true, v.settings.AdvancedSettings.ProxySettings)
 			if err != nil {
 				v.log.Warningln("scanLowVideoSubInfo.ReadSeriesInfoFromDir", seriesDirRootFPath, err)
 				return false
@@ -685,7 +685,9 @@ func (v *VideoScanAndRefreshHelper) scrabbleUpVideoListNormal(normal *NormalScan
 		}
 		v.processLocker.Unlock()
 
-		bNeedDlSub, seriesInfo, err := v.subSupplierHub.SeriesNeedDlSub(oneSeriesRootDir,
+		bNeedDlSub, seriesInfo, err := v.subSupplierHub.SeriesNeedDlSub(
+			v.fileDownloader.MediaInfoDealers,
+			oneSeriesRootDir,
 			v.NeedForcedScanAndDownSub, false)
 		if err != nil {
 			v.log.Errorln("filterMovieAndSeriesNeedDownloadNormal.SeriesNeedDlSub", err)
@@ -1051,7 +1053,7 @@ func (v *VideoScanAndRefreshHelper) updateLocalVideoCacheInfo(scanVideoResult *S
 			return err
 		}
 		// 获取 IMDB 信息
-		localIMDBInfo, err := imdb_helper.GetIMDBInfoFromVideoNfoInfo(v.log, videoImdbInfo, v.settings.AdvancedSettings.ProxySettings)
+		localIMDBInfo, err := imdb_helper.GetIMDBInfoFromVideoNfoInfo(v.fileDownloader.MediaInfoDealers, videoImdbInfo, v.settings.AdvancedSettings.ProxySettings)
 		if err != nil {
 			v.log.Warningln("GetIMDBInfoFromVideoNfoInfo,IMDB:", videoImdbInfo.ImdbId, movieInputData.InputPath, err)
 			return err
@@ -1105,7 +1107,7 @@ func (v *VideoScanAndRefreshHelper) updateLocalVideoCacheInfo(scanVideoResult *S
 		}
 
 		// 获取 IMDB 信息
-		localIMDBInfo, err := imdb_helper.GetIMDBInfoFromVideoNfoInfo(v.log, videoNfoInfo, v.settings.AdvancedSettings.ProxySettings)
+		localIMDBInfo, err := imdb_helper.GetIMDBInfoFromVideoNfoInfo(v.fileDownloader.MediaInfoDealers, videoNfoInfo, v.settings.AdvancedSettings.ProxySettings)
 		if err != nil {
 			v.log.Warningln("GetIMDBInfoFromVideoNfoInfo,IMDB:", videoNfoInfo.ImdbId, seriesInputData.InputPath, err)
 			return err
@@ -1152,7 +1154,7 @@ func (v *VideoScanAndRefreshHelper) filterMovieAndSeriesNeedDownloadNormal(norma
 
 		taskData := inData.(*task_control.TaskData)
 		movieInputData := taskData.DataEx.(TaskInputData)
-		if v.subSupplierHub.MovieNeedDlSub(movieInputData.InputPath, v.NeedForcedScanAndDownSub) == false {
+		if v.subSupplierHub.MovieNeedDlSub(v.fileDownloader.MediaInfoDealers, movieInputData.InputPath, v.NeedForcedScanAndDownSub) == false {
 			return nil
 		}
 		bok, err := v.downloadQueue.Add(*task_queue2.NewOneJob(
@@ -1206,7 +1208,9 @@ func (v *VideoScanAndRefreshHelper) filterMovieAndSeriesNeedDownloadNormal(norma
 		taskData := inData.(*task_control.TaskData)
 		seriesInputData := taskData.DataEx.(TaskInputData)
 		// 因为可能回去 Web 获取 IMDB 信息,所以这里的错误不返回
-		bNeedDlSub, seriesInfo, err := v.subSupplierHub.SeriesNeedDlSub(seriesInputData.InputPath,
+		bNeedDlSub, seriesInfo, err := v.subSupplierHub.SeriesNeedDlSub(
+			v.fileDownloader.MediaInfoDealers,
+			seriesInputData.InputPath,
 			v.NeedForcedScanAndDownSub, false)
 		if err != nil {
 			v.log.Errorln("filterMovieAndSeriesNeedDownloadNormal.SeriesNeedDlSub", err)
@@ -1289,7 +1293,7 @@ func (v *VideoScanAndRefreshHelper) filterMovieAndSeriesNeedDownloadEmby(emby *E
 		}
 
 		// 放入队列
-		if v.subSupplierHub.MovieNeedDlSub(oneMovieMixInfo.PhysicalVideoFileFullPath, v.NeedForcedScanAndDownSub) == false {
+		if v.subSupplierHub.MovieNeedDlSub(v.fileDownloader.MediaInfoDealers, oneMovieMixInfo.PhysicalVideoFileFullPath, v.NeedForcedScanAndDownSub) == false {
 			continue
 		}
 		nowOneJob := task_queue2.NewOneJob(