polaris/pkg/qbittorrent/qbittorrent.go

package qbittorrent

import (
	"fmt"
	"os"
	"polaris/pkg"
	"polaris/pkg/go-qbittorrent/qbt"
	"polaris/pkg/utils"
	"strings"

	"github.com/pkg/errors"
)

const btCategory = "polaris"

type Info struct {
	URL      string
	User     string
	Password string
}

type Client struct {
	c        *qbt.Client
	category string
	Info
}

func NewClient(url, user, pass string) (*Client, error) {
	// connect to qbittorrent client
	qb := qbt.NewClient(url)

	// login to the client
	loginOpts := qbt.LoginOptions{
		Username: user,
		Password: pass,
	}
	err := qb.Login(loginOpts)
	if err != nil {
		return nil, err
	}

	return &Client{c: qb, category: btCategory, Info: Info{URL: url, User: user, Password: pass}}, nil
}

func (c *Client) GetAll() ([]pkg.Torrent, error) {
	tt, err := c.c.Torrents(qbt.TorrentsOptions{Category: &c.category})
	if err != nil {
		return nil, errors.Wrap(err, "get torrents")
	}
	var res []pkg.Torrent
	for _, t := range tt {
		t1 := &Torrent{
			c:    c.c,
			hash: t.Hash,
			//Info: c.Info,
		}
		res = append(res, t1)
	}
	return res, nil
}

func (c *Client) Download(link, dir string) (pkg.Torrent, error) {
	err := c.c.DownloadLinks([]string{link}, qbt.DownloadOptions{Savepath: &dir, Category: &c.category})
	if err != nil {
		return nil, errors.Wrap(err, "qbt download")
	}
	magnet, err := utils.Link2Magnet(link)
	if err != nil {
		return nil, errors.Errorf("converting link to magnet error, link: %v, error: %v", link, err)
	}

	hash, err := utils.MagnetHash(magnet)
	if err != nil {
		return nil, errors.Wrap(err, "get hash")
	}

	return &Torrent{hash: hash, c: c.c}, nil

}

func NewTorrent(info Info, link string) (*Torrent, error) {
	c, err := NewClient(info.URL, info.User, info.Password)
	if err != nil {
		return nil, err
	}
	magnet, err := utils.Link2Magnet(link)
	if err != nil {
		return nil, errors.Errorf("converting link to magnet error, link: %v, error: %v", link, err)
	}

	hash, err := utils.MagnetHash(magnet)
	if err != nil {
		return nil, err
	}
	t := &Torrent{
		c:    c.c,
		hash: hash,
	}
	if !t.Exists() {
		return nil, errors.Errorf("torrent not exist: %v", magnet)
	}
	return t, nil
}

type Torrent struct {
	c    *qbt.Client
	hash string
	//info Info
}

func (t *Torrent) GetHash() string {
	return t.hash
}

func (t *Torrent) getTorrent() (*qbt.TorrentInfo, error) {
	all, err := t.c.Torrents(qbt.TorrentsOptions{Hashes: []string{t.hash}})
	if err != nil {
		return nil, err
	}
	if len(all) == 0 {
		return nil, fmt.Errorf("no such torrent: %v", t.hash)
	}
	return &all[0], nil
}

func (t *Torrent) Name() (string, error) {
	dir, err := t.getTorrentBaseNameOrDir()
	if err != nil { //use torrent name
		qb, err := t.getTorrent()
		if err != nil {
			return "", err
		}
		return qb.Name, nil
	}
	return dir, nil
}

// https://github.com/qbittorrent/qBittorrent/issues/13572
func (t *Torrent) getTorrentBaseNameOrDir() (string, error) {
	files, err := t.c.TorrentFiles(t.hash)
	if err != nil {
		return "", err
	}
	if len(files) == 0 {
		return "", errors.Wrap(err, "no file")
	}
	name := files[0].Name
	dir := strings.Split(name, string(os.PathSeparator))[0]
	return dir, nil
}

func (t *Torrent) Progress() (int, error) {
	qb, err := t.getTorrent()
	if err != nil {
		return 0, err
	}
	p := qb.Progress * 100
	if p >= 100 {
		return 100, nil
	}
	if int(p) == 100 {
		return 99, nil
	}

	return int(p), nil
}

func (t *Torrent) Stop() error {
	return t.c.Pause([]string{t.hash})
}

func (t *Torrent) Start() error {
	ok, err := t.c.Resume([]string{t.hash})
	if err != nil {
		return err
	}
	if !ok {
		return fmt.Errorf("status not 200")
	}
	return nil
}

func (t *Torrent) Remove() error {
	ok, err := t.c.Delete([]string{t.hash}, true)
	if err != nil {
		return err
	}
	if !ok {
		return fmt.Errorf("status not 200")
	}
	return nil
}

func (t *Torrent) Exists() bool {
	_, err := t.getTorrent()
	return err == nil
}

func (t *Torrent) SeedRatio() (float64, error) {
	qb, err := t.getTorrent()
	if err != nil {
		return 0, err
	}
	return qb.Ratio, nil
}