3 |
3 | 
191 |
192 | ## License
193 |
194 | GPLv3
195 |
196 | ---
197 |
198 | > GitHub [@ad-on-is](https://github.com/ad-on-is) ·
199 | > Built using [pocketbase](https://pocketbase.io/) and [Nuxt](https://nuxt.com/)
200 |
--------------------------------------------------------------------------------
/apps/backend/Dockerfile:
--------------------------------------------------------------------------------
1 | From golang:alpine as builder
2 | WORKDIR /build/
3 | COPY go.mod .
4 | COPY go.sum .
5 | RUN CGO_ENABLED=0 GOOS=linux go mod download
6 | COPY . .
7 | RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix -o odin-backend
8 |
9 |
10 | FROM alpine
11 | RUN apk --update add ca-certificates curl mailcap
12 | WORKDIR /
13 | COPY --from=builder /build/odin-backend /odin-backend
14 |
15 |
16 | CMD ["/odin-backend", "serve", "--http=0.0.0.0:8090"]
17 |
--------------------------------------------------------------------------------
/apps/backend/cache/cache.go:
--------------------------------------------------------------------------------
1 | package cache
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "fmt"
7 | "os"
8 | "time"
9 |
10 | "github.com/charmbracelet/log"
11 | "github.com/odin-movieshow/backend/types"
12 | "github.com/pocketbase/dbx"
13 | "github.com/pocketbase/pocketbase"
14 | "github.com/pocketbase/pocketbase/models"
15 | "github.com/redis/go-redis/v9"
16 | )
17 |
18 | type Cache struct {
19 | redis *redis.Client
20 | app *pocketbase.PocketBase
21 | }
22 |
23 | func New(app *pocketbase.PocketBase) *Cache {
24 | opts, err := redis.ParseURL(os.Getenv("REDIS_URL"))
25 | if err != nil {
26 | log.Error(err)
27 | }
28 | rdb := redis.NewClient(opts)
29 | err = rdb.Set(context.Background(), "test", "test", 0).Err()
30 | if err != nil {
31 | log.Error("REDIS", "Cannot connect to", opts.Addr, opts)
32 | log.Error(err)
33 | }
34 | return &Cache{app: app, redis: rdb}
35 | }
36 |
37 | func (c *Cache) GetCachedTorrents(prefix string) []types.Torrent {
38 | ctx := context.Background()
39 | keys, err := c.redis.Keys(ctx, prefix+":*").Result()
40 | if err != nil {
41 | return nil
42 | }
43 | torrents := []types.Torrent{}
44 | for _, key := range keys {
45 | data, err := c.redis.Get(ctx, key).Result()
46 | if err != nil {
47 | continue
48 | }
49 | var torrent types.Torrent
50 | err = json.Unmarshal([]byte(data), &torrent)
51 | if err != nil {
52 | log.Error("Failed to unmarshal torrent data", "key", key, "error", err)
53 | continue
54 | }
55 | torrents = append(torrents, torrent)
56 | }
57 |
58 | return torrents
59 | }
60 |
61 | func (c *Cache) ReadCache(service string, id string, resource string) interface{} {
62 | if c.redis == nil {
63 | return nil
64 | }
65 | ctx := context.Background()
66 | key := fmt.Sprintf("%s:%s:%s", service, resource, id)
67 |
68 | data, err := c.redis.Get(ctx, key).Result()
69 | if err != nil {
70 | return nil
71 | }
72 | var res any
73 | err = json.Unmarshal([]byte(data), &res)
74 | if err != nil {
75 | return nil
76 | }
77 | log.Debug("cache hit", "for", service, "resource", resource, "id", id)
78 | return res
79 | }
80 |
81 | func (c *Cache) WriteCache(service string, id string, resource string, data any, hours int) {
82 | d := time.Duration(hours) * time.Hour
83 |
84 | if c.redis == nil {
85 | return
86 | }
87 | ctx := context.Background()
88 | key := fmt.Sprintf("%s:%s:%s", service, resource, id)
89 |
90 | if data == nil {
91 | return
92 | }
93 | log.Info("cache write", "for", service, "resource", resource, "id", id)
94 | m, err := json.Marshal(data)
95 | if err != nil {
96 | return
97 | }
98 | err = c.redis.Set(ctx, key, m, d).Err()
99 | if err != nil {
100 | log.Error(err)
101 | }
102 | }
103 |
104 | // func (c *Cache) ReadRDCache(resource string, magnet string) *types.Torrent {
105 | // record, err := c.app.Dao().
106 | // FindFirstRecordByFilter("rd_resolved", "magnet = {:magnet}", dbx.Params{"magnet": magnet})
107 | // var res types.Torrent
108 | // if err == nil {
109 | // err := record.UnmarshalJSONField("data", &res)
110 | // date := record.GetDateTime("updated")
111 | // now := time.Now().Add(time.Duration((-8) * time.Hour))
112 | // if err == nil {
113 | // if date.Time().Before(now) {
114 | // return nil
115 | // }
116 | // log.Debug("cache hit", "for", "RD", "resource", resource)
117 | // return &res
118 | // }
119 | // }
120 | // return nil
121 | // }
122 |
123 | func (c *Cache) ReadRDCacheByResource(resource string) []types.Torrent {
124 | records, err := c.app.Dao().
125 | FindRecordsByFilter("rd_resolved", "resource = {:resource}", "id", -1, 0, dbx.Params{"resource": resource})
126 | res := make([]types.Torrent, 0)
127 | if err == nil {
128 | for _, record := range records {
129 | var r types.Torrent
130 | date := record.GetDateTime("updated")
131 | now := time.Now().Add(time.Duration((-8) * time.Hour))
132 | // add 1 hour to date
133 | if date.Time().Before(now) {
134 | continue
135 | }
136 | err := record.UnmarshalJSONField("data", &r)
137 | if err == nil {
138 | res = append(res, r)
139 | }
140 | }
141 | }
142 | return res
143 | }
144 |
145 | func (c *Cache) WriteRDCache(resource string, magnet string, data interface{}) {
146 | // c.WriteCache("stream", resource, magnet, &data, 12)
147 | log.Info("cache write", "for", "RD", "resource", resource)
148 | record, err := c.app.Dao().
149 | FindFirstRecordByFilter("rd_resolved", "magnet = {:magnet}", dbx.Params{"magnet": magnet})
150 |
151 | if err == nil {
152 | record.Set("data", &data)
153 | c.app.Dao().SaveRecord(record)
154 | } else {
155 | collection, _ := c.app.Dao().FindCollectionByNameOrId("rd_resolved")
156 | record := models.NewRecord(collection)
157 | record.Set("data", &data)
158 | record.Set("magnet", magnet)
159 | record.Set("resource", resource)
160 | c.app.Dao().SaveRecord(record)
161 | }
162 | }
163 |
--------------------------------------------------------------------------------
/apps/backend/common/common.go:
--------------------------------------------------------------------------------
1 | package common
2 |
3 | import (
4 | "encoding/xml"
5 | "fmt"
6 | "regexp"
7 | "strconv"
8 | "strings"
9 | "time"
10 |
11 | "github.com/charmbracelet/log"
12 | mqtt "github.com/eclipse/paho.mqtt.golang"
13 | "github.com/thoas/go-funk"
14 | )
15 |
16 | type Item struct {
17 | XMLName xml.Name `xml:"item"`
18 | Title string `xml:"title"`
19 | Size int64 `xml:"size"`
20 | Link string `xml:"link"`
21 | Enclosure struct {
22 | URL string `xml:"url,attr"`
23 | Length int64 `xml:"length,attr"`
24 | Type string `xml:"type,attr"`
25 | } `xml:"enclosure"`
26 | Attrs []struct {
27 | Name string `xml:"name,attr"`
28 | Value string `xml:"value,attr"`
29 | } `xml:"http://torznab.com/schemas/2015/feed attr"`
30 | }
31 |
32 | type Rss struct {
33 | XMLName xml.Name `xml:"rss"`
34 | Channel struct {
35 | XMLName xml.Name `xml:"channel"`
36 | Link string `xml:"link"`
37 | Title string `xml:"title"`
38 | Description string `xml:"description"`
39 | Language string `xml:"language"`
40 | Category string `xml:"category"`
41 | Items []Item `xml:"item"`
42 | } `xml:"channel"`
43 | }
44 |
45 | type Torrent struct {
46 | Scraper string `json:"scraper"`
47 | Hash string `json:"hash"`
48 | Size uint64 `json:"size"`
49 | ReleaseTitle string `json:"release_title"`
50 | Magnet string `json:"magnet"`
51 | Name string `json:"name"`
52 | Quality string `json:"quality"`
53 | Info []string `json:"info"`
54 | Seeds uint64 `json:"seeds"`
55 | }
56 |
57 | type Payload struct {
58 | Type string `json:"type"`
59 | Title string `json:"title"`
60 | Year string `json:"year"`
61 | Imdb string `json:"imdb"`
62 | Trakt string `json:"trakt"`
63 | ShowImdb string `json:"show_imdb"`
64 | ShowTvdb string `json:"show_tvdb"`
65 | ShowTitle string `json:"show_title"`
66 | ShowYear string `json:"show_year"`
67 | SeasonNumber string `json:"season_number"`
68 | EpisodeImdb string `json:"episode_imdb"`
69 | EpisodeTvdb string `json:"episode_tvdb"`
70 | EpisodeTitle string `json:"episode_title"`
71 | EpisodeNumber string `json:"episode_number"`
72 | EpisodeTrakt string `json:"episode_trakt"`
73 | }
74 |
75 | func ParseDates(str string) string {
76 | re := regexp.MustCompile("::(year|month|day):(\\+|-)?(\\d+)?:")
77 |
78 | matches := re.FindAllStringSubmatch(str, -1)
79 | now := time.Now()
80 | // current := time.Now()
81 | orig := str
82 | for _, match := range matches {
83 |
84 | yearVal := 0
85 | monthVal := 0
86 | dayVal := 0
87 | if len(match) == 4 {
88 | val := 0
89 | if v, err := strconv.Atoi(match[3]); err == nil {
90 | val = v
91 | }
92 | if match[2] == "-" {
93 | val *= -1
94 | }
95 | if match[1] == "year" {
96 |
97 | yearVal = val
98 | str = strings.ReplaceAll(str, match[0], "#year#")
99 | } else if match[1] == "month" {
100 | monthVal = val
101 | str = strings.ReplaceAll(str, match[0], "#month#")
102 | } else if match[1] == "day" {
103 | dayVal = val
104 | str = strings.ReplaceAll(str, match[0], "#day#")
105 | }
106 | }
107 | now = now.AddDate(yearVal, monthVal, dayVal)
108 |
109 | }
110 | str = strings.ReplaceAll(str, "#day#", fmt.Sprintf("%d", now.Day()))
111 | str = strings.ReplaceAll(str, "#month#", fmt.Sprintf("%d", now.Month()))
112 | str = strings.ReplaceAll(str, "#year#", fmt.Sprintf("%d", now.Year()))
113 |
114 | re2 := regexp.MustCompile("::monthdays::")
115 |
116 | matches2 := re2.FindAllStringSubmatch(str, -1)
117 | dinm := daysInMonth(now)
118 | for _, match := range matches2 {
119 | str = strings.ReplaceAll(str, match[0], fmt.Sprintf("%d", dinm))
120 | }
121 |
122 | log.Debug(orig, "new", str, "year", now.Year(), "month", now.Month(), "day", now.Day())
123 |
124 | return str
125 | }
126 |
127 | func daysInMonth(t time.Time) int {
128 | t = time.Date(t.Year(), t.Month(), 32, 0, 0, 0, 0, time.UTC)
129 | daysInMonth := 32 - t.Day()
130 | days := make([]int, daysInMonth)
131 | for i := range days {
132 | days[i] = i + 1
133 | }
134 |
135 | d := days[len(days)-1]
136 | d += 1
137 | return d
138 | }
139 |
140 | func SeparateByQuality(torrents []Torrent, payload Payload) []Torrent {
141 | res := map[string][]Torrent{}
142 |
143 | regexpPatterns := []*regexp.Regexp{
144 | regexp.MustCompile(
145 | fmt.Sprintf("s0?%s[.x]?e0?%s", payload.SeasonNumber, payload.EpisodeNumber),
146 | ),
147 | regexp.MustCompile(
148 | fmt.Sprintf("Season 0?%s,? ?Episode 0?%s", payload.SeasonNumber, payload.EpisodeNumber),
149 | ),
150 | }
151 |
152 | for _, q := range []string{"4K", "1080p", "720p", "SD", "CAM"} {
153 | res[q] = []Torrent{}
154 | }
155 |
156 | for _, t := range torrents {
157 | if _, ok := res[t.Quality]; !ok {
158 | res[t.Quality] = []Torrent{}
159 | }
160 |
161 | // sort SxEx episodes first
162 | if payload.Type == "episode" {
163 | title := strings.ToLower(t.ReleaseTitle)
164 | for _, pattern := range regexpPatterns {
165 | if pattern.MatchString(title) {
166 | res[t.Quality] = append([]Torrent{t}, res[t.Quality]...)
167 | break
168 | } else {
169 | res[t.Quality] = append(res[t.Quality], t)
170 | }
171 | }
172 | } else {
173 | res[t.Quality] = append(res[t.Quality], t)
174 | }
175 | }
176 |
177 | // if len(res["4K"]) > 20 {
178 | // res["4K"] = res["4K"][:20]
179 | // }
180 |
181 | // if len(res["1080p"]) > 20 {
182 | // res["1080p"] = res["1080p"][:20]
183 | // }
184 |
185 | // if len(res["720p"]) > 10 {
186 | // res["720p"] = res["720p"][:10]
187 | // }
188 |
189 | // if len(res["SD"]) > 10 {
190 | // res["SD"] = res["SD"][:10]
191 | // }
192 |
193 | // if len(res["4K"])+len(res["1080p"]) > 30 {
194 |
195 | // res["720p"] = []Torrent{}
196 | // res["SD"] = []Torrent{}
197 | // }
198 |
199 | // if len(res["4K"]) > 1 {
200 | // res["1080p"] = res["1080p"][:20]
201 | // }
202 |
203 | // if len(res["1080p"]) > 30 {
204 | // res["1080p"] = res["1080p"][:30]
205 | // }
206 |
207 | ret := append(res["4K"], res["1080p"]...)
208 | ret = append(ret, res["720p"]...)
209 | ret = append(ret, res["SD"]...)
210 | return ret
211 | }
212 |
213 | func Dedupe(torrents []Torrent) []Torrent {
214 | res := []Torrent{}
215 | hashes := []string{}
216 | for _, t := range torrents {
217 | if t.Magnet != "" && !funk.ContainsString(hashes, t.Hash) {
218 | res = append(res, t)
219 | hashes = append(hashes, t.Hash)
220 | }
221 | }
222 | return res
223 | }
224 |
225 | func GetInfos(title string) ([]string, string) {
226 | title = strings.ToLower(title)
227 |
228 | res := []string{}
229 | quality := "SD"
230 | infoTypes := map[string][]string{
231 | "AVC": {"x264", "x 264", "h264", "h 264", "avc"},
232 | "HEVC": {"x265", "x 265", "h265", "h 265", "hevc"},
233 | "XVID": {"xvid"},
234 | "DIVX": {"divx"},
235 | "MP4": {"mp4"},
236 | "WMV": {"wmv"},
237 | "MPEG": {"mpeg"},
238 | "4K": {"4k", "2160p", "216o"},
239 | "1080p": {"1080p", "1o80", "108o", "1o8p"},
240 | "720p": {"720", "72o"},
241 | "REMUX": {"remux", "bdremux"},
242 | "DV": {" dv ", "dovi", "dolby vision", "dolbyvision"},
243 | "HDR": {
244 | " hdr ",
245 | "hdr10",
246 | "hdr 10",
247 | "uhd bluray 2160p",
248 | "uhd blu ray 2160p",
249 | "2160p uhd bluray",
250 | "2160p uhd blu ray",
251 | "2160p bluray hevc truehd",
252 | "2160p bluray hevc dts",
253 | "2160p bluray hevc lpcm",
254 | "2160p us bluray hevc truehd",
255 | "2160p us bluray hevc dts",
256 | },
257 | "SDR": {" sdr"},
258 | "AAC": {"aac"},
259 | "DTS-HDMA": {"hd ma", "hdma"},
260 | "DTS-HDHR": {"hd hr", "hdhr", "dts hr", "dtshr"},
261 | "DTS-X": {"dtsx", " dts x"},
262 | "ATMOS": {"atmos"},
263 | "TRUEHD": {"truehd", "true hd"},
264 | "DD+": {"ddp", "eac3", " e ac3", " e ac 3", "dd+", "digital plus", "digitalplus"},
265 | "DD": {
266 | " dd ",
267 | "dd2",
268 | "dd5",
269 | "dd7",
270 | " ac3",
271 | " ac 3",
272 | "dolby digital",
273 | "dolbydigital",
274 | "dolby5",
275 | },
276 | "MP3": {"mp3"},
277 | "WMA": {" wma"},
278 | "2.0": {"2 0 ", "2 0ch", "2ch"},
279 | "5.1": {"5 1 ", "5 1ch", "6ch"},
280 | "7.1": {"7 1 ", "7 1ch", "8ch"},
281 | "BLURAY": {"bluray", "blu ray", "bdrip", "bd rip", "brrip", "br rip"},
282 | "WEB": {" web ", "webrip", "webdl", "web rip", "web dl", "webmux"},
283 | "HD-RIP": {" hdrip", " hd rip"},
284 | "DVDRIP": {"dvdrip", "dvd rip"},
285 | "HDTV": {"hdtv"},
286 | "PDTV": {"pdtv"},
287 | "CAMQUALITY": {
288 | " cam ", "camrip", "cam rip",
289 | "hdcam", "hd cam",
290 | " ts ", " ts1", " ts7",
291 | "hd ts", "hdts",
292 | "telesync",
293 | " tc ", " tc1", " tc7",
294 | "hd tc", "hdtc",
295 | "telecine",
296 | "xbet",
297 | "hcts", "hc ts",
298 | "hctc", "hc tc",
299 | "hqcam", "hq cam",
300 | },
301 | "SCR": {"scr ", "screener"},
302 | "HC": {
303 | "korsub", " kor ",
304 | " hc ", "hcsub", "hcts", "hctc", "hchdrip",
305 | "hardsub", "hard sub",
306 | "sub hard",
307 | "hardcode", "hard code",
308 | "vostfr", "vo stfr",
309 | },
310 | "3D": {" 3d"},
311 | }
312 | for baseInfo, infoType := range infoTypes {
313 | for _, info := range infoType {
314 | if strings.Contains(title, strings.ToLower(baseInfo)) {
315 | res = append(res, baseInfo)
316 | break
317 | }
318 | if strings.Contains(title, strings.ToLower(info)) {
319 | res = append(res, baseInfo)
320 | break
321 | }
322 |
323 | if strings.Contains(title, strings.ReplaceAll(strings.ToLower(info), " ", ".")) {
324 | res = append(res, baseInfo)
325 | break
326 | }
327 | }
328 | }
329 |
330 | if funk.Contains(res, "SDR") && funk.Contains(res, "HDR") {
331 | res = funk.FilterString(res, func(s string) bool {
332 | return s != "SDR"
333 | })
334 | }
335 |
336 | if funk.Contains(res, "DD") && funk.Contains(res, "DD+") {
337 | res = funk.FilterString(res, func(s string) bool {
338 | return s != "DD"
339 | })
340 | }
341 |
342 | if funk.ContainsString([]string{"2160p", "remux"}, title) &&
343 | !funk.Contains(res, []string{"HDR", "SDR"}) {
344 | res = append(res, "HDR")
345 | }
346 |
347 | if funk.Contains(res, "720p") {
348 | quality = "720p"
349 | }
350 | if funk.Contains(res, "1080p") {
351 | quality = "1080p"
352 | }
353 |
354 | if funk.Contains(res, "4K") {
355 | quality = "4K"
356 | }
357 | if funk.Contains(res, "CAMQUALITY") {
358 | quality = "CAM"
359 | }
360 |
361 | return res, quality
362 | }
363 |
364 | func SimplifyMagnet(magnet string) string {
365 | s := ""
366 | r := regexp.MustCompile(`magnet:\?xt=urn:btih:\s*(.*?)\s*&dn`)
367 | matches := r.FindAllStringSubmatch(magnet, -1)
368 | for _, v := range matches {
369 | s = v[1]
370 | }
371 | return "magnet:?xt=urn:btih:" + s
372 | }
373 |
374 | func Strip(s string) string {
375 | var result strings.Builder
376 | for i := 0; i < len(s); i++ {
377 | b := s[i]
378 | if b >= 32 && b <= 126 {
379 | result.WriteByte(b)
380 | }
381 | }
382 | return result.String()
383 | }
384 |
385 | func MqttClient() mqtt.Client {
386 | // mqtt.DEBUG = stdlog.New(os.Stdout, "", 0)
387 | // mqtt.ERROR = stdlog.New(os.Stdout, "", 0)
388 | opts := mqtt.NewClientOptions().
389 | AddBroker("ws://127.0.0.1:6060/ws/mqtt")
390 | opts.SetKeepAlive(2 * time.Second)
391 | opts.SetPingTimeout(1 * time.Second)
392 |
393 | c := mqtt.NewClient(opts)
394 | if token := c.Connect(); token.Wait() && token.Error() != nil {
395 | log.Error("MQTT", "conneced", c.IsConnected())
396 | } else {
397 | log.Info("MQTT", "connected", c.IsConnected())
398 | }
399 |
400 | return c
401 | }
402 |
--------------------------------------------------------------------------------
/apps/backend/downloader/alldebrid/alldebrid.go:
--------------------------------------------------------------------------------
1 | package alldebrid
2 |
3 | import (
4 | "fmt"
5 | "mime"
6 | "net/http"
7 | "os"
8 | "regexp"
9 | "strconv"
10 | "strings"
11 | "time"
12 |
13 | "github.com/odin-movieshow/backend/settings"
14 | "github.com/odin-movieshow/backend/types"
15 |
16 | "github.com/charmbracelet/log"
17 | "github.com/go-resty/resty/v2"
18 | "github.com/pocketbase/pocketbase"
19 | )
20 |
21 | type AllDebrid struct {
22 | app *pocketbase.PocketBase
23 | settings *settings.Settings
24 | Headers map[string]any
25 | }
26 |
27 | type Magnet struct {
28 | Magnet string `json:"magnet"`
29 | Hash string `json:"hash"`
30 | Name string `json:"name"`
31 | Size int `json:"size"`
32 | Ready bool `json:"ready"`
33 | ID int `json:"id"`
34 | }
35 |
36 | type FileNode struct {
37 | N string `json:"n"`
38 | S int `json:"s"`
39 | L string `json:"l"`
40 | E []FileNode `json:"e"`
41 | }
42 |
43 | func New(app *pocketbase.PocketBase, settings *settings.Settings) *AllDebrid {
44 | return &AllDebrid{app: app, settings: settings}
45 | }
46 |
47 | func (ad *AllDebrid) CallEndpoint(
48 | endpoint string,
49 | method string,
50 | body map[string]string,
51 | res interface{},
52 | ) (http.Header, int) {
53 | appendix := "?"
54 | if strings.Contains(endpoint, "?") {
55 | appendix = "&"
56 | }
57 | endpoint = endpoint + appendix + "agent=odinMovieShow&apikey=" + os.Getenv("ALLDEBRID_KEY")
58 |
59 | request := resty.New().
60 | SetRetryCount(3).
61 | SetRetryWaitTime(time.Second * 1).
62 | AddRetryCondition(func(r *resty.Response, err error) bool {
63 | return r.StatusCode() == 429
64 | }).
65 | R()
66 | request.SetResult(res)
67 | var respHeaders http.Header
68 | status := 200
69 |
70 | if body != nil {
71 | request.SetFormData(body)
72 | }
73 |
74 | request.Attempt = 3
75 |
76 | var r func(url string) (*resty.Response, error)
77 | switch method {
78 | case "POST":
79 | r = request.Post
80 | case "PATCH":
81 | r = request.Patch
82 | case "PUT":
83 | r = request.Put
84 | case "DELETE":
85 | r = request.Delete
86 | default:
87 | r = request.Get
88 |
89 | }
90 |
91 | resp, err := r("https://api.alldebrid.com/v4" + endpoint)
92 | if err == nil {
93 | respHeaders = resp.Header()
94 | status = resp.StatusCode()
95 | } else {
96 | log.Error("alldebrid", "url", endpoint, "error", err)
97 | return respHeaders, status
98 | }
99 |
100 | if status > 299 {
101 | log.Error(
102 | "alldebrid",
103 | "status",
104 | status,
105 | "url",
106 | endpoint,
107 | "data",
108 | strings.ReplaceAll(string(resp.Body()), "\n", ""),
109 | )
110 | } else {
111 | log.Debug("alldebrid", "call", fmt.Sprintf("%s %s", method, endpoint))
112 | }
113 |
114 | return respHeaders, status
115 | }
116 |
117 | func getLinks(files []FileNode) []string {
118 | links := []string{}
119 | for _, v := range files {
120 | if v.L != "" {
121 | links = append(links, v.L)
122 | continue
123 | }
124 | if len(v.E) > 0 {
125 | links = append(links, getLinks(v.E)...)
126 | }
127 | }
128 | return links
129 | }
130 |
131 | func (ad *AllDebrid) Unrestrict(m string) []types.Unrestricted {
132 | var res struct {
133 | Data struct {
134 | Magnets []Magnet `json:"magnets"`
135 | } `json:"data"`
136 | }
137 |
138 | ad.CallEndpoint("/magnet/upload?magnets[]="+m, "GET", nil, &res)
139 |
140 | if len(res.Data.Magnets) == 0 {
141 | log.Debug("No magnets found for", m)
142 | return nil
143 | }
144 |
145 | magnetId := strconv.Itoa(int(res.Data.Magnets[0].ID))
146 | magnetReady := res.Data.Magnets[0].Ready
147 | defer ad.CallEndpoint(
148 | fmt.Sprintf("/magnet/delete?id=%s", magnetId),
149 | "GET",
150 | nil,
151 | nil,
152 | )
153 |
154 | if !magnetReady {
155 | log.Debug("Magnet not available in cache", magnetId)
156 | return nil
157 | }
158 |
159 | var files struct {
160 | Data struct {
161 | Magnets []struct {
162 | Files []FileNode `json:"files"`
163 | } `json:"magnets"`
164 | } `json:"data"`
165 | }
166 |
167 | ad.CallEndpoint("/magnet/files?id[]="+magnetId, "GET", nil, &files)
168 |
169 | if len(files.Data.Magnets) == 0 || len(files.Data.Magnets[0].Files) == 0 {
170 | log.Debug("No files found for magnet", magnetId)
171 | return nil
172 | }
173 |
174 | us := []types.Unrestricted{}
175 |
176 | for _, f := range files.Data.Magnets[0].Files {
177 |
178 | link := f.L
179 | if link == "" {
180 | continue
181 | }
182 | var u struct {
183 | Data struct {
184 | Link string `json:"link"`
185 | Filename string `json:"filename"`
186 | Filesize int `json:"filesize"`
187 | } `json:"data"`
188 | }
189 | ad.CallEndpoint("/link/unlock?link="+link, "GET", nil, &u)
190 | fname := u.Data.Filename
191 | mimetype := mime.TypeByExtension(fname[strings.LastIndex(fname, "."):])
192 |
193 | isVideo := strings.Contains(
194 | mimetype,
195 | "video",
196 | )
197 |
198 | match, _ := regexp.MatchString("^[Ss]ample[ -_]?[0-9].", fname)
199 |
200 | if !match && isVideo {
201 | un := types.Unrestricted{Filename: fname, Filesize: u.Data.Filesize, Download: u.Data.Link}
202 | us = append(us, un)
203 | }
204 |
205 | }
206 | return us
207 | }
208 |
--------------------------------------------------------------------------------
/apps/backend/downloader/realdebrid/realdebrid.go:
--------------------------------------------------------------------------------
1 | package realdebrid
2 |
3 | import (
4 | "fmt"
5 | "mime"
6 | "net/http"
7 | "regexp"
8 | "strconv"
9 | "strings"
10 | "time"
11 |
12 | "github.com/odin-movieshow/backend/settings"
13 | "github.com/odin-movieshow/backend/types"
14 |
15 | "github.com/charmbracelet/log"
16 | "github.com/go-resty/resty/v2"
17 | "github.com/pocketbase/pocketbase"
18 | "github.com/pocketbase/pocketbase/models"
19 | "github.com/thoas/go-funk"
20 | )
21 |
22 | type RealDebrid struct {
23 | app *pocketbase.PocketBase
24 | settings *settings.Settings
25 | Headers map[string]any
26 | }
27 |
28 | func New(app *pocketbase.PocketBase, settings *settings.Settings) *RealDebrid {
29 | return &RealDebrid{app: app, settings: settings}
30 | }
31 |
32 | func (rd *RealDebrid) RemoveByType(t string) {
33 | var res interface{}
34 | headers, _ := rd.CallEndpoint(fmt.Sprintf("/%s/?limit=1", t), "GET", nil, &res, false)
35 | if res == nil {
36 | return
37 | }
38 |
39 | count := 0
40 | if headers.Get("X-Total-Count") != "" {
41 | c, err := strconv.Atoi(headers.Get("X-Total-Count"))
42 | if err == nil {
43 | count = c
44 | }
45 | }
46 |
47 | for count > 0 {
48 |
49 | rd.CallEndpoint(fmt.Sprintf("/%s/?limit=200", t), "GET", nil, &res, false)
50 | for _, v := range res.([]any) {
51 | rd.CallEndpoint(
52 | fmt.Sprintf("/%s/delete/%s", t, v.(map[string]any)["id"].(string), nil),
53 | "DELETE",
54 | nil,
55 | nil,
56 | false,
57 | )
58 | }
59 | count -= 200
60 | }
61 |
62 | log.Info("realdebrid cleanup", "type", t, "count", count)
63 | }
64 |
65 | func (rd *RealDebrid) RefreshTokens() {
66 | records := []models.Record{}
67 | rd.app.Dao().RecordQuery("settings").All(&records)
68 | if len(records) == 0 {
69 | return
70 | }
71 | data := make(map[string]any)
72 | r := records[0]
73 |
74 | rdsets := rd.settings.GetRealDebrid()
75 | request := resty.New().SetRetryCount(3).SetRetryWaitTime(time.Second * 3).R()
76 | request.SetHeader("Authorization", "Bearer "+rdsets.AccessToken)
77 |
78 | for k, v := range rd.Headers {
79 |
80 | if funk.Contains([]string{"Host", "Connection"}, k) {
81 | continue
82 | }
83 | request.SetHeader(k, v.(string))
84 | }
85 | if _, err := request.SetFormData(map[string]string{
86 | "client_id": rdsets.ClientId,
87 | "client_secret": rdsets.ClientSecret,
88 | "code": rdsets.RefreshToken,
89 | "grant_type": "http://oauth.net/grant_type/device/1.0",
90 | }).SetResult(&data).Post("https://api.real-debrid.com/oauth/v2/token"); err == nil {
91 | if data["access_token"] == nil || data["refresh_token"] == nil {
92 | return
93 | }
94 | rdsets.AccessToken = data["access_token"].(string)
95 | rdsets.RefreshToken = data["refresh_token"].(string)
96 | r.Set("real_debrid", rdsets)
97 | log.Info("realdebrid", "token", "refreshed")
98 | rd.app.Dao().SaveRecord(&r)
99 | }
100 | }
101 |
102 | func (rd *RealDebrid) CallEndpoint(
103 | endpoint string,
104 | method string,
105 | body map[string]string,
106 | data any,
107 | isAuth bool,
108 | ) (http.Header, int) {
109 | request := resty.New().
110 | SetRetryCount(3).
111 | SetRetryWaitTime(time.Second * 1).
112 | AddRetryCondition(func(r *resty.Response, err error) bool {
113 | return r.StatusCode() == 429
114 | }).
115 | R()
116 | request.SetResult(&data)
117 | var respHeaders http.Header
118 | status := 200
119 |
120 | request.SetFormData(body)
121 |
122 | if !isAuth {
123 |
124 | rdsets := rd.settings.GetRealDebrid()
125 | request.SetHeader("Authorization", "Bearer "+rdsets.AccessToken)
126 | }
127 |
128 | request.Attempt = 3
129 |
130 | var r func(url string) (*resty.Response, error)
131 | switch method {
132 | case "POST":
133 | r = request.Post
134 | case "PATCH":
135 | r = request.Patch
136 | case "PUT":
137 | r = request.Put
138 | case "DELETE":
139 | r = request.Delete
140 | default:
141 | r = request.Get
142 |
143 | }
144 |
145 | host := "https://api.real-debrid.com/rest/1.0"
146 | if isAuth {
147 | host = "https://api.real-debrid.com/oauth/v2"
148 | }
149 |
150 | resp, err := r(host + endpoint)
151 | if err == nil {
152 | respHeaders = resp.Header()
153 | status = resp.StatusCode()
154 | } else {
155 | log.Error("realdebrid", "url", endpoint, "error", err)
156 | return respHeaders, status
157 | }
158 |
159 | if status > 299 {
160 | log.Error(
161 | "realdebrid",
162 | "status",
163 | status,
164 | "url",
165 | endpoint,
166 | "data",
167 | strings.Replace(string(resp.Body()), "\n", "", -1),
168 | )
169 | } else {
170 | log.Debug("realdebrid", "call", fmt.Sprintf("%s %s", method, endpoint))
171 | }
172 |
173 | return respHeaders, status
174 | }
175 |
176 | type Magnet struct {
177 | Id string `json:"id"`
178 | }
179 |
180 | type Info struct {
181 | Links []string `json:"links"`
182 | }
183 |
184 | type Link struct {
185 | Id string `json:"id"`
186 | Filename string `json:"filename"`
187 | Filesize uint `json:"filesize"`
188 | Download string `json:"download"`
189 | Streamable int `json:"streamable`
190 | }
191 |
192 | func (rd *RealDebrid) Unrestrict(m string) []types.Unrestricted {
193 | magnet := Magnet{}
194 | rd.CallEndpoint("/torrents/addMagnet", "POST", map[string]string{
195 | "host": "real-debrid.com",
196 | "magnet": m,
197 | }, &magnet, false)
198 |
199 | if magnet.Id == "" {
200 | return nil
201 | }
202 |
203 | defer rd.CallEndpoint(
204 | fmt.Sprintf("/torrents/delete/%s", magnet.Id),
205 | "DELETE",
206 | nil,
207 | nil,
208 | false,
209 | )
210 |
211 | rd.CallEndpoint("/torrents/selectFiles/"+magnet.Id, "POST", map[string]string{
212 | "files": "all",
213 | }, nil, false)
214 |
215 | info := Info{}
216 | rd.CallEndpoint("/torrents/info/"+magnet.Id, "GET", nil, &info, false)
217 |
218 | if len(info.Links) == 0 {
219 | return nil
220 | }
221 |
222 | us := []types.Unrestricted{}
223 |
224 | for _, v := range info.Links {
225 | u := Link{}
226 | rd.CallEndpoint("/unrestrict/link", "POST", map[string]string{
227 | "link": v,
228 | }, &u, false)
229 | if u.Filename == "" {
230 | continue
231 | }
232 | fname := u.Filename
233 |
234 | mimetype := mime.TypeByExtension(fname[strings.LastIndex(fname, "."):])
235 |
236 | isVideo := strings.Contains(
237 | mimetype,
238 | "video",
239 | )
240 |
241 | match, _ := regexp.MatchString("^[Ss]ample[ -_]?[0-9].", fname)
242 |
243 | if !match && isVideo {
244 | log.Debug("realdebrid unrestricted", "file", fname)
245 | streams := []string{}
246 | if u.Streamable == 1 {
247 | streams = append(streams, "https://real-debrid.com/streaming-"+u.Id)
248 | }
249 | un := types.Unrestricted{Filename: fname, Filesize: int(u.Filesize), Download: u.Download, Streams: streams}
250 | us = append(us, un)
251 | }
252 | }
253 |
254 | return us
255 | }
256 |
257 | func (rd *RealDebrid) Cleanup() {
258 | rd.RemoveByType("downloads")
259 | }
260 |
--------------------------------------------------------------------------------
/apps/backend/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/odin-movieshow/backend
2 |
3 | go 1.22.7
4 |
5 | toolchain go1.23.2
6 |
7 | require (
8 | github.com/charmbracelet/log v0.4.0
9 | github.com/eclipse/paho.mqtt.golang v1.5.0
10 | github.com/go-resty/resty/v2 v2.15.3
11 | github.com/joho/godotenv v1.5.1
12 | github.com/labstack/echo/v5 v5.0.0-20230722203903-ec5b858dab61
13 | github.com/pocketbase/dbx v1.10.1
14 | github.com/pocketbase/pocketbase v0.22.23
15 | github.com/thoas/go-funk v0.9.3
16 | )
17 |
18 | require (
19 | cloud.google.com/go/iam v1.2.1 // indirect
20 | github.com/AlecAivazis/survey/v2 v2.3.7 // indirect
21 | github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
22 | github.com/aws/aws-sdk-go-v2 v1.32.4 // indirect
23 | github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.6.6 // indirect
24 | github.com/aws/aws-sdk-go-v2/config v1.28.2 // indirect
25 | github.com/aws/aws-sdk-go-v2/credentials v1.17.43 // indirect
26 | github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.19 // indirect
27 | github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.17.36 // indirect
28 | github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.23 // indirect
29 | github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.23 // indirect
30 | github.com/aws/aws-sdk-go-v2/internal/ini v1.8.1 // indirect
31 | github.com/aws/aws-sdk-go-v2/internal/v4a v1.3.23 // indirect
32 | github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.0 // indirect
33 | github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.4.4 // indirect
34 | github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.4 // indirect
35 | github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.18.4 // indirect
36 | github.com/aws/aws-sdk-go-v2/service/s3 v1.66.3 // indirect
37 | github.com/aws/aws-sdk-go-v2/service/sso v1.24.4 // indirect
38 | github.com/aws/aws-sdk-go-v2/service/ssooidc v1.28.4 // indirect
39 | github.com/aws/aws-sdk-go-v2/service/sts v1.32.4 // indirect
40 | github.com/aws/smithy-go v1.22.0 // indirect
41 | github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
42 | github.com/cespare/xxhash/v2 v2.3.0 // indirect
43 | github.com/charmbracelet/lipgloss v1.0.0 // indirect
44 | github.com/charmbracelet/x/ansi v0.4.2 // indirect
45 | github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
46 | github.com/disintegration/imaging v1.6.2 // indirect
47 | github.com/domodwyer/mailyak/v3 v3.6.2 // indirect
48 | github.com/dustin/go-humanize v1.0.1 // indirect
49 | github.com/fatih/color v1.18.0 // indirect
50 | github.com/gabriel-vasile/mimetype v1.4.6 // indirect
51 | github.com/ganigeorgiev/fexpr v0.4.1 // indirect
52 | github.com/go-logfmt/logfmt v0.6.0 // indirect
53 | github.com/go-ozzo/ozzo-validation/v4 v4.3.0 // indirect
54 | github.com/goccy/go-json v0.10.3 // indirect
55 | github.com/golang-jwt/jwt/v4 v4.5.1 // indirect
56 | github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
57 | github.com/google/pprof v0.0.0-20241101162523-b92577c0c142 // indirect
58 | github.com/google/uuid v1.6.0 // indirect
59 | github.com/googleapis/gax-go/v2 v2.13.0 // indirect
60 | github.com/gorilla/websocket v1.5.3 // indirect
61 | github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
62 | github.com/inconshreveable/mousetrap v1.1.0 // indirect
63 | github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
64 | github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
65 | github.com/mattn/go-colorable v0.1.13 // indirect
66 | github.com/mattn/go-isatty v0.0.20 // indirect
67 | github.com/mattn/go-runewidth v0.0.16 // indirect
68 | github.com/mattn/go-sqlite3 v1.14.24 // indirect
69 | github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
70 | github.com/muesli/termenv v0.15.2 // indirect
71 | github.com/ncruces/go-strftime v0.1.9 // indirect
72 | github.com/redis/go-redis/v9 v9.9.0 // indirect
73 | github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
74 | github.com/rivo/uniseg v0.4.7 // indirect
75 | github.com/spf13/cast v1.7.0 // indirect
76 | github.com/spf13/cobra v1.8.1 // indirect
77 | github.com/spf13/pflag v1.0.5 // indirect
78 | github.com/valyala/bytebufferpool v1.0.0 // indirect
79 | github.com/valyala/fasttemplate v1.2.2 // indirect
80 | go.opencensus.io v0.24.0 // indirect
81 | gocloud.dev v0.40.0 // indirect
82 | golang.org/x/crypto v0.28.0 // indirect
83 | golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c // indirect
84 | golang.org/x/image v0.21.0 // indirect
85 | golang.org/x/net v0.30.0 // indirect
86 | golang.org/x/oauth2 v0.23.0 // indirect
87 | golang.org/x/sync v0.8.0 // indirect
88 | golang.org/x/sys v0.26.0 // indirect
89 | golang.org/x/term v0.25.0 // indirect
90 | golang.org/x/text v0.19.0 // indirect
91 | golang.org/x/time v0.7.0 // indirect
92 | golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
93 | google.golang.org/api v0.205.0 // indirect
94 | google.golang.org/genproto/googleapis/api v0.0.0-20241015192408-796eee8c2d53 // indirect
95 | google.golang.org/genproto/googleapis/rpc v0.0.0-20241104194629-dd2ea8efbc28 // indirect
96 | google.golang.org/grpc v1.68.0 // indirect
97 | google.golang.org/protobuf v1.35.1 // indirect
98 | modernc.org/gc/v3 v3.0.0-20240801135723-a856999a2e4a // indirect
99 | modernc.org/libc v1.61.0 // indirect
100 | modernc.org/mathutil v1.6.0 // indirect
101 | modernc.org/memory v1.8.0 // indirect
102 | modernc.org/sqlite v1.33.1 // indirect
103 | modernc.org/strutil v1.2.0 // indirect
104 | modernc.org/token v1.1.0 // indirect
105 | )
106 |
--------------------------------------------------------------------------------
/apps/backend/helpers/helpers.go:
--------------------------------------------------------------------------------
1 | package helpers
2 |
3 | import (
4 | "fmt"
5 | "os/user"
6 |
7 | "github.com/pocketbase/pocketbase"
8 | )
9 |
10 | type Helpers struct {
11 | app *pocketbase.PocketBase
12 | }
13 |
14 | func New(app *pocketbase.PocketBase) *Helpers {
15 | return &Helpers{app: app}
16 | }
17 |
18 | func (h *Helpers) GetHomeDir() string {
19 | currentUser, err := user.Current()
20 | if err != nil {
21 | fmt.Println(err)
22 | return ""
23 | }
24 | return currentUser.HomeDir
25 | }
26 |
--------------------------------------------------------------------------------
/apps/backend/imdb/imdb.go:
--------------------------------------------------------------------------------
1 | package imdb
2 |
3 | import (
4 | "encoding/json"
5 | "strings"
6 | "time"
7 |
8 | "github.com/charmbracelet/log"
9 | "github.com/go-resty/resty/v2"
10 | )
11 |
12 | func Get(id string) map[string]interface{} {
13 | request := resty.New().
14 | SetRetryCount(3).
15 | SetTimeout(time.Second * 30).
16 | SetRetryWaitTime(time.Second).
17 | R()
18 |
19 | res, err := request.Get("https://www.imdb.com/title/" + id)
20 | r := make(map[string]interface{})
21 | if err == nil {
22 | b := string(res.Body())
23 | start := ""
25 | startIndex := strings.Index(b, start)
26 | endIndex := strings.Index(b[startIndex+len(start):], end)
27 | str := b[startIndex+len(start) : endIndex+startIndex+len(start)]
28 | if err := json.Unmarshal([]byte(str), &r); err != nil {
29 | log.Error("imdb", "id", id, "err", err)
30 | } else {
31 | log.Info("imdb", "id", id, "parsed", "success")
32 | }
33 | }
34 | return r
35 | }
36 |
--------------------------------------------------------------------------------
/apps/backend/indexer/indexer.go:
--------------------------------------------------------------------------------
1 | package indexer
2 |
3 | import (
4 | "os"
5 |
6 | "github.com/charmbracelet/log"
7 | mqtt "github.com/eclipse/paho.mqtt.golang"
8 | "github.com/odin-movieshow/backend/common"
9 | "github.com/odin-movieshow/backend/indexer/jackett"
10 | )
11 |
12 | type Indexer struct {
13 | mqt mqtt.Client
14 | }
15 |
16 | func New(mqt mqtt.Client) *Indexer {
17 | return &Indexer{mqt: mqt}
18 | }
19 |
20 | func Index(data common.Payload) {
21 | jackettUrl := os.Getenv("JACKETT_URL")
22 | jackettKey := os.Getenv("JACKETT_KEY")
23 | if jackettUrl == "" || jackettKey == "" {
24 | log.Error("missing env vars JACKETT_URL and JACKETT_KEY")
25 | return
26 | }
27 |
28 | jackett.Search(data)
29 | }
30 |
--------------------------------------------------------------------------------
/apps/backend/indexer/jackett/jackett.go:
--------------------------------------------------------------------------------
1 | package jackett
2 |
3 | import (
4 | "encoding/json"
5 | "encoding/xml"
6 | "fmt"
7 | "net/url"
8 | "os"
9 | "strconv"
10 | "strings"
11 | "sync"
12 | "time"
13 |
14 | "github.com/charmbracelet/log"
15 | "github.com/go-resty/resty/v2"
16 | "github.com/odin-movieshow/backend/common"
17 | )
18 |
19 | type Indexer struct {
20 | Id string `xml:"id,attr"`
21 | Title string `xml:"title"`
22 | Caps struct {
23 | Searching struct {
24 | Search struct {
25 | Available string `xml:"available,attr"`
26 | SupportedParams string `xml:"supportedParams,attr"`
27 | } `xml:"search"`
28 | MovieSearch struct {
29 | Available string `xml:"available,attr"`
30 | SupportedParams string `xml:"supportedParams,attr"`
31 | } `xml:"movie-search"`
32 | TvSearch struct {
33 | Available string `xml:"available,attr"`
34 | SupportedParams string `xml:"supportedParams,attr"`
35 | } `xml:"tv-search"`
36 | } `xml:"searching"`
37 | Categories struct {
38 | Category []struct {
39 | ID string `xml:"id,attr"`
40 | Name string `xml:"name,attr"`
41 | } `xml:"category"`
42 | } `xml:"categories"`
43 | } `xml:"caps"`
44 | }
45 |
46 | func (indexer *Indexer) SearchAvailable() bool {
47 | return indexer.Caps.Searching.Search.Available == "yes"
48 | }
49 |
50 | func (indexer *Indexer) MovieSearchAvailable() bool {
51 | return indexer.Caps.Searching.MovieSearch.Available == "yes"
52 | }
53 |
54 | func (indexer *Indexer) TvSearchAvailable() bool {
55 | return indexer.Caps.Searching.TvSearch.Available == "yes"
56 | }
57 |
58 | func (indexer *Indexer) HasMovieParam(param string) bool {
59 | return strings.Contains(indexer.Caps.Searching.MovieSearch.SupportedParams, param)
60 | }
61 |
62 | func (indexer *Indexer) HasTvParam(param string) bool {
63 | return strings.Contains(indexer.Caps.Searching.TvSearch.SupportedParams, param)
64 | }
65 |
66 | func Search(payload common.Payload) {
67 | mq := common.MqttClient()
68 |
69 | payload.Title = url.QueryEscape(common.Strip(payload.Title))
70 | payload.EpisodeTitle = url.QueryEscape(common.Strip(payload.EpisodeTitle))
71 | payload.ShowTitle = url.QueryEscape(common.Strip(payload.ShowTitle))
72 |
73 | indexers := getIndexerList(payload)
74 | l := log.Debug
75 | wg := sync.WaitGroup{}
76 | indexertopic := "odin-movieshow/indexer/" + payload.Type
77 | if payload.Type == "episode" {
78 | indexertopic += "/" + payload.EpisodeTrakt
79 | } else {
80 | indexertopic += "/" + payload.Trakt
81 | }
82 | total := 0
83 | log.Debug("MQTT", "topic", indexertopic)
84 | for _, indexer := range indexers {
85 | wg.Add(1)
86 | go func(indexer Indexer) {
87 | defer wg.Done()
88 | t1 := time.Now()
89 | ts := getTorrents(indexer, payload)
90 | t2 := time.Now()
91 | if len(ts) > 0 {
92 | l = log.Info
93 | }
94 | l(
95 | "indexer",
96 | "id",
97 | indexer.Title,
98 | "type",
99 | payload.Type,
100 | "torrents",
101 | len(ts),
102 | "took",
103 | fmt.Sprintf("%.1fs", t2.Sub(t1).Seconds()),
104 | )
105 | if ts != nil {
106 | total += len(ts)
107 | tsstr, _ := json.Marshal(ts)
108 | mq.Publish(
109 | indexertopic,
110 | 0,
111 | false,
112 | tsstr,
113 | )
114 | }
115 | }(indexer)
116 | }
117 |
118 | wg.Wait()
119 | mq.Publish(indexertopic, 0, false, "INDEXING_DONE")
120 | log.Info("Indexing done", "total", total)
121 | }
122 |
123 | func getIndexerList(payload common.Payload) []Indexer {
124 | cat := "Movies"
125 |
126 | if payload.Type == "episode" {
127 | cat = "TV"
128 | }
129 | var indexers struct {
130 | Indexers []Indexer `xml:"indexer"`
131 | }
132 |
133 | jackettUrl := os.Getenv("JACKETT_URL")
134 | jackettKey := os.Getenv("JACKETT_KEY")
135 |
136 | request := resty.New().
137 | SetRetryCount(3).
138 | SetTimeout(time.Second * 60).
139 | SetRetryWaitTime(time.Second * 2).
140 | R()
141 | resp, err := request.Get(
142 | fmt.Sprintf(
143 | "%s/api/v2.0/indexers/type:public/results/torznab/api?apikey=%s&t=indexers&configured=true",
144 | jackettUrl,
145 | jackettKey,
146 | ),
147 | )
148 | if err != nil {
149 | log.Error("getting indexers", "error", err.Error())
150 | return []Indexer{}
151 | }
152 |
153 | if err := xml.Unmarshal(resp.Body(), &indexers); err != nil {
154 | log.Error("indexers", err)
155 | }
156 |
157 | neededIndexers := []Indexer{}
158 | for _, indexer := range indexers.Indexers {
159 | for _, category := range indexer.Caps.Categories.Category {
160 | if category.Name == cat {
161 | neededIndexers = append(neededIndexers, indexer)
162 | break
163 | }
164 | }
165 | }
166 | log.Info("indexers", "cat", cat, "total", len(indexers.Indexers), "needed", len(neededIndexers))
167 | return neededIndexers
168 | }
169 |
170 | func getTorrents(indexer Indexer, payload common.Payload) []common.Torrent {
171 | var rss common.Rss
172 | t := "search"
173 | q := ""
174 | season := ""
175 | ep := ""
176 | traktid := ""
177 | imdbid := ""
178 | tvdbid := ""
179 | tmdbid := ""
180 |
181 | if indexer.SearchAvailable() {
182 | q = payload.Title + "+" + payload.Year
183 | if payload.Type == "episode" {
184 | q = payload.ShowTitle
185 | }
186 | }
187 |
188 | if indexer.MovieSearchAvailable() && payload.Type == "movie" {
189 | t = "movie"
190 | if indexer.HasMovieParam("imdbid") {
191 | imdbid = payload.Imdb
192 | }
193 | if indexer.HasMovieParam("traktid") {
194 | traktid = payload.Trakt
195 | }
196 | }
197 | if indexer.TvSearchAvailable() && payload.Type == "episode" {
198 | t = "tvsearch"
199 | if indexer.HasTvParam("imdbid") {
200 | imdbid = payload.EpisodeImdb
201 | }
202 | if indexer.HasTvParam("tvdbid") {
203 | tvdbid = payload.EpisodeTvdb
204 | }
205 | if indexer.HasTvParam("season") {
206 | q = payload.ShowTitle
207 | season = payload.SeasonNumber
208 | }
209 | if indexer.HasTvParam("ep") {
210 | q = payload.ShowTitle
211 | ep = payload.EpisodeNumber
212 | }
213 |
214 | if indexer.HasTvParam("traktid") {
215 | traktid = payload.Trakt
216 | }
217 |
218 | }
219 |
220 | query := ""
221 | if q != "" {
222 | query = "&q=" + q
223 | }
224 | if imdbid != "" {
225 | query = query + "&imdbid=" + imdbid
226 | }
227 |
228 | if tvdbid != "" {
229 | query = query + "&tvdbid=" + tvdbid
230 | }
231 |
232 | if tmdbid != "" {
233 | query = query + "&tmdbid=" + tmdbid
234 | }
235 |
236 | if season != "" {
237 | query = query + "&season=" + season
238 | }
239 |
240 | if ep != "" {
241 | query = query + "&ep=" + ep
242 | }
243 |
244 | if traktid != "" {
245 | query = query + "&traktid=" + traktid
246 | }
247 |
248 | var torrents []common.Torrent
249 |
250 | request := resty.New().
251 | // SetRetryCount(1).
252 | SetTimeout(time.Second * 60).
253 | // SetRetryWaitTime(time.Second * 2).
254 | R()
255 |
256 | jackettUrl := os.Getenv("JACKETT_URL")
257 | jackettKey := os.Getenv("JACKETT_KEY")
258 |
259 | url := fmt.Sprintf(
260 | "%s/api/v2.0/indexers/%s/results/torznab/api?apikey=%s&t=%s%s",
261 | jackettUrl,
262 | indexer.Id,
263 | jackettKey,
264 | t,
265 | query,
266 | )
267 | resp, err := request.Get(url)
268 | if err != nil {
269 | log.Error("get request", "indexer", indexer.Id, "error", err.Error())
270 | return torrents
271 | }
272 |
273 | if err := xml.Unmarshal(resp.Body(), &rss); err != nil {
274 | if err.Error() != "EOF" {
275 | log.Error("xml unmarshall", "indexer", indexer.Id, "error", err.Error())
276 | }
277 | return torrents
278 | }
279 |
280 | for _, item := range rss.Channel.Items {
281 | t := common.Torrent{}
282 | t.Scraper = indexer.Id
283 | t.Size = uint64(item.Size)
284 | t.ReleaseTitle = item.Title
285 | infos, q := common.GetInfos(item.Title)
286 | t.Info = infos
287 | t.Quality = q
288 | t.Name = item.Title
289 | for _, attr := range item.Attrs {
290 | if attr.Name == "magneturl" {
291 | t.Magnet = common.SimplifyMagnet(attr.Value)
292 | }
293 | if attr.Name == "infohash" {
294 | t.Hash = attr.Value
295 | }
296 | if attr.Name == "seeders" {
297 | c, err := strconv.Atoi(attr.Value)
298 | if err == nil {
299 | t.Seeds = uint64(c)
300 | }
301 | }
302 | }
303 | if t.Magnet != "" {
304 | log.Debug("Torrent", "hash", t.Hash, "name", t.Name)
305 | torrents = append(torrents, t)
306 | }
307 | }
308 |
309 | return torrents
310 | }
311 |
--------------------------------------------------------------------------------
/apps/backend/indexer/prowlarr/prowlarr.go:
--------------------------------------------------------------------------------
1 | // WIP - probably won't use
2 |
3 | package prowlarr
4 |
5 | import (
6 | "fmt"
7 | "net/url"
8 | "os"
9 | "strings"
10 | "sync"
11 | "time"
12 |
13 | "github.com/odin-movieshow/backend/common"
14 |
15 | "github.com/charmbracelet/log"
16 | "github.com/go-resty/resty/v2"
17 | "github.com/thoas/go-funk"
18 | )
19 |
20 | type Indexer struct {
21 | Id uint32 `json:"id"`
22 | Title string `json:"name"`
23 | Caps struct {
24 | SupportsRawSearch bool `json:"supportsRawSearch"`
25 | SearchParams []string `json:"searchParams"`
26 | MovieSearchParams []string `json:"movieSearchParams"`
27 | TvSearchParams []string `json:"tvSearchParams"`
28 | Categories []struct {
29 | ID uint32 `json:"id"`
30 | Name string `json:"name"`
31 | } `json:"categories"`
32 | } `json:"capabilities"`
33 | }
34 |
35 | func (indexer *Indexer) SearchAvailable() bool {
36 | return indexer.Caps.SupportsRawSearch
37 | }
38 |
39 | func (indexer *Indexer) MovieSearchAvailable() bool {
40 | return indexer.Caps.MovieSearchParams != nil && len(indexer.Caps.MovieSearchParams) > 0
41 | }
42 |
43 | func (indexer *Indexer) TvSearchAvailable() bool {
44 | return indexer.Caps.TvSearchParams != nil && len(indexer.Caps.TvSearchParams) > 0
45 | }
46 |
47 | func (indexer *Indexer) HasMovieParam(param string) bool {
48 | return indexer.MovieSearchAvailable() && funk.Contains(indexer.Caps.MovieSearchParams, param)
49 | }
50 |
51 | func (indexer *Indexer) HasTvParam(param string) bool {
52 | return indexer.TvSearchAvailable() && funk.Contains(indexer.Caps.TvSearchParams, param)
53 | }
54 |
55 | func Search(payload common.Payload) {
56 | payload.Title = url.QueryEscape(common.Strip(payload.Title))
57 | payload.EpisodeTitle = url.QueryEscape(common.Strip(payload.EpisodeTitle))
58 | payload.ShowTitle = url.QueryEscape(common.Strip(payload.ShowTitle))
59 |
60 | indexers := getIndexerList(payload)
61 |
62 | allTorrents := []common.Torrent{}
63 | l := log.Warn
64 | wg := sync.WaitGroup{}
65 | for _, indexer := range indexers {
66 | wg.Add(1)
67 | go func(indexer Indexer) {
68 | defer wg.Done()
69 | t1 := time.Now()
70 | ts := getTorrents(indexer, payload)
71 | t2 := time.Now()
72 | if len(ts) > 0 {
73 | l = log.Info
74 | }
75 | l(
76 | "indexer",
77 | "id",
78 | indexer.Title,
79 | "torrents",
80 | len(ts),
81 | "took",
82 | fmt.Sprintf("%.1fs", t2.Sub(t1).Seconds()),
83 | )
84 | allTorrents = append(allTorrents, ts...)
85 | }(indexer)
86 | }
87 |
88 | wg.Wait()
89 | }
90 |
91 | func getIndexerList(payload common.Payload) []Indexer {
92 | cat := "Movies"
93 |
94 | prowlarrUrl := os.Getenv("PROWLARR_URL")
95 | prowlarrKey := os.Getenv("PROWLARR_KEY")
96 |
97 | if payload.Type == "episode" {
98 | cat = "TV"
99 | }
100 | var indexers []Indexer
101 |
102 | request := resty.New().
103 | SetRetryCount(3).
104 | SetTimeout(time.Second * 30).
105 | SetRetryWaitTime(time.Second * 2).
106 | R()
107 | _, err := request.SetResult(&indexers).Get(
108 | fmt.Sprintf(
109 | "%s/api/v1/indexer?apikey=%s&t=indexers&configured=true",
110 | prowlarrUrl,
111 | prowlarrKey,
112 | ),
113 | )
114 | if err != nil {
115 | log.Error("getting indexers", "error", err.Error())
116 | return []Indexer{}
117 | }
118 | neededIndexers := []Indexer{}
119 | for _, indexer := range indexers {
120 | for _, category := range indexer.Caps.Categories {
121 | if category.Name == cat {
122 | neededIndexers = append(neededIndexers, indexer)
123 | break
124 | }
125 | }
126 | }
127 |
128 | log.Info("indexers", "cat", cat, "total", len(indexers), "needed", len(neededIndexers))
129 |
130 | return neededIndexers
131 | }
132 |
133 | func getTorrents(indexer Indexer, payload common.Payload) []common.Torrent {
134 | // var rss common.Rss
135 | t := "search"
136 | q := ""
137 | season := ""
138 | ep := ""
139 | traktid := ""
140 | imdbid := ""
141 | tvdbid := ""
142 | tmdbid := ""
143 | if indexer.SearchAvailable() {
144 | q = payload.Title + "+" + payload.Year
145 | if payload.Type == "episode" {
146 | q = payload.ShowTitle + "+S" + payload.SeasonNumber + "+E" + payload.EpisodeNumber
147 | }
148 | }
149 |
150 | if indexer.MovieSearchAvailable() && payload.Type == "movie" {
151 | t = "movie"
152 | if indexer.HasMovieParam("imdbid") {
153 | imdbid = payload.Imdb
154 | }
155 | if indexer.HasMovieParam("traktid") {
156 | traktid = payload.Trakt
157 | }
158 | }
159 | if indexer.TvSearchAvailable() && payload.Type == "episode" {
160 | t = "tvsearch"
161 | if indexer.HasTvParam("imdbid") {
162 | imdbid = payload.EpisodeImdb
163 | }
164 | if indexer.HasTvParam("tvdbid") {
165 | tvdbid = payload.EpisodeTvdb
166 | }
167 | if indexer.HasTvParam("season") {
168 | // q = payload.ShowTitle
169 | season = payload.SeasonNumber
170 | }
171 | if indexer.HasTvParam("ep") {
172 | // q = payload.ShowTitle
173 | ep = payload.EpisodeNumber
174 | }
175 |
176 | if indexer.HasTvParam("traktid") {
177 | traktid = payload.Trakt
178 | }
179 |
180 | }
181 |
182 | query := "&t=" + t
183 | if q != "" {
184 | query = "&query=" + q
185 | }
186 | if imdbid != "" {
187 | query = query + "&imdbid=" + imdbid
188 | }
189 |
190 | if tvdbid != "" {
191 | query = query + "&tvdbid=" + tvdbid
192 | }
193 |
194 | if tmdbid != "" {
195 | query = query + "&tmdbid=" + tmdbid
196 | }
197 |
198 | if season != "" {
199 | query = query + "&season=" + season
200 | }
201 |
202 | if ep != "" {
203 | query = query + "&ep=" + ep
204 | }
205 |
206 | if traktid != "" {
207 | query = query + "&traktid=" + traktid
208 | }
209 |
210 | torrents := []common.Torrent{}
211 |
212 | request := resty.New().
213 | // SetRetryCount(1).
214 | SetTimeout(time.Second * 30).
215 | // SetRetryWaitTime(time.Second * 2).
216 | R()
217 |
218 | prowlarrUrl := os.Getenv("PROWLARR_URL")
219 | prowlarrKey := os.Getenv("PROWLARR_KEY")
220 |
221 | url := fmt.Sprintf(
222 | "%s/api/v1/search?apikey=%s&indexerId=%d%s",
223 | prowlarrUrl,
224 | prowlarrKey,
225 | indexer.Id,
226 | query,
227 | )
228 |
229 | log.Info(url)
230 |
231 | type Res struct {
232 | Title string `json:"title"`
233 | Seeders uint64 `json:"seeders"`
234 | DownloadUrl string `json:"downloadUrl"`
235 | Indexer string `json:"indexer"`
236 | Size uint32 `json:"size"`
237 | }
238 |
239 | res := []Res{}
240 | _, err := request.SetResult(&res).Get(url)
241 | if err != nil {
242 | log.Error("get request", "indexer", indexer.Id, "error", err.Error())
243 | return torrents
244 | }
245 |
246 | wg := sync.WaitGroup{}
247 |
248 | for _, item := range res {
249 |
250 | wg.Add(1)
251 | go func(item Res, indexer *Indexer, wg *sync.WaitGroup, torrents *[]common.Torrent) {
252 | defer wg.Done()
253 | t := common.Torrent{}
254 | t.Scraper = indexer.Title
255 | t.Size = uint64(item.Size)
256 | t.ReleaseTitle = item.Title
257 | infos, q := common.GetInfos(item.Title)
258 | t.Info = infos
259 | t.Quality = q
260 |
261 | r := resty.New().
262 | SetTimeout(time.Second * 10).
263 | SetRedirectPolicy(resty.FlexibleRedirectPolicy(0)).
264 | R()
265 | magnet := ""
266 | resp, err := r.Get(item.DownloadUrl)
267 | // log.Debug(resp.Request.URL)
268 | if err == nil {
269 | }
270 |
271 | l := resp.Header().Get("Location")
272 | if strings.Contains(l, "magnet") {
273 | magnet = l
274 | }
275 |
276 | t.Name = item.Title
277 | t.Magnet = magnet
278 | t.Hash = magnet
279 | t.Seeds = item.Seeders
280 | *torrents = append(*torrents, t)
281 | }(
282 | item,
283 | &indexer,
284 | &wg,
285 | &torrents,
286 | )
287 |
288 | }
289 |
290 | wg.Wait()
291 |
292 | return torrents
293 | }
294 |
--------------------------------------------------------------------------------
/apps/backend/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "net/http"
7 | "os"
8 | "strconv"
9 | "strings"
10 | "sync"
11 | "time"
12 |
13 | "github.com/charmbracelet/log"
14 | "github.com/joho/godotenv"
15 | "github.com/odin-movieshow/backend/cache"
16 | "github.com/odin-movieshow/backend/common"
17 | "github.com/odin-movieshow/backend/downloader/alldebrid"
18 | "github.com/odin-movieshow/backend/downloader/realdebrid"
19 | "github.com/odin-movieshow/backend/helpers"
20 | "github.com/odin-movieshow/backend/imdb"
21 | "github.com/odin-movieshow/backend/scraper"
22 | "github.com/odin-movieshow/backend/settings"
23 | "github.com/odin-movieshow/backend/tmdb"
24 | "github.com/odin-movieshow/backend/trakt"
25 | "github.com/odin-movieshow/backend/types"
26 |
27 | "github.com/labstack/echo/v5"
28 | _ "github.com/odin-movieshow/backend/migrations"
29 | "github.com/pocketbase/dbx"
30 | "github.com/pocketbase/pocketbase"
31 | "github.com/pocketbase/pocketbase/apis"
32 | "github.com/pocketbase/pocketbase/core"
33 | "github.com/pocketbase/pocketbase/models"
34 | "github.com/pocketbase/pocketbase/plugins/migratecmd"
35 | "github.com/pocketbase/pocketbase/tools/cron"
36 | "github.com/thoas/go-funk"
37 | )
38 |
39 | func getDevice(app *pocketbase.PocketBase, c echo.Context) (*models.Record, error) {
40 | device := c.Request().Header.Get("Device")
41 | return app.Dao().FindRecordById("devices", device)
42 | }
43 |
44 | func getDeps() echo.MiddlewareFunc {
45 | return func(next echo.HandlerFunc) echo.HandlerFunc {
46 | return func(c echo.Context) error {
47 | return next(c)
48 | }
49 | }
50 | }
51 |
52 | func RequireDeviceOrRecordAuth(app *pocketbase.PocketBase) echo.MiddlewareFunc {
53 | mut := sync.RWMutex{}
54 | return func(next echo.HandlerFunc) echo.HandlerFunc {
55 | return func(c echo.Context) error {
56 | mut.Lock()
57 | record, _ := c.Get("authRecord").(*models.Record)
58 | mut.Unlock()
59 | if record == nil {
60 | d, _ := getDevice(app, c)
61 | if d != nil {
62 | if d.GetBool("verified") {
63 | u, err := app.Dao().FindRecordById("users", d.Get("user").(string))
64 | if err == nil {
65 | mut.Lock()
66 | c.Set("authRecord", u)
67 | mut.Unlock()
68 | }
69 | }
70 | }
71 | }
72 |
73 | if c.Get("authRecord") == nil {
74 | return apis.NewBadRequestError("Verified device code or Auth are required", nil)
75 | }
76 |
77 | return next(c)
78 | }
79 | }
80 | }
81 |
82 | func getVersion() string {
83 | b, err := os.ReadFile("./version.txt")
84 | if err == nil {
85 | v := string(b)
86 | v = strings.ReplaceAll(v, "\n", "")
87 | return v
88 | }
89 |
90 | return "Missing file: version.txt"
91 | }
92 |
93 | func main() {
94 | godotenv.Load()
95 |
96 | log.SetReportCaller(true)
97 | l, err := log.ParseLevel(os.Getenv("LOG_LEVEL"))
98 |
99 | if err == nil {
100 | log.SetLevel(l)
101 | } else {
102 | log.SetLevel(log.InfoLevel)
103 | }
104 |
105 | conf := pocketbase.Config{DefaultDev: true}
106 | app := pocketbase.NewWithConfig(conf)
107 | migratecmd.MustRegister(app, app.RootCmd, migratecmd.Config{
108 | Automigrate: true,
109 | })
110 |
111 | app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
112 | settings := settings.New(app)
113 | cache := cache.New(app)
114 | helpers := helpers.New(app)
115 | tmdb := tmdb.New(settings, cache)
116 | trakt := trakt.New(app, tmdb, settings, cache)
117 | realdebrid := realdebrid.New(app, settings)
118 | alldebrid := alldebrid.New(app, settings)
119 | scraper := scraper.New(app, settings, cache, helpers, realdebrid, alldebrid)
120 |
121 | date := time.Now()
122 |
123 | email := "admin@odin.local"
124 | if os.Getenv("ADMIN_EMAIL") != "" {
125 | email = os.Getenv("ADMIN_EMAIL")
126 | }
127 |
128 | password := "odinAdmin1"
129 | if os.Getenv("ADMIN_PASSWORD") != "" {
130 | password = os.Getenv("ADMIN_PASSWORD")
131 | }
132 |
133 | a, _ := app.Dao().FindAdminByEmail(email)
134 | if a == nil {
135 | a = &models.Admin{Email: email}
136 | a.SetPassword(password)
137 | app.Dao().SaveAdmin(a)
138 | } else {
139 | a.SetPassword(password)
140 | app.Dao().SaveAdmin(a)
141 | }
142 |
143 | scheduler := cron.New()
144 | scheduler.MustAdd("hourly", "0 * * * *", func() {
145 | trakt.RefreshTokens()
146 | realdebrid.RefreshTokens()
147 | trakt.SyncHistory("")
148 | })
149 | scheduler.MustAdd("daily", "0 4 * * *", func() {
150 | realdebrid.Cleanup()
151 | })
152 | scheduler.Start()
153 |
154 | go func() {
155 | // trakt.SyncHistory()
156 | }()
157 |
158 | e.Router.POST("/-/scrape", func(c echo.Context) error {
159 | mq := common.MqttClient()
160 | var pl common.Payload
161 | log.Debug("Scraping")
162 | c.Bind(&pl)
163 | log.Debug(pl)
164 | go func() {
165 | scraper.GetLinks(pl, mq)
166 | }()
167 | return c.JSON(http.StatusOK, map[string]string{"status": "ok"})
168 | }, RequireDeviceOrRecordAuth(app))
169 |
170 | e.Router.GET("/-/imdb/:id", func(c echo.Context) error {
171 | id := c.PathParam("id")
172 | return c.JSON(http.StatusOK, imdb.Get(id))
173 | })
174 |
175 | e.Router.GET("/-/device/verify/:id/:name", func(c echo.Context) error {
176 | id := c.PathParam("id")
177 | name := c.PathParam("name")
178 | d, err := app.Dao().FindRecordById("devices", id)
179 | if err != nil {
180 | return c.JSON(http.StatusNotFound, nil)
181 | }
182 | uid := d.Get("user").(string)
183 | u, err := app.Dao().FindRecordById("users", uid)
184 | if err != nil {
185 | return c.JSON(http.StatusNotFound, nil)
186 | }
187 | d.Set("verified", true)
188 | d.Set("name", name)
189 | app.Dao().SaveRecord(d)
190 | log.Info("Device verified", "id", id)
191 | return c.JSON(http.StatusOK, u)
192 | }, apis.RequireGuestOnly())
193 |
194 | e.Router.GET("/-/user", func(c echo.Context) error {
195 | u := c.Get("authRecord")
196 | sections := make(map[string]any)
197 | err := u.(*models.Record).UnmarshalJSONField("trakt_sections", §ions)
198 |
199 | if err == nil {
200 | for _, t := range []string{"home", "movies", "shows"} {
201 | s := sections[t].([]any)
202 | for i := range s {
203 | title := common.ParseDates(sections[t].([]any)[i].(map[string]any)["title"].(string))
204 | url := common.ParseDates(sections[t].([]any)[i].(map[string]any)["url"].(string))
205 | sections[t].([]any)[i].(map[string]any)["title"] = title
206 | sections[t].([]any)[i].(map[string]any)["url"] = url
207 | }
208 |
209 | }
210 |
211 | str, err := json.Marshal(sections)
212 | if err == nil {
213 | u.(*models.Record).Set("trakt_sections", string(str))
214 | }
215 | }
216 |
217 | return c.JSON(http.StatusOK, u)
218 | }, RequireDeviceOrRecordAuth(app))
219 |
220 | e.Router.GET("/-/refreshHistory", func(c echo.Context) error {
221 | info := apis.RequestInfo(c)
222 | id := info.AuthRecord.Id
223 |
224 | q := app.Dao().DB().Delete("history", dbx.NewExp("user = {:user}", dbx.Params{"user": id}))
225 | q.Execute()
226 |
227 | trakt.SyncHistory(id)
228 |
229 | // q := app.Dao().DB().NewQuery("DELETE FROM history WHERE user = {:user}").Bind(dbx.Params{"user": id})
230 |
231 | return c.String(http.StatusOK, "OK")
232 | }, RequireDeviceOrRecordAuth(app))
233 |
234 | e.Router.Any("/-/trakt/*", func(c echo.Context) error {
235 | info := apis.RequestInfo(c)
236 |
237 | id := info.AuthRecord.Id
238 | url := strings.ReplaceAll(c.Request().URL.String(), "/-/trakt", "")
239 |
240 | t := make(map[string]any)
241 | u, _ := app.Dao().FindRecordById("users", id)
242 | u.UnmarshalJSONField("trakt_token", &t)
243 | // delete(trakt.Headers, "authorization")
244 | //
245 | theaders := map[string]string{}
246 |
247 | if t != nil && t["access_token"] != nil {
248 | theaders["authorization"] = "Bearer " + t["access_token"].(string)
249 | }
250 | if strings.Contains(url, "fresh=true") {
251 | delete(theaders, "authorization")
252 | }
253 |
254 | jsonData := apis.RequestInfo(c).Data
255 |
256 | if strings.Contains(url, "scrobble/stop") {
257 | go func() {
258 | trakt.SyncHistory(id)
259 | }()
260 | }
261 | url = common.ParseDates(url)
262 | result, headers, status := trakt.CallEndpoint(
263 | url,
264 | c.Request().Method,
265 | types.TraktParams{
266 | Body: jsonData,
267 | Donorm: true,
268 | Headers: theaders,
269 | FetchTMDB: true,
270 | },
271 | )
272 |
273 | for k, v := range headers {
274 | if funk.Contains([]string{
275 | "Content-Encoding",
276 | "Access-Control-Allow-Origin",
277 | }, k) {
278 | continue
279 | }
280 | c.Response().Header().Add(k, v[0])
281 | }
282 | c.Response().Status = status
283 |
284 | return c.JSON(http.StatusOK, result)
285 | }, RequireDeviceOrRecordAuth(app))
286 |
287 | e.Router.Any("/-/realdebrid/*", func(c echo.Context) error {
288 | url := strings.ReplaceAll(c.Request().URL.String(), "/-/realdebrid", "")
289 | var result interface{}
290 | var headers http.Header
291 | isAuth := false
292 | status := 0
293 | if strings.Contains(url, "/isAuth") {
294 | url = strings.ReplaceAll(url, "/isAuth", "")
295 | isAuth = true
296 | }
297 |
298 | data := apis.RequestInfo(c).Data
299 |
300 | var body map[string]string
301 | if data != nil {
302 | jm, err := json.Marshal(data)
303 | log.Debug(string(jm))
304 | if err == nil {
305 | err := json.Unmarshal(jm, &body)
306 | if err != nil {
307 | log.Warn(body)
308 | }
309 | }
310 | }
311 |
312 | headers, status = realdebrid.CallEndpoint(url, c.Request().Method, body, &result, isAuth)
313 |
314 | for k, v := range headers {
315 | if funk.Contains([]string{
316 | "Content-Encoding",
317 | "Access-Control-Allow-Origin",
318 | }, k) {
319 | continue
320 | }
321 | c.Response().Header().Add(k, v[0])
322 | }
323 | c.Response().Status = status
324 | return c.JSON(http.StatusOK, result)
325 | }, apis.RequireAdminAuth())
326 |
327 | e.Router.Any("/-/alldebrid/*", func(c echo.Context) error {
328 | url := strings.ReplaceAll(c.Request().URL.String(), "/-/alldebrid", "")
329 | var result interface{}
330 | headers, status := alldebrid.CallEndpoint(url, c.Request().Method, nil, &result)
331 |
332 | for k, v := range headers {
333 | if funk.Contains([]string{
334 | "Content-Encoding",
335 | "Access-Control-Allow-Origin",
336 | }, k) {
337 | continue
338 | }
339 | c.Response().Header().Add(k, v[0])
340 | }
341 | c.Response().Status = status
342 | return c.JSON(http.StatusOK, result)
343 | }, apis.RequireAdminAuth())
344 |
345 | e.Router.GET("/-/traktseasons/:id", func(c echo.Context) error {
346 | fmt.Println(c.PathParam("id"))
347 | id, _ := strconv.Atoi(c.PathParam("id"))
348 | res := trakt.GetSeasons(id)
349 | return c.JSON(http.StatusOK, res)
350 | }, RequireDeviceOrRecordAuth(app))
351 |
352 | e.Router.GET("/-/secrets", func(c echo.Context) error {
353 | return c.JSON(http.StatusOK, map[string]string{"TRAKT_CLIENTID": os.Getenv("TRAKT_CLIENTID"), "TRAKT_SECRET": os.Getenv("TRAKT_SECRET")})
354 | })
355 |
356 | e.Router.GET("/-/health", func(c echo.Context) error {
357 | ping := c.QueryParam("ping")
358 | if ping != "" {
359 | return c.String(http.StatusOK, "pong")
360 | }
361 |
362 | info := apis.RequestInfo(c)
363 |
364 | id := info.AuthRecord.Id
365 |
366 | t := make(map[string]any)
367 | u, _ := app.Dao().FindRecordById("users", id)
368 | u.UnmarshalJSONField("trakt_token", &t)
369 | // delete(trakt.Headers, "authorization")
370 | //
371 | theaders := map[string]string{}
372 |
373 | if t != nil && t["access_token"] != nil {
374 | theaders["authorization"] = "Bearer " + t["access_token"].(string)
375 | }
376 |
377 | var rd any
378 | realdebrid.CallEndpoint("/user", "GET", nil, &rd, false)
379 | var ad any
380 | alldebrid.CallEndpoint("/user", "GET", nil, &ad)
381 | tr, _, _ := trakt.CallEndpoint("/users/settings", "GET", types.TraktParams{Headers: theaders})
382 | return c.JSON(http.StatusOK, map[string]any{"realdebrid": rd, "alldebrid": ad, "trakt": tr, "version": getVersion(), "date": date})
383 | }, RequireDeviceOrRecordAuth(app))
384 |
385 | e.Router.GET("/-/tmdbseasons/:id", func(c echo.Context) error {
386 | fmt.Println(c.PathParam("id"))
387 | seasons := c.QueryParam("seasons")
388 | res := tmdb.GetEpisodes(c.PathParam("id"), strings.Split(seasons, ","))
389 | return c.JSON(http.StatusOK, res)
390 | }, RequireDeviceOrRecordAuth(app))
391 |
392 | return nil
393 | })
394 |
395 | if err := app.Start(); err != nil {
396 | log.Fatal(err)
397 | }
398 | }
399 |
--------------------------------------------------------------------------------
/apps/backend/migrations/1735493885_collections_snapshot.go:
--------------------------------------------------------------------------------
1 | package migrations
2 |
3 | import (
4 | "encoding/json"
5 |
6 | "github.com/pocketbase/dbx"
7 | "github.com/pocketbase/pocketbase/daos"
8 | m "github.com/pocketbase/pocketbase/migrations"
9 | "github.com/pocketbase/pocketbase/models"
10 | )
11 |
12 | func init() {
13 | m.Register(func(db dbx.Builder) error {
14 | jsonData := `[
15 | {
16 | "id": "_pb_users_auth_",
17 | "created": "2023-12-15 18:30:15.247Z",
18 | "updated": "2023-12-24 21:24:28.471Z",
19 | "name": "users",
20 | "type": "auth",
21 | "system": false,
22 | "schema": [
23 | {
24 | "system": false,
25 | "id": "users_name",
26 | "name": "name",
27 | "type": "text",
28 | "required": false,
29 | "presentable": false,
30 | "unique": false,
31 | "options": {
32 | "min": null,
33 | "max": null,
34 | "pattern": ""
35 | }
36 | },
37 | {
38 | "system": false,
39 | "id": "users_avatar",
40 | "name": "avatar",
41 | "type": "file",
42 | "required": false,
43 | "presentable": false,
44 | "unique": false,
45 | "options": {
46 | "mimeTypes": [
47 | "image/jpeg",
48 | "image/png",
49 | "image/svg+xml",
50 | "image/gif",
51 | "image/webp"
52 | ],
53 | "thumbs": null,
54 | "maxSelect": 1,
55 | "maxSize": 5242880,
56 | "protected": false
57 | }
58 | },
59 | {
60 | "system": false,
61 | "id": "ebrrsidx",
62 | "name": "trakt_sections",
63 | "type": "json",
64 | "required": false,
65 | "presentable": false,
66 | "unique": false,
67 | "options": {
68 | "maxSize": 2000000
69 | }
70 | },
71 | {
72 | "system": false,
73 | "id": "hpy6zodi",
74 | "name": "trakt_token",
75 | "type": "json",
76 | "required": false,
77 | "presentable": false,
78 | "unique": false,
79 | "options": {
80 | "maxSize": 2000000
81 | }
82 | }
83 | ],
84 | "indexes": [],
85 | "listRule": "id = @request.auth.id",
86 | "viewRule": "id = @request.auth.id",
87 | "createRule": null,
88 | "updateRule": "id = @request.auth.id",
89 | "deleteRule": "id = @request.auth.id",
90 | "options": {
91 | "allowEmailAuth": true,
92 | "allowOAuth2Auth": true,
93 | "allowUsernameAuth": true,
94 | "exceptEmailDomains": null,
95 | "manageRule": null,
96 | "minPasswordLength": 8,
97 | "onlyEmailDomains": null,
98 | "onlyVerified": false,
99 | "requireEmail": false
100 | }
101 | },
102 | {
103 | "id": "kog9lz3zq2kj07s",
104 | "created": "2023-12-15 18:32:16.845Z",
105 | "updated": "2024-12-25 07:47:18.193Z",
106 | "name": "settings",
107 | "type": "base",
108 | "system": false,
109 | "schema": [
110 | {
111 | "system": false,
112 | "id": "qcycymzs",
113 | "name": "app",
114 | "type": "json",
115 | "required": false,
116 | "presentable": false,
117 | "unique": false,
118 | "options": {
119 | "maxSize": 2000000
120 | }
121 | },
122 | {
123 | "system": false,
124 | "id": "wfnmmcoj",
125 | "name": "real_debrid",
126 | "type": "json",
127 | "required": false,
128 | "presentable": false,
129 | "unique": false,
130 | "options": {
131 | "maxSize": 2000000
132 | }
133 | }
134 | ],
135 | "indexes": [],
136 | "listRule": "@request.auth.id != \"\"",
137 | "viewRule": "@request.auth.id != \"\"",
138 | "createRule": null,
139 | "updateRule": null,
140 | "deleteRule": null,
141 | "options": {}
142 | },
143 | {
144 | "id": "uvaxc6sfjgaxw9c",
145 | "created": "2023-12-15 18:34:04.439Z",
146 | "updated": "2024-11-03 08:06:04.441Z",
147 | "name": "tmdb",
148 | "type": "base",
149 | "system": false,
150 | "schema": [
151 | {
152 | "system": false,
153 | "id": "txaj4w1q",
154 | "name": "data",
155 | "type": "json",
156 | "required": false,
157 | "presentable": false,
158 | "unique": false,
159 | "options": {
160 | "maxSize": 2000000
161 | }
162 | },
163 | {
164 | "system": false,
165 | "id": "5e3mgwxm",
166 | "name": "type",
167 | "type": "select",
168 | "required": false,
169 | "presentable": false,
170 | "unique": false,
171 | "options": {
172 | "maxSelect": 1,
173 | "values": [
174 | "movie",
175 | "show"
176 | ]
177 | }
178 | },
179 | {
180 | "system": false,
181 | "id": "0li9qnvg",
182 | "name": "tmdb_id",
183 | "type": "number",
184 | "required": false,
185 | "presentable": false,
186 | "unique": false,
187 | "options": {
188 | "min": null,
189 | "max": null,
190 | "noDecimal": false
191 | }
192 | }
193 | ],
194 | "indexes": [
195 | "CREATE INDEX ` + "`" + `idx_1ir7EEI` + "`" + ` ON ` + "`" + `tmdb` + "`" + ` (` + "`" + `id` + "`" + `)",
196 | "CREATE INDEX ` + "`" + `idx_eWT8ulS` + "`" + ` ON ` + "`" + `tmdb` + "`" + ` (` + "`" + `tmdb_id` + "`" + `)",
197 | "CREATE INDEX ` + "`" + `idx_7QPyCnz` + "`" + ` ON ` + "`" + `tmdb` + "`" + ` (` + "`" + `type` + "`" + `)"
198 | ],
199 | "listRule": null,
200 | "viewRule": null,
201 | "createRule": null,
202 | "updateRule": null,
203 | "deleteRule": null,
204 | "options": {}
205 | },
206 | {
207 | "id": "jib32sgrokndtt2",
208 | "created": "2023-12-20 14:59:04.811Z",
209 | "updated": "2023-12-20 16:23:08.540Z",
210 | "name": "history",
211 | "type": "base",
212 | "system": false,
213 | "schema": [
214 | {
215 | "system": false,
216 | "id": "xfytwctq",
217 | "name": "user",
218 | "type": "relation",
219 | "required": false,
220 | "presentable": false,
221 | "unique": false,
222 | "options": {
223 | "collectionId": "_pb_users_auth_",
224 | "cascadeDelete": false,
225 | "minSelect": null,
226 | "maxSelect": 1,
227 | "displayFields": null
228 | }
229 | },
230 | {
231 | "system": false,
232 | "id": "axymvzt6",
233 | "name": "data",
234 | "type": "json",
235 | "required": false,
236 | "presentable": false,
237 | "unique": false,
238 | "options": {
239 | "maxSize": 2000000
240 | }
241 | },
242 | {
243 | "system": false,
244 | "id": "vv5en8cb",
245 | "name": "type",
246 | "type": "select",
247 | "required": false,
248 | "presentable": false,
249 | "unique": false,
250 | "options": {
251 | "maxSelect": 1,
252 | "values": [
253 | "movie",
254 | "episode"
255 | ]
256 | }
257 | },
258 | {
259 | "system": false,
260 | "id": "293urao6",
261 | "name": "trakt_id",
262 | "type": "number",
263 | "required": false,
264 | "presentable": false,
265 | "unique": false,
266 | "options": {
267 | "min": null,
268 | "max": null,
269 | "noDecimal": false
270 | }
271 | },
272 | {
273 | "system": false,
274 | "id": "spgro5mw",
275 | "name": "watched_at",
276 | "type": "date",
277 | "required": false,
278 | "presentable": false,
279 | "unique": false,
280 | "options": {
281 | "min": "",
282 | "max": ""
283 | }
284 | },
285 | {
286 | "system": false,
287 | "id": "09ahphxh",
288 | "name": "runtime",
289 | "type": "number",
290 | "required": false,
291 | "presentable": false,
292 | "unique": false,
293 | "options": {
294 | "min": null,
295 | "max": null,
296 | "noDecimal": false
297 | }
298 | },
299 | {
300 | "system": false,
301 | "id": "xeh8twko",
302 | "name": "show_id",
303 | "type": "number",
304 | "required": false,
305 | "presentable": false,
306 | "unique": false,
307 | "options": {
308 | "min": null,
309 | "max": null,
310 | "noDecimal": false
311 | }
312 | }
313 | ],
314 | "indexes": [
315 | "CREATE INDEX ` + "`" + `idx_SHZ0Jzt` + "`" + ` ON ` + "`" + `history` + "`" + ` (` + "`" + `show_id` + "`" + `)",
316 | "CREATE INDEX ` + "`" + `idx_WaWH7nI` + "`" + ` ON ` + "`" + `history` + "`" + ` (` + "`" + `trakt_id` + "`" + `)"
317 | ],
318 | "listRule": "user.id = @request.auth.id",
319 | "viewRule": "user.id = @request.auth.id",
320 | "createRule": "",
321 | "updateRule": null,
322 | "deleteRule": null,
323 | "options": {}
324 | },
325 | {
326 | "id": "gy7oibx0bg0num2",
327 | "created": "2023-12-21 16:39:00.621Z",
328 | "updated": "2023-12-21 17:11:57.884Z",
329 | "name": "devices",
330 | "type": "base",
331 | "system": false,
332 | "schema": [
333 | {
334 | "system": false,
335 | "id": "17ici2x4",
336 | "name": "user",
337 | "type": "relation",
338 | "required": false,
339 | "presentable": false,
340 | "unique": false,
341 | "options": {
342 | "collectionId": "_pb_users_auth_",
343 | "cascadeDelete": false,
344 | "minSelect": null,
345 | "maxSelect": 1,
346 | "displayFields": null
347 | }
348 | },
349 | {
350 | "system": false,
351 | "id": "iy8rm0eq",
352 | "name": "token",
353 | "type": "text",
354 | "required": false,
355 | "presentable": false,
356 | "unique": false,
357 | "options": {
358 | "min": null,
359 | "max": null,
360 | "pattern": ""
361 | }
362 | },
363 | {
364 | "system": false,
365 | "id": "xqkkkixs",
366 | "name": "verified",
367 | "type": "bool",
368 | "required": false,
369 | "presentable": false,
370 | "unique": false,
371 | "options": {}
372 | },
373 | {
374 | "system": false,
375 | "id": "u20rxpwn",
376 | "name": "name",
377 | "type": "text",
378 | "required": false,
379 | "presentable": false,
380 | "unique": false,
381 | "options": {
382 | "min": null,
383 | "max": null,
384 | "pattern": ""
385 | }
386 | }
387 | ],
388 | "indexes": [
389 | "CREATE INDEX ` + "`" + `idx_Q19a20R` + "`" + ` ON ` + "`" + `devices` + "`" + ` (` + "`" + `user` + "`" + `)",
390 | "CREATE INDEX ` + "`" + `idx_JuaFpI7` + "`" + ` ON ` + "`" + `devices` + "`" + ` (` + "`" + `token` + "`" + `)",
391 | "CREATE INDEX ` + "`" + `idx_7TjpMBM` + "`" + ` ON ` + "`" + `devices` + "`" + ` (\n ` + "`" + `user` + "`" + `,\n ` + "`" + `token` + "`" + `\n)"
392 | ],
393 | "listRule": "user.id = @request.auth.id",
394 | "viewRule": "user.id = @request.auth.id",
395 | "createRule": "user.id = @request.auth.id",
396 | "updateRule": null,
397 | "deleteRule": null,
398 | "options": {}
399 | },
400 | {
401 | "id": "7n09aifcpshv459",
402 | "created": "2024-02-22 10:21:47.021Z",
403 | "updated": "2024-10-18 09:43:52.826Z",
404 | "name": "trakt_seasons",
405 | "type": "base",
406 | "system": false,
407 | "schema": [
408 | {
409 | "system": false,
410 | "id": "hjqjynor",
411 | "name": "data",
412 | "type": "json",
413 | "required": false,
414 | "presentable": false,
415 | "unique": false,
416 | "options": {
417 | "maxSize": 2000000
418 | }
419 | },
420 | {
421 | "system": false,
422 | "id": "uaatrqia",
423 | "name": "trakt_id",
424 | "type": "number",
425 | "required": false,
426 | "presentable": false,
427 | "unique": false,
428 | "options": {
429 | "min": null,
430 | "max": null,
431 | "noDecimal": false
432 | }
433 | }
434 | ],
435 | "indexes": [
436 | "CREATE INDEX ` + "`" + `idx_O92766T` + "`" + ` ON ` + "`" + `trakt_seasons` + "`" + ` (` + "`" + `trakt_id` + "`" + `)"
437 | ],
438 | "listRule": null,
439 | "viewRule": null,
440 | "createRule": null,
441 | "updateRule": null,
442 | "deleteRule": null,
443 | "options": {}
444 | },
445 | {
446 | "id": "n434wzwv45po9ib",
447 | "created": "2024-10-18 09:42:49.313Z",
448 | "updated": "2024-10-18 11:54:29.844Z",
449 | "name": "rd_resolved",
450 | "type": "base",
451 | "system": false,
452 | "schema": [
453 | {
454 | "system": false,
455 | "id": "pyyh9opk",
456 | "name": "resource",
457 | "type": "text",
458 | "required": false,
459 | "presentable": false,
460 | "unique": false,
461 | "options": {
462 | "min": null,
463 | "max": null,
464 | "pattern": ""
465 | }
466 | },
467 | {
468 | "system": false,
469 | "id": "kkyx6hfp",
470 | "name": "data",
471 | "type": "json",
472 | "required": false,
473 | "presentable": false,
474 | "unique": false,
475 | "options": {
476 | "maxSize": 2000000
477 | }
478 | },
479 | {
480 | "system": false,
481 | "id": "ncpi3amv",
482 | "name": "magnet",
483 | "type": "text",
484 | "required": false,
485 | "presentable": false,
486 | "unique": false,
487 | "options": {
488 | "min": null,
489 | "max": null,
490 | "pattern": ""
491 | }
492 | }
493 | ],
494 | "indexes": [
495 | "CREATE INDEX ` + "`" + `idx_PgBvcoT` + "`" + ` ON ` + "`" + `rd_resolved` + "`" + ` (` + "`" + `resource` + "`" + `)"
496 | ],
497 | "listRule": null,
498 | "viewRule": null,
499 | "createRule": null,
500 | "updateRule": null,
501 | "deleteRule": null,
502 | "options": {}
503 | }
504 | ]`
505 |
506 | collections := []*models.Collection{}
507 | if err := json.Unmarshal([]byte(jsonData), &collections); err != nil {
508 | return err
509 | }
510 |
511 | return daos.New(db).ImportCollections(collections, true, nil)
512 | }, func(db dbx.Builder) error {
513 | return nil
514 | })
515 | }
516 |
--------------------------------------------------------------------------------
/apps/backend/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "backend",
3 | "version": "1.0.0",
4 | "private": true,
5 | "scripts": {
6 | "dev": "watchexec -r -e go -e .env --stop-signal SIGINT -- go run main.go serve --http 0.0.0.0:8090",
7 | "build": "mkdir build || true && CGO_ENABLED=0 go build -o build/odin-server"
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/apps/backend/pb_public:
--------------------------------------------------------------------------------
1 | ../frontend/public
--------------------------------------------------------------------------------
/apps/backend/scraper/scraper.go:
--------------------------------------------------------------------------------
1 | package scraper
2 |
3 | import (
4 | "encoding/json"
5 |
6 | mqtt "github.com/eclipse/paho.mqtt.golang"
7 | "github.com/odin-movieshow/backend/cache"
8 | "github.com/odin-movieshow/backend/common"
9 | "github.com/odin-movieshow/backend/downloader/alldebrid"
10 | "github.com/odin-movieshow/backend/downloader/realdebrid"
11 | "github.com/odin-movieshow/backend/helpers"
12 | "github.com/odin-movieshow/backend/indexer"
13 | "github.com/odin-movieshow/backend/settings"
14 | "github.com/odin-movieshow/backend/types"
15 | "github.com/thoas/go-funk"
16 |
17 | "github.com/charmbracelet/log"
18 | "github.com/pocketbase/pocketbase"
19 | )
20 |
21 | type Scraper struct {
22 | app *pocketbase.PocketBase
23 | settings *settings.Settings
24 | helpers *helpers.Helpers
25 | cache *cache.Cache
26 | realdebrid *realdebrid.RealDebrid
27 | alldebrid *alldebrid.AllDebrid
28 | }
29 |
30 | func New(
31 | app *pocketbase.PocketBase,
32 | settings *settings.Settings,
33 | cache *cache.Cache,
34 | helpers *helpers.Helpers,
35 | realdebrid *realdebrid.RealDebrid,
36 | alldebrid *alldebrid.AllDebrid,
37 | ) *Scraper {
38 | return &Scraper{app: app, settings: settings, helpers: helpers, cache: cache, realdebrid: realdebrid, alldebrid: alldebrid}
39 | }
40 |
41 | func (s *Scraper) GetLinks(data common.Payload, mqt mqtt.Client) {
42 | topic := "odin-movieshow/" + data.Type
43 | indexertopic := "odin-movieshow/indexer/" + data.Type
44 | if data.Type == "episode" {
45 | topic += "/" + data.EpisodeTrakt
46 | indexertopic += "/" + data.EpisodeTrakt
47 | } else {
48 | topic += "/" + data.Trakt
49 | indexertopic += "/" + data.Trakt
50 | }
51 |
52 | log.Debug("test")
53 |
54 | log.Debug("MQTT", "indexer topic", indexertopic)
55 | log.Debug("MQTT", "result topic", topic)
56 | torrentQueueLowPrio := make(chan types.Torrent)
57 | torrentQueueNormalPrio := make(chan types.Torrent)
58 | torrentQueueHighPrio := make(chan types.Torrent)
59 |
60 | allTorrentsUnrestricted := s.cache.GetCachedTorrents("stream:" + topic)
61 | for _, u := range allTorrentsUnrestricted {
62 | cstr, _ := json.Marshal(u)
63 | mqt.Publish(topic, 0, false, cstr)
64 | }
65 |
66 | if token := mqt.Subscribe(indexertopic, 0, func(client mqtt.Client, msg mqtt.Message) {
67 | newTorrents := []types.Torrent{}
68 | json.Unmarshal(msg.Payload(), &newTorrents)
69 | go func() {
70 | for _, t := range newTorrents {
71 | switch t.Quality {
72 | case "4K":
73 | torrentQueueHighPrio <- t
74 | case "1080p":
75 | torrentQueueNormalPrio <- t
76 | default:
77 | torrentQueueLowPrio <- t
78 | }
79 | }
80 | }()
81 | }); token.Wait() &&
82 | token.Error() != nil {
83 | log.Error("mqtt-subscribe-indexer", "error", token.Error())
84 | }
85 |
86 | i := 0
87 | d := 0
88 |
89 | done := []string{}
90 | go func() {
91 | for k := range torrentQueueHighPrio {
92 | s.handlePrio(&i, &d, &done, k, &allTorrentsUnrestricted, mqt, topic)
93 | }
94 | }()
95 |
96 | go func() {
97 | for k := range torrentQueueNormalPrio {
98 | s.handlePrio(&i, &d, &done, k, &allTorrentsUnrestricted, mqt, topic)
99 | }
100 | }()
101 |
102 | go func() {
103 | for k := range torrentQueueLowPrio {
104 | s.handlePrio(&i, &d, &done, k, &allTorrentsUnrestricted, mqt, topic)
105 | }
106 | }()
107 |
108 | indexer.Index(data)
109 |
110 | go func() {
111 | <-torrentQueueLowPrio
112 | }()
113 |
114 | go func() {
115 | <-torrentQueueNormalPrio
116 | }()
117 |
118 | <-torrentQueueHighPrio
119 | mqt.Publish(topic, 0, false, "SCRAPING_DONE")
120 | log.Warn("Scraping done", "unrestricted", d)
121 | }
122 |
123 | func (s *Scraper) handlePrio(i *int, d *int, done *[]string, k types.Torrent, allTorrentsUnrestricted *[]types.Torrent, mqt mqtt.Client, topic string) {
124 | *i++
125 | // Filter quality from settings
126 | if !funk.Contains(*done, k.Magnet) {
127 |
128 | isUnrestricted := funk.Find(*allTorrentsUnrestricted, func(s types.Torrent) bool {
129 | return s.Magnet == k.Magnet
130 | }) != nil
131 |
132 | if !isUnrestricted {
133 | if s.unrestrict(k, mqt, topic) {
134 | *d++
135 | }
136 | }
137 | *done = append(*done, k.Magnet)
138 | }
139 | // }
140 | }
141 |
142 | func (s *Scraper) unrestrict(
143 | k types.Torrent,
144 | mqt mqtt.Client,
145 | topic string,
146 | ) bool {
147 | us := s.alldebrid.Unrestrict(k.Magnet)
148 | if len(us) == 0 {
149 | us = s.realdebrid.Unrestrict(k.Magnet)
150 | }
151 | if len(us) == 0 {
152 | return false
153 | }
154 | k.Links = us
155 | log.Info("Found streams for ", k.ReleaseTitle)
156 | kstr, _ := json.Marshal(k)
157 | s.cache.WriteCache("stream", k.Hash, topic, k, 12)
158 | mqt.Publish(topic, 0, false, kstr)
159 | return true
160 | }
161 |
--------------------------------------------------------------------------------
/apps/backend/settings/settings.go:
--------------------------------------------------------------------------------
1 | package settings
2 |
3 | import (
4 | "github.com/pocketbase/pocketbase"
5 | "github.com/pocketbase/pocketbase/models"
6 | )
7 |
8 | type RealDebridSettings struct {
9 | AccessToken string `json:"access_token"`
10 | ClientId string `json:"client_id"`
11 | ClientSecret string `json:"client_secret"`
12 | RefreshToken string `json:"refresh_token"`
13 | }
14 |
15 | type Settings struct {
16 | app *pocketbase.PocketBase
17 | }
18 |
19 | func New(app *pocketbase.PocketBase) *Settings {
20 | return &Settings{app: app}
21 | }
22 |
23 | func (s *Settings) GetRealDebrid() *RealDebridSettings {
24 | sets := s.getSettings()
25 | if sets != nil {
26 | r := RealDebridSettings{}
27 | if err := sets.UnmarshalJSONField("real_debrid", &r); err == nil {
28 | return &r
29 | }
30 | }
31 | return nil
32 | }
33 |
34 | func (s *Settings) getSettings() *models.Record {
35 | sets := []*models.Record{}
36 | s.app.Dao().RecordQuery("settings").All(&sets)
37 | if len(sets) > 0 {
38 | return sets[0]
39 | }
40 | return nil
41 | }
42 |
--------------------------------------------------------------------------------
/apps/backend/tmdb/tmdb.go:
--------------------------------------------------------------------------------
1 | package tmdb
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "os"
7 | "sync"
8 | "time"
9 |
10 | "github.com/odin-movieshow/backend/cache"
11 | "github.com/odin-movieshow/backend/settings"
12 | "github.com/odin-movieshow/backend/types"
13 | "github.com/thoas/go-funk"
14 |
15 | "github.com/charmbracelet/log"
16 |
17 | resty "github.com/go-resty/resty/v2"
18 | )
19 |
20 | type Tmdb struct {
21 | settings *settings.Settings
22 | cache *cache.Cache
23 | }
24 |
25 | func New(settings *settings.Settings, cache *cache.Cache) *Tmdb {
26 | return &Tmdb{settings: settings, cache: cache}
27 | }
28 |
29 | const (
30 | TMDB_URL = "https://api.themoviedb.org/3"
31 | )
32 |
33 | func (t *Tmdb) PopulateTMDB(
34 | k int,
35 | objmap []types.TraktItem,
36 | ) {
37 | resource := "movie"
38 | tmdbResource := "movie"
39 | if objmap[k].Type == "show" || objmap[k].Type == "episode" && objmap[k].Show != nil {
40 | resource = "show"
41 | tmdbResource = "tv"
42 | }
43 | if objmap[k].Season > 0 {
44 | resource = "season"
45 | tmdbResource = "tv"
46 | }
47 | id := objmap[k].IDs.Tmdb
48 |
49 | if objmap[k].Show != nil {
50 | id = objmap[k].Show.IDs.Tmdb
51 | }
52 | if objmap[k].IDs.Tmdb == 0 {
53 | return
54 | }
55 | var tmdbObj any
56 | url := fmt.Sprintf("/%s/%d", tmdbResource, id)
57 | cache := t.cache.ReadCache("tmdb", fmt.Sprintf("%d", id), resource)
58 | if cache != nil {
59 | tmdbObj = cache
60 | } else {
61 | tmdbObj = t.CallEndpoint(url)
62 | }
63 |
64 | if tmdbObj == nil {
65 | return
66 | }
67 | tmdb := t.prepare(tmdbObj)
68 | tmdbObj = t.tmdbToObj(tmdb)
69 | objmap[k].Tmdb = tmdbObj
70 | if objmap[k].Show != nil {
71 | objmap[k].Show.Tmdb = tmdbObj
72 | }
73 | if cache == nil {
74 | t.cache.WriteCache("tmdb", fmt.Sprintf("%d", id), resource, &tmdbObj, 12)
75 | }
76 | }
77 |
78 | func (t *Tmdb) prepare(obj any) *types.TmdbItem {
79 | tmdb := types.TmdbItem{}
80 | ms, err := json.Marshal(obj)
81 | if err != nil {
82 | log.Error(err)
83 | return nil
84 | }
85 | err = json.Unmarshal(ms, &tmdb)
86 | if err != nil {
87 | log.Error(err)
88 | return nil
89 | }
90 | tmdb.Original = &obj
91 |
92 | if (tmdb).Credits != nil {
93 | if (tmdb).Credits.Crew != nil {
94 | (tmdb).Credits.Crew = nil
95 | }
96 | if tmdb.Credits.Cast != nil {
97 | // strip down cast
98 | cast := tmdb.Credits.Cast
99 | castlen := len(*cast)
100 | if castlen > 15 {
101 | castlen = 15
102 | }
103 | castcut := (*cast)[0:castlen]
104 | tmdb.Credits.Cast = &castcut
105 | }
106 | }
107 |
108 | if tmdb.Images != nil &&
109 | tmdb.Images.Logos != nil {
110 |
111 | for _, l := range *tmdb.Images.Logos {
112 | if l.Iso_639_1 != nil && *(l.Iso_639_1) == "en" {
113 | tmdb.LogoPath = l.FilePath
114 | break
115 | }
116 | }
117 | if tmdb.LogoPath == "" && len(*tmdb.Images.Logos) > 0 {
118 | tmdb.LogoPath = (*tmdb.Images.Logos)[0].FilePath
119 | }
120 | tmdb.Images = nil
121 | } else {
122 | tmdb.LogoPath = ""
123 | }
124 |
125 | return &tmdb
126 | }
127 |
128 | func (t *Tmdb) tmdbToObj(tmdb *types.TmdbItem) any {
129 | var obj any
130 | ms, err := json.Marshal(tmdb)
131 | if err == nil {
132 | err = json.Unmarshal(ms, &obj)
133 | if err == nil {
134 | orig := *(tmdb.Original)
135 | if (orig) == nil {
136 | return obj
137 | }
138 | for k, v := range (orig).(map[string]interface{}) {
139 | if funk.Contains([]string{"images", "credits"}, k) {
140 | continue
141 | }
142 | obj.(map[string]any)[k] = v
143 | }
144 | obj.(map[string]any)["original"] = nil
145 | }
146 | }
147 | return obj
148 | }
149 |
150 | func (t *Tmdb) CallEndpoint(endpoint string) any {
151 | var data any
152 | request := resty.New().
153 | SetRetryCount(3).
154 | SetTimeout(time.Second * 30).
155 | SetRetryWaitTime(time.Second).
156 | R()
157 | url := TMDB_URL + endpoint + "?api_key=" + os.Getenv("TMDB_KEY") + "&append_to_response=credits,videos,images"
158 | if res, err := request.SetResult(&data).SetHeader("content-type", "application/json").Get(url); err != nil {
159 | log.Error("TMDB", endpoint, "status", res.StatusCode())
160 | }
161 | return data
162 | }
163 |
164 | func (t *Tmdb) GetEpisodes(showId string, seasons []string) *[]any {
165 | var wg sync.WaitGroup
166 | res := make([]any, 0)
167 |
168 | for _, s := range seasons {
169 | wg.Add(1)
170 | go func(s string) {
171 | endpoint := fmt.Sprintf("/tv/%s/season/%s", showId, s)
172 |
173 | defer wg.Done()
174 | obj := t.CallEndpoint(endpoint)
175 | res = append(res, obj)
176 | }(s)
177 | }
178 | wg.Wait()
179 |
180 | return &res
181 | }
182 |
--------------------------------------------------------------------------------
/apps/backend/trakt/trakt.go:
--------------------------------------------------------------------------------
1 | package trakt
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "net/http"
7 | "os"
8 | "strconv"
9 | "strings"
10 | "sync"
11 | "time"
12 |
13 | "github.com/odin-movieshow/backend/cache"
14 | "github.com/odin-movieshow/backend/settings"
15 | "github.com/odin-movieshow/backend/tmdb"
16 | "github.com/odin-movieshow/backend/types"
17 |
18 | "github.com/pocketbase/dbx"
19 | "github.com/pocketbase/pocketbase"
20 | "github.com/pocketbase/pocketbase/models"
21 | ptypes "github.com/pocketbase/pocketbase/tools/types"
22 | "github.com/thoas/go-funk"
23 |
24 | "github.com/go-resty/resty/v2"
25 |
26 | "github.com/charmbracelet/log"
27 | )
28 |
29 | const (
30 | TRAKT_URL = "https://api.trakt.tv"
31 | )
32 |
33 | type Trakt struct {
34 | app *pocketbase.PocketBase
35 | tmdb *tmdb.Tmdb
36 | settings *settings.Settings
37 | cache *cache.Cache
38 | }
39 |
40 | func New(app *pocketbase.PocketBase, tmdb *tmdb.Tmdb, settings *settings.Settings, cache *cache.Cache) *Trakt {
41 | return &Trakt{
42 | app: app,
43 | tmdb: tmdb,
44 | settings: settings,
45 | cache: cache,
46 | }
47 | }
48 |
49 | func (t *Trakt) removeDuplicates(objmap []types.TraktItem) []types.TraktItem {
50 | showsSeen := []uint{}
51 | toRemove := []int{}
52 | for i, o := range objmap {
53 | if o.Type != "episode" {
54 | continue
55 | }
56 | id := o.IDs.Trakt
57 |
58 | if o.Show != nil {
59 | id = o.Show.IDs.Trakt
60 | }
61 | if !funk.Contains(showsSeen, id) {
62 | showsSeen = append(showsSeen, id)
63 | } else {
64 | toRemove = append(toRemove, i)
65 | }
66 | }
67 |
68 | newmap := []types.TraktItem{}
69 |
70 | for i, o := range objmap {
71 | if !funk.ContainsInt(toRemove, i) {
72 | newmap = append(newmap, o)
73 | }
74 | }
75 |
76 | return newmap
77 | }
78 |
79 | func (t *Trakt) removeWatched(objmap []types.TraktItem) []types.TraktItem {
80 | return funk.Filter(objmap, func(o types.TraktItem) bool {
81 | return !o.Watched
82 | }).([]types.TraktItem)
83 | }
84 |
85 | func (t *Trakt) removeSeason0(objmap []types.TraktItem) []types.TraktItem {
86 | toKeep := []types.TraktItem{}
87 | for _, o := range objmap {
88 | if o.Number > 0 && o.Season > 0 {
89 | toKeep = append(toKeep, o)
90 | }
91 | }
92 |
93 | return toKeep
94 | }
95 |
96 | func (t *Trakt) SyncHistory(id string) {
97 | users := []*models.Record{}
98 | t.app.Dao().RecordQuery("users").All(&users)
99 | var wg sync.WaitGroup
100 | for _, u := range users {
101 | if id != "" && u.Id != id {
102 | continue
103 | }
104 | records, _ := t.app.Dao().FindRecordsByFilter("history", "user = {:user}", "-watched_at", 1, 0, dbx.Params{"user": u.Get("id")})
105 | last_watched := ptypes.DateTime{}
106 | if len(records) > 0 {
107 | last_watched = records[0].GetDateTime("watched_at")
108 | }
109 |
110 | token := make(map[string]any)
111 | if err := u.UnmarshalJSONField("trakt_token", &token); err != nil {
112 | continue
113 | }
114 |
115 | wg.Add(1)
116 | go t.syncByType(&wg, "movies", last_watched, u.Get("id").(string), "Bearer "+token["access_token"].(string))
117 | wg.Add(1)
118 | go t.syncByType(&wg, "episodes", last_watched, u.Get("id").(string), "Bearer "+token["access_token"].(string))
119 |
120 | wg.Wait()
121 | log.Info("Done synching trakt history", "user", u.Get("id"))
122 |
123 | }
124 | }
125 |
126 | func (t *Trakt) syncByType(wg *sync.WaitGroup, typ string, last_history ptypes.DateTime, user string, accesToken string) {
127 | defer wg.Done()
128 | limit := 200
129 | url := "/sync/history/" + typ + "?limit=" + fmt.Sprint(limit)
130 | collection, _ := t.app.Dao().FindCollectionByNameOrId("history")
131 | if !last_history.IsZero() {
132 | url += "&start_at=" + last_history.Time().Add(time.Second*1).Format(time.RFC3339)
133 | }
134 | _, headers, _ := t.CallEndpoint(url, "GET", types.TraktParams{Headers: map[string]string{"authorization": accesToken}})
135 | pages, _ := strconv.Atoi(headers.Get("X-Pagination-Page-Count"))
136 |
137 | for i := 1; i <= pages; i++ {
138 | // wg.Add(1)
139 | // go func(i int, wg *sync.WaitGroup) {
140 | // defer wg.Done()
141 | pageurl := url + "&page=" + fmt.Sprint(i)
142 |
143 | data, _, _ := t.CallEndpoint(pageurl, "GET", types.TraktParams{Headers: map[string]string{"authorization": accesToken}})
144 | if data == nil {
145 | continue
146 | }
147 | for _, o := range data.([]types.TraktItem) {
148 | o.Original = nil
149 | o.Watched = true
150 | record := models.NewRecord(collection)
151 | record.Set("watched_at", o.WatchedAt)
152 | record.Set("user", user)
153 | record.Set("type", o.Type)
154 | record.Set("trakt_id", o.IDs.Trakt)
155 | record.Set("runtime", o.Runtime)
156 | switch typ {
157 | case "movies":
158 | record.Set("data", o)
159 | case "episodes":
160 | record.Set("show_id", o.Show.IDs.Trakt)
161 | record.Set("data", o.Show)
162 | }
163 | t.app.Dao().SaveRecord(record)
164 |
165 | }
166 | // }(i, wg)
167 | }
168 | }
169 |
170 | func (t *Trakt) RefreshTokens() {
171 | records := []*models.Record{}
172 | t.app.Dao().RecordQuery("users").All(&records)
173 |
174 | for _, r := range records {
175 | token := make(map[string]any)
176 | if err := r.UnmarshalJSONField("trakt_token", &t); err == nil {
177 | data, _, status := t.CallEndpoint("/oauth/token", "POST", types.TraktParams{Body: map[string]any{"grant_type": "refresh_token", "client_id": os.Getenv("TRAKT_CLIENTID"), "client_secret": os.Getenv("TRAKT_SECRET"), "code": token["device_code"], "refresh_token": token["refresh_token"]}})
178 | if status < 300 && data != nil {
179 | data.(map[string]any)["device_code"] = token["device_code"]
180 | r.Set("trakt_token", data)
181 | t.app.Dao().Save(r)
182 | log.Info("trakt refresh token", "user", r.Get("id"))
183 | }
184 | }
185 |
186 | }
187 | }
188 |
189 | func (t *Trakt) normalize(objmap []types.TraktItem, isShow bool) []types.TraktItem {
190 | for i, o := range objmap {
191 | if o.Movie != nil || o.Episode != nil || o.Show != nil {
192 | m := types.TraktItem{}
193 | if o.Movie != nil {
194 | m = *o.Movie
195 | m.Movie = nil
196 | m.Type = "movie"
197 | } else {
198 | if o.Episode != nil && o.Show != nil {
199 | m = *o.Episode
200 | m.Episode = nil
201 | m.Show = o.Show
202 | m.Type = "episode"
203 | } else {
204 | m = *o.Show
205 | m.Show = nil
206 | m.Type = "show"
207 | }
208 | }
209 | orig := *o.Original
210 | if orig.(map[string]any)[m.Type] != nil {
211 | orig = (*o.Original).(map[string]any)[m.Type]
212 | }
213 | m.Original = &orig
214 | m.WatchedAt = o.WatchedAt
215 | objmap[i] = m
216 | } else {
217 | t := "movie"
218 | if isShow {
219 | t = "show"
220 | }
221 | if objmap[i].Episodes != nil {
222 | t = "season"
223 | }
224 | objmap[i].Type = t
225 | }
226 | }
227 | return objmap
228 | }
229 |
230 | func (t *Trakt) objToItems(objmap []any, isShow bool) []types.TraktItem {
231 | jm, err := json.Marshal(objmap)
232 | if err == nil {
233 | items := []types.TraktItem{}
234 | err = json.Unmarshal(jm, &items)
235 |
236 | if err == nil {
237 | if len(items) == 0 {
238 | return items
239 | }
240 | for i, item := range items {
241 | items[i].Original = &objmap[i]
242 | if item.Show != nil {
243 | sorig := objmap[i].(map[string]any)["show"]
244 | (*items[i].Show).Original = &sorig
245 | }
246 | if item.Episodes != nil && len(*item.Episodes) > 0 {
247 | for e := range *item.Episodes {
248 | (*items[i].Episodes)[e].Original = &objmap[i].(map[string]any)["episodes"].([]any)[e]
249 | }
250 | }
251 | }
252 | return t.normalize(items, isShow)
253 | }
254 | }
255 | return []types.TraktItem{}
256 | }
257 |
258 | func (t *Trakt) itemsToObj(items []types.TraktItem) []map[string]any {
259 | m, err := json.Marshal(items)
260 | o := []map[string]any{}
261 | if err != nil {
262 | return o
263 | }
264 |
265 | err = json.Unmarshal(m, &o)
266 | if err != nil {
267 | return o
268 | }
269 |
270 | for i := range o {
271 | orig := items[i].Original
272 | for k, v := range (*orig).(map[string]any) {
273 | if o[i][k] == nil && v != nil {
274 | o[i][k] = v
275 | }
276 | }
277 | o[i]["original"] = nil
278 | o[i]["movie"] = nil
279 | if o[i]["episode"] != nil {
280 | o[i]["episode"] = nil
281 | }
282 | if items[i].Show != nil {
283 | for k, v := range (*items[i].Show.Original).(map[string]any) {
284 | if o[i]["show"].(map[string]any)[k] == nil {
285 | o[i]["show"].(map[string]any)[k] = v
286 | }
287 | }
288 | o[i]["show"].(map[string]any)["original"] = nil
289 | }
290 |
291 | if items[i].Episodes != nil && len(*items[i].Episodes) > 0 {
292 | for e, ep := range *items[i].Episodes {
293 | for k, v := range (*ep.Original).(map[string]any) {
294 | if o[i]["episodes"].([]any)[e].(map[string]any)[k] == nil {
295 | o[i]["episodes"].([]any)[e].(map[string]any)[k] = v
296 | }
297 | }
298 | o[i]["episodes"].([]any)[e].(map[string]any)["original"] = nil
299 | }
300 | }
301 | }
302 |
303 | return o
304 | }
305 |
306 | func (t *Trakt) CallEndpoint(endpoint string, method string, params types.TraktParams) (any, http.Header, int) {
307 | var objmap any
308 |
309 | hs := map[string]string{}
310 | if params.Headers != nil {
311 | hs = params.Headers
312 | }
313 |
314 | request := resty.New().SetRetryCount(10).SetRetryWaitTime(time.Second * 3).R()
315 | request.SetHeader("trakt-api-version", "2").SetHeader("content-type", "application/json").SetHeader("trakt-api-key", os.Getenv("TRAKT_CLIENTID")).AddRetryCondition(func(r *resty.Response, err error) bool {
316 | return r.StatusCode() == 401
317 | }).SetHeaders(hs)
318 |
319 | var respHeaders http.Header
320 | status := 200
321 | if params.Body != nil {
322 | request.SetBody(params.Body)
323 | }
324 | request.Attempt = 3
325 | var r func(url string) (*resty.Response, error)
326 | switch method {
327 | case "POST":
328 | r = request.Post
329 | case "PATCH":
330 | r = request.Patch
331 | case "PUT":
332 | r = request.Put
333 | case "DELETE":
334 | r = request.Delete
335 | default:
336 | r = request.Get
337 |
338 | }
339 |
340 | if !strings.Contains(endpoint, "oauth") {
341 | if !strings.Contains(endpoint, "extended=") {
342 | if strings.Contains(endpoint, "?") {
343 | endpoint += "&"
344 | } else {
345 | endpoint += "?"
346 | }
347 | endpoint += "extended=full&limit=30"
348 | if !strings.Contains(endpoint, "limit=") {
349 | endpoint += "&limit=30"
350 | }
351 | }
352 | }
353 |
354 | if resp, err := r(fmt.Sprintf("%s%s", TRAKT_URL, endpoint)); err == nil {
355 | respHeaders = resp.Header()
356 | status = resp.StatusCode()
357 | if status > 299 {
358 | log.Error("trakt error", "fetch", endpoint, "status", status)
359 | log.Debug("trakt error", "res", string(resp.Body()), "body", params.Body, "headers", respHeaders)
360 | } else {
361 | log.Debug("trakt fetch", "url", endpoint, "method", method, "status", status)
362 | }
363 | err := json.Unmarshal(resp.Body(), &objmap)
364 | if err != nil {
365 | log.Error("trakt", "unmarshal", err)
366 | }
367 |
368 | switch objmap := objmap.(type) {
369 |
370 | case []any:
371 | items := t.objToItems(objmap, strings.Contains(endpoint, "/shows"))
372 | var wg sync.WaitGroup
373 | var mux sync.Mutex
374 |
375 | if len(items) == 0 || strings.Contains(endpoint, "sync/history") {
376 | if params.FetchTMDB {
377 | t.getTMDB(&wg, &mux, items)
378 | }
379 | wg.Wait()
380 | return items, respHeaders, status
381 | }
382 |
383 | t.GetWatched(items)
384 |
385 | if strings.Contains(endpoint, "calendars") {
386 | items = t.removeSeason0(items)
387 | items = t.removeWatched(items)
388 | items = t.removeDuplicates(items)
389 | }
390 |
391 | if params.FetchTMDB {
392 | t.getTMDB(&wg, &mux, items)
393 | }
394 |
395 | wg.Wait()
396 |
397 | return t.itemsToObj(items), respHeaders, status
398 |
399 | default:
400 |
401 | }
402 |
403 | } else {
404 | log.Error("trakt", "endpoint", endpoint, "body", params.Body, "err", err)
405 | }
406 |
407 | return objmap, respHeaders, status
408 | }
409 |
410 | func (t *Trakt) getTMDB(wg *sync.WaitGroup, _ *sync.Mutex, objmap []types.TraktItem) {
411 | for k := range objmap {
412 | wg.Add(1)
413 | go func() {
414 | t.tmdb.PopulateTMDB(k, objmap)
415 | wg.Done()
416 | }()
417 | }
418 | wg.Wait()
419 | }
420 |
421 | type Watched struct {
422 | LastWatchedAt time.Time `json:"last_watched_at"`
423 | LastUpdatedAt time.Time `json:"last_updated_at"`
424 | Seasons []struct {
425 | Episodes []struct {
426 | LastWatchedAt time.Time `json:"last_watched_at"`
427 | Number int `json:"number"`
428 | Plays int `json:"plays"`
429 | } `json:"episodes"`
430 | Number int `json:"number"`
431 | } `json:"seasons"`
432 | Movie types.TraktItem `json:"movie"`
433 | Show types.TraktItem `json:"show"`
434 | Plays int `json:"plays"`
435 | }
436 |
437 | func (t *Trakt) GetWatched(objmap []types.TraktItem) []types.TraktItem {
438 | if len(objmap) == 0 {
439 | return objmap
440 | }
441 | return t.AssignWatched(objmap, objmap[0].Type)
442 | }
443 |
444 | func (t *Trakt) getHistory(htype string) []any {
445 | records, _ := t.app.Dao().FindRecordsByFilter("history", "type = {:htype}", "-watched_at", -1, 0, dbx.Params{"htype": htype})
446 | data := make([]any, 0)
447 | for _, r := range records {
448 | item := make(map[string]any)
449 | item["type"] = r.Get("type")
450 | item["trakt_id"] = r.Get("trakt_id")
451 | data = append(data, item)
452 | }
453 | return data
454 | }
455 |
456 | func (t *Trakt) AssignWatched(objmap []types.TraktItem, typ string) []types.TraktItem {
457 | if typ == "season" {
458 | typ = "episode"
459 | }
460 | history := t.getHistory(typ)
461 | for i, o := range objmap {
462 | if o.Episodes != nil {
463 | for j, e := range *o.Episodes {
464 | oid := e.IDs.Trakt
465 | (*objmap[i].Episodes)[j].Watched = false
466 | for _, h := range history {
467 | hid := uint(h.(map[string]any)["trakt_id"].(float64))
468 | if hid == oid {
469 | (*objmap[i].Episodes)[j].Watched = true
470 | log.Debug(oid, "watched", (*objmap[i].Episodes)[j].Watched)
471 | break
472 | }
473 | }
474 | }
475 | } else {
476 |
477 | oid := o.IDs.Trakt
478 | objmap[i].Watched = false
479 | for _, h := range history {
480 | hid := uint(h.(map[string]any)["trakt_id"].(float64))
481 | if hid == oid {
482 | objmap[i].Watched = true
483 | break
484 | }
485 | }
486 | }
487 | }
488 | newmap := make([]types.TraktItem, 0)
489 |
490 | for _, o := range objmap {
491 | newmap = append(newmap, o)
492 | }
493 |
494 | return newmap
495 | }
496 |
497 | func (t *Trakt) GetSeasons(id int) any {
498 | cache := t.cache.ReadCache("trakt", fmt.Sprintf("%d", id), "seasons")
499 | if cache != nil {
500 | return cache
501 | }
502 | endpoint := fmt.Sprintf("/shows/%d/seasons?extended=full,episodes", id)
503 | result, _, _ := t.CallEndpoint(endpoint, "GET", types.TraktParams{})
504 | t.cache.WriteCache("trakt", fmt.Sprintf("%d", id), "seasons", &result, 12)
505 | return result
506 | }
507 |
--------------------------------------------------------------------------------
/apps/backend/types/types.go:
--------------------------------------------------------------------------------
1 | package types
2 |
3 | type Torrent struct {
4 | Scraper string `json:"scraper"`
5 | Hash string `json:"hash"`
6 | ReleaseTitle string `json:"release_title"`
7 | Magnet string `json:"magnet"`
8 | Url string `json:"url"`
9 | Name string `json:"name"`
10 | Quality string `json:"quality"`
11 | Info []string `json:"info"`
12 | Links []Unrestricted `json:"links"`
13 | Size uint64 `json:"size"`
14 | Seeds uint64 `json:"seeds"`
15 | }
16 |
17 | type TmdbItem struct {
18 | Credits *struct {
19 | Cast *[]any `json:"cast"`
20 | Crew *[]any `json:"crew"`
21 | } `json:"credits,omitempty"`
22 | Images *struct {
23 | Logos *[]struct {
24 | Iso_639_1 *string `json:"iso_639_1"`
25 | FilePath string `json:"file_path"`
26 | } `json:"logos"`
27 | } `json:"images,omitempty"`
28 | Original *interface{} `json:"original,omitempty"`
29 | LogoPath string `json:"logo_path"`
30 | }
31 |
32 | type TraktItem struct {
33 | Tmdb any `json:"tmdb"`
34 | Original *interface{} `json:"original,omitempty"`
35 | Show *TraktItem `json:"show,omitempty"`
36 | Movie *TraktItem `json:"movie,omitempty"`
37 | Episode *TraktItem `json:"episode,omitempty"`
38 | Episodes *[]TraktItem `json:"episodes,omitempty"`
39 | Title string `json:"title"`
40 | Type string `json:"type"`
41 | WatchedAt string `json:"watched_at"`
42 | Genres []string `json:"genres"`
43 | IDs struct {
44 | Slug string `json:"slug"`
45 | Imdb string `json:"imdb"`
46 | Trakt uint `json:"trakt"`
47 | Tmdb uint `json:"tmdb"`
48 | Tvdb uint `json:"tvdb"`
49 | } `json:"ids"`
50 | Runtime uint `json:"runtime"`
51 | Season uint `json:"season"`
52 | Number uint `json:"number"`
53 | Watched bool `json:"watched"`
54 | }
55 |
56 | type Unrestricted struct {
57 | Filename string `json:"filename"`
58 | Download string `json:"download"`
59 | Streams []string `json:"stream"`
60 | Filesize int `json:"filesize"`
61 | }
62 |
63 | type TraktParams struct {
64 | Body map[string]any
65 | Headers map[string]string
66 | Donorm bool
67 | FetchTMDB bool
68 | }
69 |
--------------------------------------------------------------------------------
/apps/frontend/.gitignore:
--------------------------------------------------------------------------------
1 | # Nuxt dev/build outputs
2 | .output
3 | .data
4 | .nuxt
5 | .nitro
6 | .cache
7 | dist
8 |
9 | # Node dependencies
10 | node_modules
11 |
12 | # Logs
13 | logs
14 | *.log
15 |
16 | # Misc
17 | .DS_Store
18 | .fleet
19 | .idea
20 |
21 | # Local env files
22 | .env
23 | .env.*
24 | !.env.example
25 |
--------------------------------------------------------------------------------
/apps/frontend/.npmrc:
--------------------------------------------------------------------------------
1 | shamefully-hoist=true
--------------------------------------------------------------------------------
/apps/frontend/.prettierrc:
--------------------------------------------------------------------------------
1 | {
2 | "trailingComma": "es5",
3 | "semi": false,
4 | "singleQuote": true,
5 | "useTabs": true,
6 | "quoteProps": "consistent",
7 | "arrowParens": "always",
8 | "printWidth": 180,
9 | "vueIndentScriptAndStyle": true
10 | }
--------------------------------------------------------------------------------
/apps/frontend/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM node:alpine as builder
2 | WORKDIR /build/
3 | RUN npm i -g pnpm
4 | COPY package.json .
5 | RUN pnpm i
6 | COPY . .
7 | RUN pnpm run build
8 |
9 | FROM node:alpine
10 | WORKDIR /app
11 | COPY --from=builder /build/.output /app
12 |
13 | CMD ["node", "server/index.mjs"]
14 |
--------------------------------------------------------------------------------
/apps/frontend/README.md:
--------------------------------------------------------------------------------
1 | # Nuxt 3 Minimal Starter
2 |
3 | Look at the [Nuxt 3 documentation](https://nuxt.com/docs/getting-started/introduction) to learn more.
4 |
5 | ## Setup
6 |
7 | Make sure to install the dependencies:
8 |
9 | ```bash
10 | # npm
11 | npm install
12 |
13 | # pnpm
14 | pnpm install
15 |
16 | # yarn
17 | yarn install
18 |
19 | # bun
20 | bun install
21 | ```
22 |
23 | ## Development Server
24 |
25 | Start the development server on `http://localhost:3000`:
26 |
27 | ```bash
28 | # npm
29 | npm run dev
30 |
31 | # pnpm
32 | pnpm run dev
33 |
34 | # yarn
35 | yarn dev
36 |
37 | # bun
38 | bun run dev
39 | ```
40 |
41 | ## Production
42 |
43 | Build the application for production:
44 |
45 | ```bash
46 | # npm
47 | npm run build
48 |
49 | # pnpm
50 | pnpm run build
51 |
52 | # yarn
53 | yarn build
54 |
55 | # bun
56 | bun run build
57 | ```
58 |
59 | Locally preview production build:
60 |
61 | ```bash
62 | # npm
63 | npm run preview
64 |
65 | # pnpm
66 | pnpm run preview
67 |
68 | # yarn
69 | yarn preview
70 |
71 | # bun
72 | bun run preview
73 | ```
74 |
75 | Check out the [deployment documentation](https://nuxt.com/docs/getting-started/deployment) for more information.
76 |
--------------------------------------------------------------------------------
/apps/frontend/app.vue:
--------------------------------------------------------------------------------
1 |
2 | {{ profile.data.user.username }}
7 |{{ profile.data.user.email }}
8 |{{ profile.data.user.premiumUntil }}
9 |Not connected!
12 |{{ item.tmdb.production_companies.at(0).name }}
6 |{{ item.overview }}
15 |
24 | {{ actor.name }}
{{ actor.character }}
25 |
S{{ sNumber }}xE{{ e.number }} - {{ e.title }}
24 |{{ e.first_aired }}
25 |
5 |
9 |
19 | {{ item['title'] }}
20 |
{{ traktProfile.user.username }}
{{ traktProfile.user.name }}
Click below to login into Trakt
27 |{{ profile.username }}
7 |{{ profile.email }}
8 |{{ profile.expiration }}
9 || ID | 9 |Username | 10 |12 | | |
| {{ user.id }} | 16 |{{ user.username }} | 17 |{{ user.email }} | 18 |19 | 22 | | 23 |
ADMIN| {{ device.name }} | 9 |{{ device.created }} | 10 |
Version: {{ serverVersion }}
8 |Please see Trakt API for reference.
35 |37 | ::(year|month|day):: current year|month|day 38 | ::(year|month|day):-1: current year|month|day +1 (or -1) 39 | ::monthdays:: days of the current month41 | Example: /movies/popular?years=::year::,::year:-1: -> /movies/popular?years=2024,2023 42 |
{children}
23 | 24 | ); 25 | } 26 | -------------------------------------------------------------------------------- /packages/ui/src/code.tsx: -------------------------------------------------------------------------------- 1 | export function Code({ 2 | children, 3 | className, 4 | }: { 5 | children: React.ReactNode; 6 | className?: string; 7 | }): JSX.Element { 8 | return{children};
9 | }
10 |
--------------------------------------------------------------------------------
/packages/ui/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "@repo/typescript-config/react-library.json",
3 | "compilerOptions": {
4 | "outDir": "dist"
5 | },
6 | "include": ["src"],
7 | "exclude": ["node_modules", "dist"]
8 | }
9 |
--------------------------------------------------------------------------------
/packages/ui/tsconfig.lint.json:
--------------------------------------------------------------------------------
1 | {
2 | "extends": "@repo/typescript-config/react-library.json",
3 | "compilerOptions": {
4 | "outDir": "dist"
5 | },
6 | "include": ["src", "turbo"],
7 | "exclude": ["node_modules", "dist"]
8 | }
9 |
--------------------------------------------------------------------------------
/packages/ui/turbo/generators/config.ts:
--------------------------------------------------------------------------------
1 | import type { PlopTypes } from "@turbo/gen";
2 |
3 | // Learn more about Turborepo Generators at https://turbo.build/repo/docs/core-concepts/monorepos/code-generation
4 |
5 | export default function generator(plop: PlopTypes.NodePlopAPI): void {
6 | // A simple generator to add a new React component to the internal UI library
7 | plop.setGenerator("react-component", {
8 | description: "Adds a new react component",
9 | prompts: [
10 | {
11 | type: "input",
12 | name: "name",
13 | message: "What is the name of the component?",
14 | },
15 | ],
16 | actions: [
17 | {
18 | type: "add",
19 | path: "src/{{kebabCase name}}.tsx",
20 | templateFile: "templates/component.hbs",
21 | },
22 | {
23 | type: "append",
24 | path: "package.json",
25 | pattern: /"exports": {(?