- Revamp decypharr arch \n

- Add callback_ur, download_folder to addContent API \n
- Fix few bugs \n
- More declarative UI keywords
- Speed up repairs
- Few other improvements/bug fixes

pkg/qbit/context.go

@@ -0,0 +1,127 @@
+package qbit
+
+import (
+	"context"
+	"encoding/base64"
+	"github.com/go-chi/chi/v5"
+	"github.com/sirrobot01/decypharr/pkg/arr"
+	"github.com/sirrobot01/decypharr/pkg/store"
+	"net/http"
+	"strings"
+)
+
+type contextKey string
+
+const (
+	categoryKey contextKey = "category"
+	hashesKey   contextKey = "hashes"
+	arrKey      contextKey = "arr"
+)
+
+func getCategory(ctx context.Context) string {
+	if category, ok := ctx.Value(categoryKey).(string); ok {
+		return category
+	}
+	return ""
+}
+
+func getHashes(ctx context.Context) []string {
+	if hashes, ok := ctx.Value(hashesKey).([]string); ok {
+		return hashes
+	}
+	return nil
+}
+
+func getArr(ctx context.Context) *arr.Arr {
+	if a, ok := ctx.Value(arrKey).(*arr.Arr); ok {
+		return a
+	}
+	return nil
+}
+
+func decodeAuthHeader(header string) (string, string, error) {
+	encodedTokens := strings.Split(header, " ")
+	if len(encodedTokens) != 2 {
+		return "", "", nil
+	}
+	encodedToken := encodedTokens[1]
+
+	bytes, err := base64.StdEncoding.DecodeString(encodedToken)
+	if err != nil {
+		return "", "", err
+	}
+
+	bearer := string(bytes)
+
+	colonIndex := strings.LastIndex(bearer, ":")
+	host := bearer[:colonIndex]
+	token := bearer[colonIndex+1:]
+
+	return host, token, nil
+}
+
+func (q *QBit) categoryContext(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		category := strings.Trim(r.URL.Query().Get("category"), "")
+		if category == "" {
+			// Get from form
+			_ = r.ParseForm()
+			category = r.Form.Get("category")
+			if category == "" {
+				// Get from multipart form
+				_ = r.ParseMultipartForm(32 << 20)
+				category = r.FormValue("category")
+			}
+		}
+		ctx := context.WithValue(r.Context(), categoryKey, strings.TrimSpace(category))
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func (q *QBit) authContext(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		host, token, err := decodeAuthHeader(r.Header.Get("Authorization"))
+		category := getCategory(r.Context())
+		arrs := store.GetStore().GetArr()
+		// Check if arr exists
+		a := arrs.Get(category)
+		if a == nil {
+			downloadUncached := false
+			a = arr.New(category, "", "", false, false, &downloadUncached)
+		}
+		if err == nil {
+			host = strings.TrimSpace(host)
+			if host != "" {
+				a.Host = host
+			}
+			token = strings.TrimSpace(token)
+			if token != "" {
+				a.Token = token
+			}
+		}
+
+		arrs.AddOrUpdate(a)
+		ctx := context.WithValue(r.Context(), arrKey, a)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func hashesContext(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_hashes := chi.URLParam(r, "hashes")
+		var hashes []string
+		if _hashes != "" {
+			hashes = strings.Split(_hashes, "|")
+		}
+		if hashes == nil {
+			// Get hashes from form
+			_ = r.ParseForm()
+			hashes = r.Form["hashes"]
+		}
+		for i, hash := range hashes {
+			hashes[i] = strings.TrimSpace(hash)
+		}
+		ctx := context.WithValue(r.Context(), hashesKey, hashes)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}

pkg/qbit/downloader.go

@@ -1,384 +0,0 @@
-package qbit
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-
-	"github.com/cavaliergopher/grab/v3"
-	"github.com/sirrobot01/decypharr/internal/utils"
-	debrid "github.com/sirrobot01/decypharr/pkg/debrid/types"
-)
-
-func Download(client *grab.Client, url, filename string, byterange *[2]int64, progressCallback func(int64, int64)) error {
-	req, err := grab.NewRequest(filename, url)
-	if err != nil {
-		return err
-	}
-
-	// Set byte range if specified
-	if byterange != nil {
-		byterangeStr := fmt.Sprintf("%d-%d", byterange[0], byterange[1])
-		req.HTTPRequest.Header.Set("Range", "bytes="+byterangeStr)
-	}
-
-	resp := client.Do(req)
-
-	t := time.NewTicker(time.Second * 2)
-	defer t.Stop()
-
-	var lastReported int64
-Loop:
-	for {
-		select {
-		case <-t.C:
-			current := resp.BytesComplete()
-			speed := int64(resp.BytesPerSecond())
-			if current != lastReported {
-				if progressCallback != nil {
-					progressCallback(current-lastReported, speed)
-				}
-				lastReported = current
-			}
-		case <-resp.Done:
-			break Loop
-		}
-	}
-
-	// Report final bytes
-	if progressCallback != nil {
-		progressCallback(resp.BytesComplete()-lastReported, 0)
-	}
-
-	return resp.Err()
-}
-
-func (q *QBit) ProcessManualFile(torrent *Torrent) (string, error) {
-	debridTorrent := torrent.DebridTorrent
-	q.logger.Info().Msgf("Downloading %d files...", len(debridTorrent.Files))
-	torrentPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, utils.RemoveExtension(debridTorrent.OriginalFilename))
-	torrentPath = utils.RemoveInvalidChars(torrentPath)
-	err := os.MkdirAll(torrentPath, os.ModePerm)
-	if err != nil {
-		// add previous error to the error and return
-		return "", fmt.Errorf("failed to create directory: %s: %v", torrentPath, err)
-	}
-	q.downloadFiles(torrent, torrentPath)
-	return torrentPath, nil
-}
-
-func (q *QBit) downloadFiles(torrent *Torrent, parent string) {
-	debridTorrent := torrent.DebridTorrent
-	var wg sync.WaitGroup
-
-	totalSize := int64(0)
-	for _, file := range debridTorrent.GetFiles() {
-		totalSize += file.Size
-	}
-	debridTorrent.Mu.Lock()
-	debridTorrent.SizeDownloaded = 0 // Reset downloaded bytes
-	debridTorrent.Progress = 0       // Reset progress
-	debridTorrent.Mu.Unlock()
-	progressCallback := func(downloaded int64, speed int64) {
-		debridTorrent.Mu.Lock()
-		defer debridTorrent.Mu.Unlock()
-		torrent.Mu.Lock()
-		defer torrent.Mu.Unlock()
-
-		// Update total downloaded bytes
-		debridTorrent.SizeDownloaded += downloaded
-		debridTorrent.Speed = speed
-
-		// Calculate overall progress
-		if totalSize > 0 {
-			debridTorrent.Progress = float64(debridTorrent.SizeDownloaded) / float64(totalSize) * 100
-		}
-		q.UpdateTorrentMin(torrent, debridTorrent)
-	}
-	client := &grab.Client{
-		UserAgent: "Decypharr[QBitTorrent]",
-		HTTPClient: &http.Client{
-			Transport: &http.Transport{
-				Proxy: http.ProxyFromEnvironment,
-			},
-		},
-	}
-	errChan := make(chan error, len(debridTorrent.Files))
-	for _, file := range debridTorrent.GetFiles() {
-		if file.DownloadLink == nil {
-			q.logger.Info().Msgf("No download link found for %s", file.Name)
-			continue
-		}
-		wg.Add(1)
-		q.downloadSemaphore <- struct{}{}
-		go func(file debrid.File) {
-			defer wg.Done()
-			defer func() { <-q.downloadSemaphore }()
-			filename := file.Name
-
-			err := Download(
-				client,
-				file.DownloadLink.DownloadLink,
-				filepath.Join(parent, filename),
-				file.ByteRange,
-				progressCallback,
-			)
-
-			if err != nil {
-				q.logger.Error().Msgf("Failed to download %s: %v", filename, err)
-				errChan <- err
-			} else {
-				q.logger.Info().Msgf("Downloaded %s", filename)
-			}
-		}(file)
-	}
-	wg.Wait()
-
-	close(errChan)
-	var errors []error
-	for err := range errChan {
-		if err != nil {
-			errors = append(errors, err)
-		}
-	}
-	if len(errors) > 0 {
-		q.logger.Error().Msgf("Errors occurred during download: %v", errors)
-		return
-	}
-	q.logger.Info().Msgf("Downloaded all files for %s", debridTorrent.Name)
-}
-
-func (q *QBit) ProcessSymlink(torrent *Torrent) (string, error) {
-	debridTorrent := torrent.DebridTorrent
-	files := debridTorrent.Files
-	if len(files) == 0 {
-		return "", fmt.Errorf("no video files found")
-	}
-	q.logger.Info().Msgf("Checking symlinks for %d files...", len(files))
-	rCloneBase := debridTorrent.MountPath
-	torrentPath, err := q.getTorrentPath(rCloneBase, debridTorrent) // /MyTVShow/
-	// This returns filename.ext for alldebrid instead of the parent folder filename/
-	torrentFolder := torrentPath
-	if err != nil {
-		return "", fmt.Errorf("failed to get torrent path: %v", err)
-	}
-	// Check if the torrent path is a file
-	torrentRclonePath := filepath.Join(rCloneBase, torrentPath) // leave it as is
-	if debridTorrent.Debrid == "alldebrid" && utils.IsMediaFile(torrentPath) {
-		// Alldebrid hotfix for single file torrents
-		torrentFolder = utils.RemoveExtension(torrentFolder)
-		torrentRclonePath = rCloneBase // /mnt/rclone/magnets/  // Remove the filename since it's in the root folder
-	}
-	torrentSymlinkPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, torrentFolder) // /mnt/symlinks/{category}/MyTVShow/
-	err = os.MkdirAll(torrentSymlinkPath, os.ModePerm)
-	if err != nil {
-		return "", fmt.Errorf("failed to create directory: %s: %v", torrentSymlinkPath, err)
-	}
-
-	realPaths := make(map[string]string)
-	err = filepath.WalkDir(torrentRclonePath, func(path string, d os.DirEntry, err error) error {
-		if err != nil {
-			return nil
-		}
-		if !d.IsDir() {
-			filename := d.Name()
-			rel, _ := filepath.Rel(torrentRclonePath, path)
-			realPaths[filename] = rel
-		}
-		return nil
-	})
-	if err != nil {
-		q.logger.Warn().Msgf("Error while scanning rclone path: %v", err)
-	}
-
-	pending := make(map[string]debrid.File)
-	for _, file := range files {
-		if realRelPath, ok := realPaths[file.Name]; ok {
-			file.Path = realRelPath
-		}
-		pending[file.Path] = file
-	}
-	ticker := time.NewTicker(200 * time.Millisecond)
-	defer ticker.Stop()
-
-	timeout := time.After(30 * time.Minute)
-	filePaths := make([]string, 0, len(pending))
-
-	for len(pending) > 0 {
-		select {
-		case <-ticker.C:
-			for path, file := range pending {
-				fullFilePath := filepath.Join(torrentRclonePath, file.Path)
-				if _, err := os.Stat(fullFilePath); !os.IsNotExist(err) {
-					fileSymlinkPath := filepath.Join(torrentSymlinkPath, file.Name)
-					if err := os.Symlink(fullFilePath, fileSymlinkPath); err != nil && !os.IsExist(err) {
-						q.logger.Debug().Msgf("Failed to create symlink: %s: %v", fileSymlinkPath, err)
-					} else {
-						filePaths = append(filePaths, fileSymlinkPath)
-						delete(pending, path)
-						q.logger.Info().Msgf("File is ready: %s", file.Name)
-					}
-				}
-			}
-		case <-timeout:
-			q.logger.Warn().Msgf("Timeout waiting for files, %d files still pending", len(pending))
-			return torrentSymlinkPath, fmt.Errorf("timeout waiting for files: %d files still pending", len(pending))
-		}
-	}
-	if q.SkipPreCache {
-		return torrentSymlinkPath, nil
-	}
-
-	go func() {
-
-		if err := q.preCacheFile(debridTorrent.Name, filePaths); err != nil {
-			q.logger.Error().Msgf("Failed to pre-cache file: %s", err)
-		} else {
-			q.logger.Trace().Msgf("Pre-cached %d files", len(filePaths))
-		}
-	}()
-	return torrentSymlinkPath, nil
-}
-
-func (q *QBit) createSymlinksWebdav(debridTorrent *debrid.Torrent, rclonePath, torrentFolder string) (string, error) {
-	files := debridTorrent.Files
-	symlinkPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, torrentFolder) // /mnt/symlinks/{category}/MyTVShow/
-	err := os.MkdirAll(symlinkPath, os.ModePerm)
-	if err != nil {
-		return "", fmt.Errorf("failed to create directory: %s: %v", symlinkPath, err)
-	}
-
-	remainingFiles := make(map[string]debrid.File)
-	for _, file := range files {
-		remainingFiles[file.Name] = file
-	}
-
-	ticker := time.NewTicker(100 * time.Millisecond)
-	defer ticker.Stop()
-	timeout := time.After(30 * time.Minute)
-	filePaths := make([]string, 0, len(files))
-
-	for len(remainingFiles) > 0 {
-		select {
-		case <-ticker.C:
-			entries, err := os.ReadDir(rclonePath)
-			if err != nil {
-				continue
-			}
-
-			// Check which files exist in this batch
-			for _, entry := range entries {
-				filename := entry.Name()
-				if file, exists := remainingFiles[filename]; exists {
-					fullFilePath := filepath.Join(rclonePath, filename)
-					fileSymlinkPath := filepath.Join(symlinkPath, file.Name)
-
-					if err := os.Symlink(fullFilePath, fileSymlinkPath); err != nil && !os.IsExist(err) {
-						q.logger.Debug().Msgf("Failed to create symlink: %s: %v", fileSymlinkPath, err)
-					} else {
-						filePaths = append(filePaths, fileSymlinkPath)
-						delete(remainingFiles, filename)
-						q.logger.Info().Msgf("File is ready: %s", file.Name)
-					}
-				}
-			}
-
-		case <-timeout:
-			q.logger.Warn().Msgf("Timeout waiting for files, %d files still pending", len(remainingFiles))
-			return symlinkPath, fmt.Errorf("timeout waiting for files")
-		}
-	}
-
-	if q.SkipPreCache {
-		return symlinkPath, nil
-	}
-
-	go func() {
-
-		if err := q.preCacheFile(debridTorrent.Name, filePaths); err != nil {
-			q.logger.Error().Msgf("Failed to pre-cache file: %s", err)
-		} else {
-			q.logger.Debug().Msgf("Pre-cached %d files", len(filePaths))
-		}
-	}() // Pre-cache the files in the background
-	// Pre-cache the first 256KB and 1MB of the file
-	return symlinkPath, nil
-}
-
-func (q *QBit) getTorrentPath(rclonePath string, debridTorrent *debrid.Torrent) (string, error) {
-	for {
-		torrentPath, err := debridTorrent.GetMountFolder(rclonePath)
-		if err == nil {
-			q.logger.Debug().Msgf("Found torrent path: %s", torrentPath)
-			return torrentPath, err
-		}
-		time.Sleep(100 * time.Millisecond)
-	}
-}
-
-func (q *QBit) preCacheFile(name string, filePaths []string) error {
-	q.logger.Trace().Msgf("Pre-caching torrent: %s", name)
-	if len(filePaths) == 0 {
-		return fmt.Errorf("no file paths provided")
-	}
-
-	for _, filePath := range filePaths {
-		err := func(f string) error {
-
-			file, err := os.Open(f)
-			if err != nil {
-				if os.IsNotExist(err) {
-					// File has probably been moved by arr, return silently
-					return nil
-				}
-				return fmt.Errorf("failed to open file: %s: %v", f, err)
-			}
-			defer file.Close()
-
-			// Pre-cache the file header (first 256KB) using 16KB chunks.
-			if err := q.readSmallChunks(file, 0, 256*1024, 16*1024); err != nil {
-				return err
-			}
-			if err := q.readSmallChunks(file, 1024*1024, 64*1024, 16*1024); err != nil {
-				return err
-			}
-			return nil
-		}(filePath)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (q *QBit) readSmallChunks(file *os.File, startPos int64, totalToRead int, chunkSize int) error {
-	_, err := file.Seek(startPos, 0)
-	if err != nil {
-		return err
-	}
-
-	buf := make([]byte, chunkSize)
-	bytesRemaining := totalToRead
-
-	for bytesRemaining > 0 {
-		toRead := chunkSize
-		if bytesRemaining < chunkSize {
-			toRead = bytesRemaining
-		}
-
-		n, err := file.Read(buf[:toRead])
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return err
-		}
-
-		bytesRemaining -= n
-	}
-	return nil
-}

pkg/qbit/http.go

@@ -1,107 +1,16 @@
 package qbit
 
 import (
-	"context"
-	"encoding/base64"
-	"github.com/go-chi/chi/v5"
 	"github.com/sirrobot01/decypharr/internal/request"
 	"github.com/sirrobot01/decypharr/pkg/arr"
-	"github.com/sirrobot01/decypharr/pkg/service"
 	"net/http"
 	"path/filepath"
 	"strings"
 )
 
-func decodeAuthHeader(header string) (string, string, error) {
-	encodedTokens := strings.Split(header, " ")
-	if len(encodedTokens) != 2 {
-		return "", "", nil
-	}
-	encodedToken := encodedTokens[1]
-
-	bytes, err := base64.StdEncoding.DecodeString(encodedToken)
-	if err != nil {
-		return "", "", err
-	}
-
-	bearer := string(bytes)
-
-	colonIndex := strings.LastIndex(bearer, ":")
-	host := bearer[:colonIndex]
-	token := bearer[colonIndex+1:]
-
-	return host, token, nil
-}
-
-func (q *QBit) CategoryContext(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		category := strings.Trim(r.URL.Query().Get("category"), "")
-		if category == "" {
-			// Get from form
-			_ = r.ParseForm()
-			category = r.Form.Get("category")
-			if category == "" {
-				// Get from multipart form
-				_ = r.ParseMultipartForm(32 << 20)
-				category = r.FormValue("category")
-			}
-		}
-		ctx := context.WithValue(r.Context(), "category", strings.TrimSpace(category))
-		next.ServeHTTP(w, r.WithContext(ctx))
-	})
-}
-
-func (q *QBit) authContext(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		host, token, err := decodeAuthHeader(r.Header.Get("Authorization"))
-		category := r.Context().Value("category").(string)
-		svc := service.GetService()
-		// Check if arr exists
-		a := svc.Arr.Get(category)
-		if a == nil {
-			downloadUncached := false
-			a = arr.New(category, "", "", false, false, &downloadUncached)
-		}
-		if err == nil {
-			host = strings.TrimSpace(host)
-			if host != "" {
-				a.Host = host
-			}
-			token = strings.TrimSpace(token)
-			if token != "" {
-				a.Token = token
-			}
-		}
-
-		svc.Arr.AddOrUpdate(a)
-		ctx := context.WithValue(r.Context(), "arr", a)
-		next.ServeHTTP(w, r.WithContext(ctx))
-	})
-}
-
-func HashesCtx(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_hashes := chi.URLParam(r, "hashes")
-		var hashes []string
-		if _hashes != "" {
-			hashes = strings.Split(_hashes, "|")
-		}
-		if hashes == nil {
-			// Get hashes from form
-			_ = r.ParseForm()
-			hashes = r.Form["hashes"]
-		}
-		for i, hash := range hashes {
-			hashes[i] = strings.TrimSpace(hash)
-		}
-		ctx := context.WithValue(r.Context(), "hashes", hashes)
-		next.ServeHTTP(w, r.WithContext(ctx))
-	})
-}
-
 func (q *QBit) handleLogin(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	_arr := ctx.Value("arr").(*arr.Arr)
+	_arr := getArr(ctx)
 	if _arr == nil {
 		// No arr
 		_, _ = w.Write([]byte("Ok."))
@@ -122,7 +31,7 @@ func (q *QBit) handleWebAPIVersion(w http.ResponseWriter, r *http.Request) {
 }
 
 func (q *QBit) handlePreferences(w http.ResponseWriter, r *http.Request) {
-	preferences := NewAppPreferences()
+	preferences := getAppPreferences()
 
 	preferences.WebUiUsername = q.Username
 	preferences.SavePath = q.DownloadFolder
@@ -150,10 +59,10 @@ func (q *QBit) handleShutdown(w http.ResponseWriter, r *http.Request) {
 func (q *QBit) handleTorrentsInfo(w http.ResponseWriter, r *http.Request) {
 	//log all url params
 	ctx := r.Context()
-	category := ctx.Value("category").(string)
+	category := getCategory(ctx)
 	filter := strings.Trim(r.URL.Query().Get("filter"), "")
-	hashes, _ := ctx.Value("hashes").([]string)
-	torrents := q.Storage.GetAllSorted(category, filter, hashes, "added_on", false)
+	hashes := getHashes(ctx)
+	torrents := q.storage.GetAllSorted(category, filter, hashes, "added_on", false)
 	request.JSONResponse(w, torrents, http.StatusOK)
 }
 
@@ -180,9 +89,13 @@ func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 	}
 
 	isSymlink := strings.ToLower(r.FormValue("sequentialDownload")) != "true"
+	debridName := r.FormValue("debrid")
 	category := r.FormValue("category")
+	_arr := getArr(ctx)
+	if _arr == nil {
+		_arr = arr.New(category, "", "", false, false, nil)
+	}
 	atleastOne := false
-	ctx = context.WithValue(ctx, "isSymlink", isSymlink)
 
 	// Handle magnet URLs
 	if urls := r.FormValue("urls"); urls != "" {
@@ -191,7 +104,7 @@ func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 			urlList = append(urlList, strings.TrimSpace(u))
 		}
 		for _, url := range urlList {
-			if err := q.AddMagnet(ctx, url, category); err != nil {
+			if err := q.addMagnet(ctx, url, _arr, debridName, isSymlink); err != nil {
 				q.logger.Info().Msgf("Error adding magnet: %v", err)
 				http.Error(w, err.Error(), http.StatusBadRequest)
 				return
@@ -204,7 +117,7 @@ func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 	if r.MultipartForm != nil && r.MultipartForm.File != nil {
 		if files := r.MultipartForm.File["torrents"]; len(files) > 0 {
 			for _, fileHeader := range files {
-				if err := q.AddTorrent(ctx, fileHeader, category); err != nil {
+				if err := q.addTorrent(ctx, fileHeader, _arr, debridName, isSymlink); err != nil {
 					q.logger.Info().Msgf("Error adding torrent: %v", err)
 					http.Error(w, err.Error(), http.StatusBadRequest)
 					return
@@ -224,14 +137,14 @@ func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 
 func (q *QBit) handleTorrentsDelete(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
+	hashes := getHashes(ctx)
 	if len(hashes) == 0 {
 		http.Error(w, "No hashes provided", http.StatusBadRequest)
 		return
 	}
-	category := ctx.Value("category").(string)
+	category := getCategory(ctx)
 	for _, hash := range hashes {
-		q.Storage.Delete(hash, category, false)
+		q.storage.Delete(hash, category, false)
 	}
 
 	w.WriteHeader(http.StatusOK)
@@ -239,10 +152,10 @@ func (q *QBit) handleTorrentsDelete(w http.ResponseWriter, r *http.Request) {
 
 func (q *QBit) handleTorrentsPause(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
-	category := ctx.Value("category").(string)
+	hashes := getHashes(ctx)
+	category := getCategory(ctx)
 	for _, hash := range hashes {
-		torrent := q.Storage.Get(hash, category)
+		torrent := q.storage.Get(hash, category)
 		if torrent == nil {
 			continue
 		}
@@ -254,10 +167,10 @@ func (q *QBit) handleTorrentsPause(w http.ResponseWriter, r *http.Request) {
 
 func (q *QBit) handleTorrentsResume(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
-	category := ctx.Value("category").(string)
+	hashes := getHashes(ctx)
+	category := getCategory(ctx)
 	for _, hash := range hashes {
-		torrent := q.Storage.Get(hash, category)
+		torrent := q.storage.Get(hash, category)
 		if torrent == nil {
 			continue
 		}
@@ -269,10 +182,10 @@ func (q *QBit) handleTorrentsResume(w http.ResponseWriter, r *http.Request) {
 
 func (q *QBit) handleTorrentRecheck(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
-	category := ctx.Value("category").(string)
+	hashes := getHashes(ctx)
+	category := getCategory(ctx)
 	for _, hash := range hashes {
-		torrent := q.Storage.Get(hash, category)
+		torrent := q.storage.Get(hash, category)
 		if torrent == nil {
 			continue
 		}
@@ -315,7 +228,7 @@ func (q *QBit) handleCreateCategory(w http.ResponseWriter, r *http.Request) {
 func (q *QBit) handleTorrentProperties(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	hash := r.URL.Query().Get("hash")
-	torrent := q.Storage.Get(hash, ctx.Value("category").(string))
+	torrent := q.storage.Get(hash, getCategory(ctx))
 
 	properties := q.GetTorrentProperties(torrent)
 	request.JSONResponse(w, properties, http.StatusOK)
@@ -324,22 +237,22 @@ func (q *QBit) handleTorrentProperties(w http.ResponseWriter, r *http.Request) {
 func (q *QBit) handleTorrentFiles(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	hash := r.URL.Query().Get("hash")
-	torrent := q.Storage.Get(hash, ctx.Value("category").(string))
+	torrent := q.storage.Get(hash, getCategory(ctx))
 	if torrent == nil {
 		return
 	}
-	files := q.GetTorrentFiles(torrent)
+	files := q.getTorrentFiles(torrent)
 	request.JSONResponse(w, files, http.StatusOK)
 }
 
 func (q *QBit) handleSetCategory(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	category := ctx.Value("category").(string)
-	hashes, _ := ctx.Value("hashes").([]string)
-	torrents := q.Storage.GetAll("", "", hashes)
+	category := getCategory(ctx)
+	hashes := getHashes(ctx)
+	torrents := q.storage.GetAll("", "", hashes)
 	for _, torrent := range torrents {
 		torrent.Category = category
-		q.Storage.AddOrUpdate(torrent)
+		q.storage.AddOrUpdate(torrent)
 	}
 	request.JSONResponse(w, nil, http.StatusOK)
 }
@@ -351,33 +264,33 @@ func (q *QBit) handleAddTorrentTags(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
+	hashes := getHashes(ctx)
 	tags := strings.Split(r.FormValue("tags"), ",")
 	for i, tag := range tags {
 		tags[i] = strings.TrimSpace(tag)
 	}
-	torrents := q.Storage.GetAll("", "", hashes)
+	torrents := q.storage.GetAll("", "", hashes)
 	for _, t := range torrents {
-		q.SetTorrentTags(t, tags)
+		q.setTorrentTags(t, tags)
 	}
 	request.JSONResponse(w, nil, http.StatusOK)
 }
 
-func (q *QBit) handleRemoveTorrentTags(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleremoveTorrentTags(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err != nil {
 		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
 		return
 	}
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
+	hashes := getHashes(ctx)
 	tags := strings.Split(r.FormValue("tags"), ",")
 	for i, tag := range tags {
 		tags[i] = strings.TrimSpace(tag)
 	}
-	torrents := q.Storage.GetAll("", "", hashes)
+	torrents := q.storage.GetAll("", "", hashes)
 	for _, torrent := range torrents {
-		q.RemoveTorrentTags(torrent, tags)
+		q.removeTorrentTags(torrent, tags)
 
 	}
 	request.JSONResponse(w, nil, http.StatusOK)
@@ -397,6 +310,6 @@ func (q *QBit) handleCreateTags(w http.ResponseWriter, r *http.Request) {
 	for i, tag := range tags {
 		tags[i] = strings.TrimSpace(tag)
 	}
-	q.AddTags(tags)
+	q.addTags(tags)
 	request.JSONResponse(w, nil, http.StatusOK)
 }

pkg/qbit/import.go

@@ -1,80 +0,0 @@
-package qbit
-
-import (
-	"github.com/sirrobot01/decypharr/internal/utils"
-	"github.com/sirrobot01/decypharr/pkg/debrid/debrid"
-	"github.com/sirrobot01/decypharr/pkg/service"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/sirrobot01/decypharr/pkg/arr"
-)
-
-type ImportRequest struct {
-	ID               string        `json:"id"`
-	Path             string        `json:"path"`
-	Magnet           *utils.Magnet `json:"magnet"`
-	Arr              *arr.Arr      `json:"arr"`
-	IsSymlink        bool          `json:"isSymlink"`
-	SeriesId         int           `json:"series"`
-	Seasons          []int         `json:"seasons"`
-	Episodes         []string      `json:"episodes"`
-	DownloadUncached bool          `json:"downloadUncached"`
-
-	Failed      bool      `json:"failed"`
-	FailedAt    time.Time `json:"failedAt"`
-	Reason      string    `json:"reason"`
-	Completed   bool      `json:"completed"`
-	CompletedAt time.Time `json:"completedAt"`
-	Async       bool      `json:"async"`
-}
-
-type ManualImportResponseSchema struct {
-	Priority            string    `json:"priority"`
-	Status              string    `json:"status"`
-	Result              string    `json:"result"`
-	Queued              time.Time `json:"queued"`
-	Trigger             string    `json:"trigger"`
-	SendUpdatesToClient bool      `json:"sendUpdatesToClient"`
-	UpdateScheduledTask bool      `json:"updateScheduledTask"`
-	Id                  int       `json:"id"`
-}
-
-func NewImportRequest(magnet *utils.Magnet, arr *arr.Arr, isSymlink, downloadUncached bool) *ImportRequest {
-	return &ImportRequest{
-		ID:               uuid.NewString(),
-		Magnet:           magnet,
-		Arr:              arr,
-		Failed:           false,
-		Completed:        false,
-		Async:            false,
-		IsSymlink:        isSymlink,
-		DownloadUncached: downloadUncached,
-	}
-}
-
-func (i *ImportRequest) Fail(reason string) {
-	i.Failed = true
-	i.FailedAt = time.Now()
-	i.Reason = reason
-}
-
-func (i *ImportRequest) Complete() {
-	i.Completed = true
-	i.CompletedAt = time.Now()
-}
-
-func (i *ImportRequest) Process(q *QBit) (err error) {
-	// Use this for now.
-	// This sends the torrent to the arr
-	svc := service.GetService()
-	torrent := createTorrentFromMagnet(i.Magnet, i.Arr.Name, "manual")
-	debridTorrent, err := debrid.ProcessTorrent(svc.Debrid, i.Magnet, i.Arr, i.IsSymlink, i.DownloadUncached)
-	if err != nil {
-		return err
-	}
-	torrent = q.UpdateTorrentMin(torrent, debridTorrent)
-	q.Storage.AddOrUpdate(torrent)
-	go q.ProcessFiles(torrent, debridTorrent, i.Arr, i.IsSymlink)
-	return nil
-}

pkg/qbit/misc.go

@@ -1,27 +0,0 @@
-package qbit
-
-import (
-	"github.com/sirrobot01/decypharr/internal/utils"
-	"strings"
-)
-
-func createTorrentFromMagnet(magnet *utils.Magnet, category, source string) *Torrent {
-	torrent := &Torrent{
-		ID:        "",
-		Hash:      strings.ToLower(magnet.InfoHash),
-		Name:      magnet.Name,
-		Size:      magnet.Size,
-		Category:  category,
-		Source:    source,
-		State:     "downloading",
-		MagnetUri: magnet.Link,
-
-		Tracker:    "udp://tracker.opentrackr.org:1337",
-		UpLimit:    -1,
-		DlLimit:    -1,
-		AutoTmm:    false,
-		Ratio:      1,
-		RatioLimit: 1,
-	}
-	return torrent
-}

pkg/qbit/qbit.go

@@ -1,52 +1,38 @@
 package qbit
 
 import (
-	"cmp"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/internal/logger"
-	"os"
-	"path/filepath"
+	"github.com/sirrobot01/decypharr/pkg/store"
 )
 
 type QBit struct {
-	Username        string   `json:"username"`
-	Password        string   `json:"password"`
-	Port            string   `json:"port"`
-	DownloadFolder  string   `json:"download_folder"`
-	Categories      []string `json:"categories"`
-	Storage         *TorrentStorage
-	logger          zerolog.Logger
-	Tags            []string
-	RefreshInterval int
-	SkipPreCache    bool
-
-	downloadSemaphore chan struct{}
+	Username       string
+	Password       string
+	DownloadFolder string
+	Categories     []string
+	storage        *store.TorrentStorage
+	logger         zerolog.Logger
+	Tags           []string
 }
 
 func New() *QBit {
 	_cfg := config.Get()
 	cfg := _cfg.QBitTorrent
-	port := cmp.Or(_cfg.Port, os.Getenv("QBIT_PORT"), "8282")
-	refreshInterval := cmp.Or(cfg.RefreshInterval, 10)
 	return &QBit{
-		Username:          cfg.Username,
-		Password:          cfg.Password,
-		Port:              port,
-		DownloadFolder:    cfg.DownloadFolder,
-		Categories:        cfg.Categories,
-		Storage:           NewTorrentStorage(filepath.Join(_cfg.Path, "torrents.json")),
-		logger:            logger.New("qbit"),
-		RefreshInterval:   refreshInterval,
-		SkipPreCache:      cfg.SkipPreCache,
-		downloadSemaphore: make(chan struct{}, cmp.Or(cfg.MaxDownloads, 5)),
+		Username:       cfg.Username,
+		Password:       cfg.Password,
+		DownloadFolder: cfg.DownloadFolder,
+		Categories:     cfg.Categories,
+		storage:        store.GetStore().GetTorrentStorage(),
+		logger:         logger.New("qbit"),
 	}
 }
 
 func (q *QBit) Reset() {
-	if q.Storage != nil {
-		q.Storage.Reset()
+	if q.storage != nil {
+		q.storage.Reset()
 	}
 	q.Tags = nil
-	close(q.downloadSemaphore)
 }

pkg/qbit/routes.go

@@ -7,12 +7,12 @@ import (
 
 func (q *QBit) Routes() http.Handler {
 	r := chi.NewRouter()
-	r.Use(q.CategoryContext)
+	r.Use(q.categoryContext)
 	r.Group(func(r chi.Router) {
 		r.Use(q.authContext)
 		r.Post("/auth/login", q.handleLogin)
 		r.Route("/torrents", func(r chi.Router) {
-			r.Use(HashesCtx)
+			r.Use(hashesContext)
 			r.Get("/info", q.handleTorrentsInfo)
 			r.Post("/add", q.handleTorrentsAdd)
 			r.Post("/delete", q.handleTorrentsDelete)
@@ -20,7 +20,7 @@ func (q *QBit) Routes() http.Handler {
 			r.Post("/createCategory", q.handleCreateCategory)
 			r.Post("/setCategory", q.handleSetCategory)
 			r.Post("/addTags", q.handleAddTorrentTags)
-			r.Post("/removeTags", q.handleRemoveTorrentTags)
+			r.Post("/removeTags", q.handleremoveTorrentTags)
 			r.Post("/createTags", q.handleCreateTags)
 			r.Get("/tags", q.handleGetTags)
 			r.Get("/pause", q.handleTorrentsPause)

pkg/qbit/storage.go

@@ -1,280 +0,0 @@
-package qbit
-
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/sirrobot01/decypharr/pkg/service"
-	"os"
-	"sort"
-	"sync"
-)
-
-func keyPair(hash, category string) string {
-	if category == "" {
-		category = "uncategorized"
-	}
-	return fmt.Sprintf("%s|%s", hash, category)
-}
-
-type Torrents = map[string]*Torrent
-
-type TorrentStorage struct {
-	torrents Torrents
-	mu       sync.RWMutex
-	filename string // Added to store the filename for persistence
-}
-
-func loadTorrentsFromJSON(filename string) (Torrents, error) {
-	data, err := os.ReadFile(filename)
-	if err != nil {
-		return nil, err
-	}
-	torrents := make(Torrents)
-	if err := json.Unmarshal(data, &torrents); err != nil {
-		return nil, err
-	}
-	return torrents, nil
-}
-
-func NewTorrentStorage(filename string) *TorrentStorage {
-	// Open the JSON file and read the data
-	torrents, err := loadTorrentsFromJSON(filename)
-	if err != nil {
-		torrents = make(Torrents)
-	}
-	// Create a new TorrentStorage
-	return &TorrentStorage{
-		torrents: torrents,
-		filename: filename,
-	}
-}
-
-func (ts *TorrentStorage) Add(torrent *Torrent) {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	ts.torrents[keyPair(torrent.Hash, torrent.Category)] = torrent
-	go func() {
-		err := ts.saveToFile()
-		if err != nil {
-			fmt.Println(err)
-		}
-	}()
-}
-
-func (ts *TorrentStorage) AddOrUpdate(torrent *Torrent) {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	ts.torrents[keyPair(torrent.Hash, torrent.Category)] = torrent
-	go func() {
-		err := ts.saveToFile()
-		if err != nil {
-			fmt.Println(err)
-		}
-	}()
-}
-
-func (ts *TorrentStorage) Get(hash, category string) *Torrent {
-	ts.mu.RLock()
-	defer ts.mu.RUnlock()
-	torrent, exists := ts.torrents[keyPair(hash, category)]
-	if !exists && category == "" {
-		// Try to find the torrent without knowing the category
-		for _, t := range ts.torrents {
-			if t.Hash == hash {
-				return t
-			}
-		}
-	}
-	return torrent
-}
-
-func (ts *TorrentStorage) GetAll(category string, filter string, hashes []string) []*Torrent {
-	ts.mu.RLock()
-	defer ts.mu.RUnlock()
-	torrents := make([]*Torrent, 0)
-	for _, torrent := range ts.torrents {
-		if category != "" && torrent.Category != category {
-			continue
-		}
-		if filter != "" && torrent.State != filter {
-			continue
-		}
-		torrents = append(torrents, torrent)
-	}
-
-	if len(hashes) > 0 {
-		filtered := make([]*Torrent, 0)
-		for _, hash := range hashes {
-			for _, torrent := range torrents {
-				if torrent.Hash == hash {
-					filtered = append(filtered, torrent)
-				}
-			}
-		}
-		torrents = filtered
-	}
-	return torrents
-}
-
-func (ts *TorrentStorage) GetAllSorted(category string, filter string, hashes []string, sortBy string, ascending bool) []*Torrent {
-	torrents := ts.GetAll(category, filter, hashes)
-	if sortBy != "" {
-		sort.Slice(torrents, func(i, j int) bool {
-			// If ascending is false, swap i and j to get descending order
-			if !ascending {
-				i, j = j, i
-			}
-
-			switch sortBy {
-			case "name":
-				return torrents[i].Name < torrents[j].Name
-			case "size":
-				return torrents[i].Size < torrents[j].Size
-			case "added_on":
-				return torrents[i].AddedOn < torrents[j].AddedOn
-			case "completed":
-				return torrents[i].Completed < torrents[j].Completed
-			case "progress":
-				return torrents[i].Progress < torrents[j].Progress
-			case "state":
-				return torrents[i].State < torrents[j].State
-			case "category":
-				return torrents[i].Category < torrents[j].Category
-			case "dlspeed":
-				return torrents[i].Dlspeed < torrents[j].Dlspeed
-			case "upspeed":
-				return torrents[i].Upspeed < torrents[j].Upspeed
-			case "ratio":
-				return torrents[i].Ratio < torrents[j].Ratio
-			default:
-				// Default sort by added_on
-				return torrents[i].AddedOn < torrents[j].AddedOn
-			}
-		})
-	}
-	return torrents
-}
-
-func (ts *TorrentStorage) Update(torrent *Torrent) {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	ts.torrents[keyPair(torrent.Hash, torrent.Category)] = torrent
-	go func() {
-		err := ts.saveToFile()
-		if err != nil {
-			fmt.Println(err)
-		}
-	}()
-}
-
-func (ts *TorrentStorage) Delete(hash, category string, removeFromDebrid bool) {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	key := keyPair(hash, category)
-	torrent, exists := ts.torrents[key]
-	if !exists && category == "" {
-		// Remove the torrent without knowing the category
-		for k, t := range ts.torrents {
-			if t.Hash == hash {
-				key = k
-				torrent = t
-				break
-			}
-		}
-	}
-
-	if torrent == nil {
-		return
-	}
-	if removeFromDebrid && torrent.ID != "" && torrent.Debrid != "" {
-		dbClient := service.GetDebrid().GetClient(torrent.Debrid)
-		if dbClient != nil {
-			err := dbClient.DeleteTorrent(torrent.ID)
-			if err != nil {
-				fmt.Println(err)
-			}
-		}
-	}
-
-	delete(ts.torrents, key)
-
-	// Delete the torrent folder
-	if torrent.ContentPath != "" {
-		err := os.RemoveAll(torrent.ContentPath)
-		if err != nil {
-			return
-		}
-	}
-	go func() {
-		err := ts.saveToFile()
-		if err != nil {
-			fmt.Println(err)
-		}
-	}()
-}
-
-func (ts *TorrentStorage) DeleteMultiple(hashes []string, removeFromDebrid bool) {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	toDelete := make(map[string]string)
-
-	for _, hash := range hashes {
-		for key, torrent := range ts.torrents {
-			if torrent == nil {
-				continue
-			}
-			if torrent.Hash == hash {
-				if removeFromDebrid && torrent.ID != "" && torrent.Debrid != "" {
-					toDelete[torrent.ID] = torrent.Debrid
-				}
-				delete(ts.torrents, key)
-				if torrent.ContentPath != "" {
-					err := os.RemoveAll(torrent.ContentPath)
-					if err != nil {
-						return
-					}
-				}
-			}
-		}
-	}
-	go func() {
-		err := ts.saveToFile()
-		if err != nil {
-			fmt.Println(err)
-		}
-	}()
-
-	go func() {
-		for id, debrid := range toDelete {
-			dbClient := service.GetDebrid().GetClient(debrid)
-			if dbClient == nil {
-				continue
-			}
-			err := dbClient.DeleteTorrent(id)
-			if err != nil {
-				fmt.Println(err)
-			}
-		}
-	}()
-}
-
-func (ts *TorrentStorage) Save() error {
-	return ts.saveToFile()
-}
-
-// saveToFile is a helper function to write the current state to the JSON file
-func (ts *TorrentStorage) saveToFile() error {
-	ts.mu.RLock()
-	data, err := json.MarshalIndent(ts.torrents, "", "  ")
-	ts.mu.RUnlock()
-	if err != nil {
-		return err
-	}
-	return os.WriteFile(ts.filename, data, 0644)
-}
-
-func (ts *TorrentStorage) Reset() {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	ts.torrents = make(Torrents)
-}

pkg/qbit/torrent.go

@@ -1,38 +1,35 @@
 package qbit
 
 import (
-	"cmp"
 	"context"
 	"fmt"
-	"github.com/sirrobot01/decypharr/internal/request"
 	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/arr"
-	"github.com/sirrobot01/decypharr/pkg/debrid/debrid"
-	debridTypes "github.com/sirrobot01/decypharr/pkg/debrid/types"
-	"github.com/sirrobot01/decypharr/pkg/service"
+	"github.com/sirrobot01/decypharr/pkg/store"
 	"io"
 	"mime/multipart"
-	"os"
-	"path/filepath"
 	"strings"
 	"time"
 )
 
-// All torrent related helpers goes here
-
-func (q *QBit) AddMagnet(ctx context.Context, url, category string) error {
+// All torrent-related helpers goes here
+func (q *QBit) addMagnet(ctx context.Context, url string, arr *arr.Arr, debrid string, isSymlink bool) error {
 	magnet, err := utils.GetMagnetFromUrl(url)
 	if err != nil {
 		return fmt.Errorf("error parsing magnet link: %w", err)
 	}
-	err = q.Process(ctx, magnet, category)
+	_store := store.GetStore()
+
+	importReq := store.NewImportRequest(debrid, q.DownloadFolder, magnet, arr, isSymlink, false, "", store.ImportTypeQBitTorrent)
+
+	err = _store.AddTorrent(ctx, importReq)
 	if err != nil {
 		return fmt.Errorf("failed to process torrent: %w", err)
 	}
 	return nil
 }
 
-func (q *QBit) AddTorrent(ctx context.Context, fileHeader *multipart.FileHeader, category string) error {
+func (q *QBit) addTorrent(ctx context.Context, fileHeader *multipart.FileHeader, arr *arr.Arr, debrid string, isSymlink bool) error {
 	file, _ := fileHeader.Open()
 	defer file.Close()
 	var reader io.Reader = file
@@ -40,226 +37,28 @@ func (q *QBit) AddTorrent(ctx context.Context, fileHeader *multipart.FileHeader,
 	if err != nil {
 		return fmt.Errorf("error reading file: %s \n %w", fileHeader.Filename, err)
 	}
-	err = q.Process(ctx, magnet, category)
+	_store := store.GetStore()
+	importReq := store.NewImportRequest(debrid, q.DownloadFolder, magnet, arr, isSymlink, false, "", store.ImportTypeQBitTorrent)
+	err = _store.AddTorrent(ctx, importReq)
 	if err != nil {
 		return fmt.Errorf("failed to process torrent: %w", err)
 	}
 	return nil
 }
 
-func (q *QBit) Process(ctx context.Context, magnet *utils.Magnet, category string) error {
-	svc := service.GetService()
-	torrent := createTorrentFromMagnet(magnet, category, "auto")
-	a, ok := ctx.Value("arr").(*arr.Arr)
-	if !ok {
-		return fmt.Errorf("arr not found in context")
-	}
-	isSymlink := ctx.Value("isSymlink").(bool)
-	debridTorrent, err := debrid.ProcessTorrent(svc.Debrid, magnet, a, isSymlink, false)
-	if err != nil || debridTorrent == nil {
-		if err == nil {
-			err = fmt.Errorf("failed to process torrent")
-		}
-		return err
-	}
-	torrent = q.UpdateTorrentMin(torrent, debridTorrent)
-	q.Storage.AddOrUpdate(torrent)
-	go q.ProcessFiles(torrent, debridTorrent, a, isSymlink) // We can send async for file processing not to delay the response
-	return nil
-}
-
-func (q *QBit) ProcessFiles(torrent *Torrent, debridTorrent *debridTypes.Torrent, arr *arr.Arr, isSymlink bool) {
-	svc := service.GetService()
-	client := svc.Debrid.GetClient(debridTorrent.Debrid)
-	downloadingStatuses := client.GetDownloadingStatus()
-	for debridTorrent.Status != "downloaded" {
-		q.logger.Debug().Msgf("%s <- (%s) Download Progress: %.2f%%", debridTorrent.Debrid, debridTorrent.Name, debridTorrent.Progress)
-		dbT, err := client.CheckStatus(debridTorrent, isSymlink)
-		if err != nil {
-			if dbT != nil && dbT.Id != "" {
-				// Delete the torrent if it was not downloaded
-				go func() {
-					_ = client.DeleteTorrent(dbT.Id)
-				}()
-			}
-			q.logger.Error().Msgf("Error checking status: %v", err)
-			q.MarkAsFailed(torrent)
-			go func() {
-				if err := arr.Refresh(); err != nil {
-					q.logger.Error().Msgf("Error refreshing arr: %v", err)
-				}
-			}()
-			return
-		}
-
-		debridTorrent = dbT
-		torrent = q.UpdateTorrentMin(torrent, debridTorrent)
-
-		// Exit the loop for downloading statuses to prevent memory buildup
-		if debridTorrent.Status == "downloaded" || !utils.Contains(downloadingStatuses, debridTorrent.Status) {
-			break
-		}
-		if !utils.Contains(client.GetDownloadingStatus(), debridTorrent.Status) {
-			break
-		}
-		time.Sleep(time.Duration(q.RefreshInterval) * time.Second)
-	}
-	var torrentSymlinkPath string
-	var err error
-	debridTorrent.Arr = arr
-
-	// Check if debrid supports webdav by checking cache
-	timer := time.Now()
-	if isSymlink {
-		cache, useWebdav := svc.Debrid.Caches[debridTorrent.Debrid]
-		if useWebdav {
-			q.logger.Info().Msgf("Using internal webdav for %s", debridTorrent.Debrid)
-
-			// Use webdav to download the file
-
-			if err := cache.AddTorrent(debridTorrent); err != nil {
-				q.logger.Error().Msgf("Error adding torrent to cache: %v", err)
-				q.MarkAsFailed(torrent)
-				return
-			}
-
-			rclonePath := filepath.Join(debridTorrent.MountPath, cache.GetTorrentFolder(debridTorrent)) // /mnt/remote/realdebrid/MyTVShow
-			torrentFolderNoExt := utils.RemoveExtension(debridTorrent.Name)
-			torrentSymlinkPath, err = q.createSymlinksWebdav(debridTorrent, rclonePath, torrentFolderNoExt) // /mnt/symlinks/{category}/MyTVShow/
-
-		} else {
-			// User is using either zurg or debrid webdav
-			torrentSymlinkPath, err = q.ProcessSymlink(torrent) // /mnt/symlinks/{category}/MyTVShow/
-		}
-	} else {
-		torrentSymlinkPath, err = q.ProcessManualFile(torrent)
-	}
-	if err != nil {
-		q.MarkAsFailed(torrent)
-		go func() {
-			_ = client.DeleteTorrent(debridTorrent.Id)
-		}()
-		q.logger.Info().Msgf("Error: %v", err)
-		return
-	}
-	torrent.TorrentPath = torrentSymlinkPath
-	q.UpdateTorrent(torrent, debridTorrent)
-	q.logger.Info().Msgf("Adding %s took %s", debridTorrent.Name, time.Since(timer))
-	go func() {
-		if err := request.SendDiscordMessage("download_complete", "success", torrent.discordContext()); err != nil {
-			q.logger.Error().Msgf("Error sending discord message: %v", err)
-		}
-	}()
-	if err := arr.Refresh(); err != nil {
-		q.logger.Error().Msgf("Error refreshing arr: %v", err)
-	}
-}
-
-func (q *QBit) MarkAsFailed(t *Torrent) *Torrent {
-	t.State = "error"
-	q.Storage.AddOrUpdate(t)
-	go func() {
-		if err := request.SendDiscordMessage("download_failed", "error", t.discordContext()); err != nil {
-			q.logger.Error().Msgf("Error sending discord message: %v", err)
-		}
-	}()
-	return t
-}
-
-func (q *QBit) UpdateTorrentMin(t *Torrent, debridTorrent *debridTypes.Torrent) *Torrent {
-	if debridTorrent == nil {
-		return t
-	}
-
-	addedOn, err := time.Parse(time.RFC3339, debridTorrent.Added)
-	if err != nil {
-		addedOn = time.Now()
-	}
-	totalSize := debridTorrent.Bytes
-	progress := (cmp.Or(debridTorrent.Progress, 0.0)) / 100.0
-	sizeCompleted := int64(float64(totalSize) * progress)
-
-	var speed int64
-	if debridTorrent.Speed != 0 {
-		speed = debridTorrent.Speed
-	}
-	var eta int
-	if speed != 0 {
-		eta = int((totalSize - sizeCompleted) / speed)
-	}
-	t.ID = debridTorrent.Id
-	t.Name = debridTorrent.Name
-	t.AddedOn = addedOn.Unix()
-	t.DebridTorrent = debridTorrent
-	t.Debrid = debridTorrent.Debrid
-	t.Size = totalSize
-	t.Completed = sizeCompleted
-	t.Downloaded = sizeCompleted
-	t.DownloadedSession = sizeCompleted
-	t.Uploaded = sizeCompleted
-	t.UploadedSession = sizeCompleted
-	t.AmountLeft = totalSize - sizeCompleted
-	t.Progress = progress
-	t.Eta = eta
-	t.Dlspeed = speed
-	t.Upspeed = speed
-	t.SavePath = filepath.Join(q.DownloadFolder, t.Category) + string(os.PathSeparator)
-	t.ContentPath = filepath.Join(t.SavePath, t.Name) + string(os.PathSeparator)
-	return t
-}
-
-func (q *QBit) UpdateTorrent(t *Torrent, debridTorrent *debridTypes.Torrent) *Torrent {
-	if debridTorrent == nil {
-		return t
-	}
-
-	if debridClient := service.GetDebrid().GetClient(debridTorrent.Debrid); debridClient != nil {
-		if debridTorrent.Status != "downloaded" {
-			_ = debridClient.UpdateTorrent(debridTorrent)
-		}
-	}
-	t = q.UpdateTorrentMin(t, debridTorrent)
-	t.ContentPath = t.TorrentPath + string(os.PathSeparator)
-
-	if t.IsReady() {
-		t.State = "pausedUP"
-		q.Storage.Update(t)
-		return t
-	}
-
-	ticker := time.NewTicker(100 * time.Millisecond)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			if t.IsReady() {
-				t.State = "pausedUP"
-				q.Storage.Update(t)
-				return t
-			}
-			updatedT := q.UpdateTorrent(t, debridTorrent)
-			t = updatedT
-
-		case <-time.After(10 * time.Minute): // Add a timeout
-			return t
-		}
-	}
-}
-
-func (q *QBit) ResumeTorrent(t *Torrent) bool {
+func (q *QBit) ResumeTorrent(t *store.Torrent) bool {
 	return true
 }
 
-func (q *QBit) PauseTorrent(t *Torrent) bool {
+func (q *QBit) PauseTorrent(t *store.Torrent) bool {
 	return true
 }
 
-func (q *QBit) RefreshTorrent(t *Torrent) bool {
+func (q *QBit) RefreshTorrent(t *store.Torrent) bool {
 	return true
 }
 
-func (q *QBit) GetTorrentProperties(t *Torrent) *TorrentProperties {
+func (q *QBit) GetTorrentProperties(t *store.Torrent) *TorrentProperties {
 	return &TorrentProperties{
 		AdditionDate:           t.AddedOn,
 		Comment:                "Debrid Blackhole <https://github.com/sirrobot01/decypharr>",
@@ -284,7 +83,7 @@ func (q *QBit) GetTorrentProperties(t *Torrent) *TorrentProperties {
 	}
 }
 
-func (q *QBit) GetTorrentFiles(t *Torrent) []*TorrentFile {
+func (q *QBit) getTorrentFiles(t *store.Torrent) []*TorrentFile {
 	files := make([]*TorrentFile, 0)
 	if t.DebridTorrent == nil {
 		return files
@@ -298,7 +97,7 @@ func (q *QBit) GetTorrentFiles(t *Torrent) []*TorrentFile {
 	return files
 }
 
-func (q *QBit) SetTorrentTags(t *Torrent, tags []string) bool {
+func (q *QBit) setTorrentTags(t *store.Torrent, tags []string) bool {
 	torrentTags := strings.Split(t.Tags, ",")
 	for _, tag := range tags {
 		if tag == "" {
@@ -312,20 +111,20 @@ func (q *QBit) SetTorrentTags(t *Torrent, tags []string) bool {
 		}
 	}
 	t.Tags = strings.Join(torrentTags, ",")
-	q.Storage.Update(t)
+	q.storage.Update(t)
 	return true
 }
 
-func (q *QBit) RemoveTorrentTags(t *Torrent, tags []string) bool {
+func (q *QBit) removeTorrentTags(t *store.Torrent, tags []string) bool {
 	torrentTags := strings.Split(t.Tags, ",")
 	newTorrentTags := utils.RemoveItem(torrentTags, tags...)
 	q.Tags = utils.RemoveItem(q.Tags, tags...)
 	t.Tags = strings.Join(newTorrentTags, ",")
-	q.Storage.Update(t)
+	q.storage.Update(t)
 	return true
 }
 
-func (q *QBit) AddTags(tags []string) bool {
+func (q *QBit) addTags(tags []string) bool {
 	for _, tag := range tags {
 		if tag == "" {
 			continue
@@ -337,7 +136,7 @@ func (q *QBit) AddTags(tags []string) bool {
 	return true
 }
 
-func (q *QBit) RemoveTags(tags []string) bool {
+func (q *QBit) removeTags(tags []string) bool {
 	q.Tags = utils.RemoveItem(q.Tags, tags...)
 	return true
 }

pkg/qbit/types.go

@@ -1,11 +1,5 @@
 package qbit
 
-import (
-	"fmt"
-	"github.com/sirrobot01/decypharr/pkg/debrid/types"
-	"sync"
-)
-
 type BuildInfo struct {
 	Libtorrent string `json:"libtorrent"`
 	Bitness    int    `json:"bitness"`
@@ -172,76 +166,6 @@ type TorrentCategory struct {
 	SavePath string `json:"savePath"`
 }
 
-type Torrent struct {
-	ID            string         `json:"id"`
-	DebridTorrent *types.Torrent `json:"-"`
-	Debrid        string         `json:"debrid"`
-	TorrentPath   string         `json:"-"`
-
-	AddedOn           int64   `json:"added_on,omitempty"`
-	AmountLeft        int64   `json:"amount_left"`
-	AutoTmm           bool    `json:"auto_tmm"`
-	Availability      float64 `json:"availability,omitempty"`
-	Category          string  `json:"category,omitempty"`
-	Completed         int64   `json:"completed"`
-	CompletionOn      int     `json:"completion_on,omitempty"`
-	ContentPath       string  `json:"content_path"`
-	DlLimit           int     `json:"dl_limit"`
-	Dlspeed           int64   `json:"dlspeed"`
-	Downloaded        int64   `json:"downloaded"`
-	DownloadedSession int64   `json:"downloaded_session"`
-	Eta               int     `json:"eta"`
-	FlPiecePrio       bool    `json:"f_l_piece_prio,omitempty"`
-	ForceStart        bool    `json:"force_start,omitempty"`
-	Hash              string  `json:"hash"`
-	LastActivity      int64   `json:"last_activity,omitempty"`
-	MagnetUri         string  `json:"magnet_uri,omitempty"`
-	MaxRatio          int     `json:"max_ratio,omitempty"`
-	MaxSeedingTime    int     `json:"max_seeding_time,omitempty"`
-	Name              string  `json:"name,omitempty"`
-	NumComplete       int     `json:"num_complete,omitempty"`
-	NumIncomplete     int     `json:"num_incomplete,omitempty"`
-	NumLeechs         int     `json:"num_leechs,omitempty"`
-	NumSeeds          int     `json:"num_seeds,omitempty"`
-	Priority          int     `json:"priority,omitempty"`
-	Progress          float64 `json:"progress"`
-	Ratio             int     `json:"ratio,omitempty"`
-	RatioLimit        int     `json:"ratio_limit,omitempty"`
-	SavePath          string  `json:"save_path"`
-	SeedingTimeLimit  int     `json:"seeding_time_limit,omitempty"`
-	SeenComplete      int64   `json:"seen_complete,omitempty"`
-	SeqDl             bool    `json:"seq_dl"`
-	Size              int64   `json:"size,omitempty"`
-	State             string  `json:"state,omitempty"`
-	SuperSeeding      bool    `json:"super_seeding"`
-	Tags              string  `json:"tags,omitempty"`
-	TimeActive        int     `json:"time_active,omitempty"`
-	TotalSize         int64   `json:"total_size,omitempty"`
-	Tracker           string  `json:"tracker,omitempty"`
-	UpLimit           int64   `json:"up_limit,omitempty"`
-	Uploaded          int64   `json:"uploaded,omitempty"`
-	UploadedSession   int64   `json:"uploaded_session,omitempty"`
-	Upspeed           int64   `json:"upspeed,omitempty"`
-	Source            string  `json:"source,omitempty"`
-
-	Mu sync.Mutex `json:"-"`
-}
-
-func (t *Torrent) IsReady() bool {
-	return (t.AmountLeft <= 0 || t.Progress == 1) && t.TorrentPath != ""
-}
-
-func (t *Torrent) discordContext() string {
-	format := `
-		**Name:** %s
-		**Arr:** %s
-		**Hash:** %s
-		**MagnetURI:** %s
-		**Debrid:** %s
-	`
-	return fmt.Sprintf(format, t.Name, t.Category, t.Hash, t.MagnetUri, t.Debrid)
-}
-
 type TorrentProperties struct {
 	AdditionDate           int64  `json:"addition_date,omitempty"`
 	Comment                string `json:"comment,omitempty"`
@@ -289,7 +213,7 @@ type TorrentFile struct {
 	Availability float64 `json:"availability,omitempty"`
 }
 
-func NewAppPreferences() *AppPreferences {
+func getAppPreferences() *AppPreferences {
 	preferences := &AppPreferences{
 		AddTrackers:                        "",
 		AddTrackersEnabled:                 false,