refactor code

2026-07-28 06:00:24 +08:00 · 2024-07-31 14:41:57 +08:00
parent 0ea1c040a2
commit 9ba59a7d5a
22 changed files with 728 additions and 325 deletions
--- a/server/resources.go
+++ b/server/resources.go
@@ -54,13 +54,13 @@ func (s *Server) downloadSeasonPackage(r1 torznab.Result, seriesId, seasonNum in
 	dir := fmt.Sprintf("%s/Season %02d/", series.TargetDir, seasonNum)

 	history, err := s.db.SaveHistoryRecord(ent.History{
-		MediaID:     seriesId,
-		EpisodeID:   0,
-		SourceTitle: r1.Name,
-		TargetDir:   dir,
-		Status:      history.StatusRunning,
-		Size:        r1.Size,
-		Saved:       torrent.Save(),
+		MediaID:          seriesId,
+		EpisodeID:        0,
+		SourceTitle:      r1.Name,
+		TargetDir:        dir,
+		Status:           history.StatusRunning,
+		Size:             r1.Size,
+		Saved:            torrent.Save(),
 		DownloadClientID: dlClient.ID,
 	})
 	if err != nil {
@@ -102,13 +102,13 @@ func (s *Server) downloadEpisodeTorrent(r1 torznab.Result, seriesId, seasonNum,
 	dir := fmt.Sprintf("%s/Season %02d/", series.TargetDir, seasonNum)

 	history, err := s.db.SaveHistoryRecord(ent.History{
-		MediaID:     ep.MediaID,
-		EpisodeID:   ep.ID,
-		SourceTitle: r1.Name,
-		TargetDir:   dir,
-		Status:      history.StatusRunning,
-		Size:        r1.Size,
-		Saved:       torrent.Save(),
+		MediaID:          ep.MediaID,
+		EpisodeID:        ep.ID,
+		SourceTitle:      r1.Name,
+		TargetDir:        dir,
+		Status:           history.StatusRunning,
+		Size:             r1.Size,
+		Saved:            torrent.Save(),
 		DownloadClientID: dlc.ID,
 	})
 	if err != nil {
@@ -265,44 +265,46 @@ func (s *Server) DownloadTorrent(c *gin.Context) (interface{}, error) {
 		}
 		res := torznab.Result{Name: name, Link: in.Link, Size: in.Size}
 		return s.downloadEpisodeTorrent(res, in.MediaID, in.Season, in.Episode)
-	}
-	trc, dlc, err := s.getDownloadClient()
-	if err != nil {
-		return nil, errors.Wrap(err, "connect transmission")
-	}
-
-	torrent, err := trc.Download(in.Link, s.db.GetDownloadDir())
-	if err != nil {
-		return nil, errors.Wrap(err, "downloading")
-	}
-	torrent.Start()
-	name := in.Name
-	if name == "" {
-		name = m.OriginalName
-	}
-	go func() {
-		ep, _ := s.db.GetMovieDummyEpisode(m.ID)
-		history, err := s.db.SaveHistoryRecord(ent.History{
-			MediaID:     m.ID,
-			EpisodeID:   ep.ID,
-			SourceTitle: name,
-			TargetDir:   m.TargetDir,
-			Status:      history.StatusRunning,
-			Size:        in.Size,
-			Saved:       torrent.Save(),
-			DownloadClientID: dlc.ID,
-		})
+	} else {
+		//movie
+		trc, dlc, err := s.getDownloadClient()
 		if err != nil {
-			log.Errorf("save history error: %v", err)
+			return nil, errors.Wrap(err, "connect transmission")
 		}

-		s.tasks[history.ID] = &Task{Torrent: torrent}
+		torrent, err := trc.Download(in.Link, s.db.GetDownloadDir())
+		if err != nil {
+			return nil, errors.Wrap(err, "downloading")
+		}
+		torrent.Start()
+		name := in.Name
+		if name == "" {
+			name = m.OriginalName
+		}
+		go func() {
+			ep, _ := s.db.GetMovieDummyEpisode(m.ID)
+			history, err := s.db.SaveHistoryRecord(ent.History{
+				MediaID:          m.ID,
+				EpisodeID:        ep.ID,
+				SourceTitle:      name,
+				TargetDir:        m.TargetDir,
+				Status:           history.StatusRunning,
+				Size:             in.Size,
+				Saved:            torrent.Save(),
+				DownloadClientID: dlc.ID,
+			})
+			if err != nil {
+				log.Errorf("save history error: %v", err)
+			}

-		s.db.SetEpisodeStatus(ep.ID, episode.StatusDownloading)
-	}()
+			s.tasks[history.ID] = &Task{Torrent: torrent}

-	s.sendMsg(fmt.Sprintf(message.BeginDownload, in.Name))
-	log.Infof("success add %s to download task", in.Name)
-	return in.Name, nil
+			s.db.SetEpisodeStatus(ep.ID, episode.StatusDownloading)
+		}()
+
+		s.sendMsg(fmt.Sprintf(message.BeginDownload, in.Name))
+		log.Infof("success add %s to download task", in.Name)
+		return in.Name, nil
+	}

 }
--- a/server/storage.go
+++ b/server/storage.go
@@ -29,7 +29,7 @@ func (s *Server) AddStorage(c *gin.Context) (interface{}, error) {
 	if in.Implementation == "webdav" {
 		//test webdav
 		wd := in.ToWebDavSetting()
-		st, err := storage.NewWebdavStorage(wd.URL, wd.User, wd.Password, wd.TvPath, false)
+		st, err := storage.NewWebdavStorage(wd.URL, wd.User, wd.Password, in.TvPath, false)
 		if err != nil {
 			return nil, errors.Wrap(err, "new webdav")
 		}
@@ -112,13 +112,14 @@ func (s *Server) SuggestedMovieFolderName(c *gin.Context) (interface{}, error) {

 func (s *Server) getStorage(storageId int, mediaType media.MediaType) (storage.Storage, error) {
 	st := s.db.GetStorage(storageId)
+	targetPath := st.TvPath
+	if mediaType == media.MediaTypeMovie {
+		targetPath = st.MoviePath
+	}
+
 	switch st.Implementation {
 	case storage1.ImplementationLocal:
-		ls := st.ToLocalSetting()
-		targetPath := ls.TvPath
-		if mediaType == media.MediaTypeMovie {
-			targetPath = ls.MoviePath
-		}
+
 		storageImpl1, err := storage.NewLocalStorage(targetPath)
 		if err != nil {
 			return nil, errors.Wrap(err, "new local")
@@ -127,11 +128,6 @@ func (s *Server) getStorage(storageId int, mediaType media.MediaType) (storage.S

 	case storage1.ImplementationWebdav:
 		ws := st.ToWebDavSetting()
-		targetPath := ws.TvPath
-		if mediaType == media.MediaTypeMovie {
-			targetPath = ws.MoviePath
-		}
-
 		storageImpl1, err := storage.NewWebdavStorage(ws.URL, ws.User, ws.Password, targetPath, ws.ChangeFileHash == "true")
 		if err != nil {
 			return nil, errors.Wrap(err, "new webdav")
--- a/server/watchlist.go
+++ b/server/watchlist.go
@@ -112,16 +112,16 @@ func (s *Server) AddTv2Watchlist(c *gin.Context) (interface{}, error) {
 		}
 	}
 	r, err := s.db.AddMediaWatchlist(&ent.Media{
-		TmdbID:       int(detail.ID),
-		MediaType:    media.MediaTypeTv,
-		NameCn:       nameCn,
-		NameEn:       nameEn,
-		OriginalName: detail.OriginalName,
-		Overview:     detail.Overview,
-		AirDate:      detail.FirstAirDate,
-		Resolution:   media.Resolution(in.Resolution),
-		StorageID:    in.StorageID,
-		TargetDir:    in.Folder,
+		TmdbID:                  int(detail.ID),
+		MediaType:               media.MediaTypeTv,
+		NameCn:                  nameCn,
+		NameEn:                  nameEn,
+		OriginalName:            detail.OriginalName,
+		Overview:                detail.Overview,
+		AirDate:                 detail.FirstAirDate,
+		Resolution:              media.Resolution(in.Resolution),
+		StorageID:               in.StorageID,
+		TargetDir:               in.Folder,
 		DownloadHistoryEpisodes: in.DownloadHistoryEpisodes,
 	}, epIds)
 	if err != nil {
@@ -304,6 +304,11 @@ func (s *Server) GetMovieWatchlist(c *gin.Context) (interface{}, error) {
 	return res, nil
 }

+type MediaDetails struct {
+	*db.MediaDetails
+	Storage *ent.Storage `json:"storage"`
+}
+
 func (s *Server) GetMediaDetails(c *gin.Context) (interface{}, error) {
 	ids := c.Param("id")
 	id, err := strconv.Atoi(ids)
@@ -311,7 +316,8 @@ func (s *Server) GetMediaDetails(c *gin.Context) (interface{}, error) {
 		return nil, errors.Wrap(err, "convert")
 	}
 	detail := s.db.GetMediaDetails(id)
-	return detail, nil
+	st := s.db.GetStorage(detail.StorageID)
+	return MediaDetails{MediaDetails: detail, Storage: &st.Storage}, nil
 }

 func (s *Server) GetAvailableResolutions(c *gin.Context) (interface{}, error) {