302 lines
8.6 KiB
Go
302 lines
8.6 KiB
Go
package web
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"encoding/json"
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/sirrobot01/decypharr/internal/config"
|
|
"github.com/sirrobot01/decypharr/internal/request"
|
|
"github.com/sirrobot01/decypharr/internal/utils"
|
|
"github.com/sirrobot01/decypharr/pkg/arr"
|
|
"github.com/sirrobot01/decypharr/pkg/qbit"
|
|
"github.com/sirrobot01/decypharr/pkg/service"
|
|
"github.com/sirrobot01/decypharr/pkg/version"
|
|
)
|
|
|
|
func (ui *Handler) handleGetArrs(w http.ResponseWriter, r *http.Request) {
|
|
svc := service.GetService()
|
|
request.JSONResponse(w, svc.Arr.GetAll(), http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleAddContent(w http.ResponseWriter, r *http.Request) {
|
|
if err := r.ParseMultipartForm(32 << 20); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
svc := service.GetService()
|
|
|
|
results := make([]*qbit.ImportRequest, 0)
|
|
errs := make([]string, 0)
|
|
|
|
arrName := r.FormValue("arr")
|
|
notSymlink := r.FormValue("notSymlink") == "true"
|
|
downloadUncached := r.FormValue("downloadUncached") == "true"
|
|
if arrName == "" {
|
|
arrName = "uncategorized"
|
|
}
|
|
|
|
_arr := svc.Arr.Get(arrName)
|
|
if _arr == nil {
|
|
_arr = arr.New(arrName, "", "", false, false, &downloadUncached)
|
|
}
|
|
|
|
// Handle URLs
|
|
if urls := r.FormValue("urls"); urls != "" {
|
|
var urlList []string
|
|
for _, u := range strings.Split(urls, "\n") {
|
|
if trimmed := strings.TrimSpace(u); trimmed != "" {
|
|
urlList = append(urlList, trimmed)
|
|
}
|
|
}
|
|
|
|
for _, url := range urlList {
|
|
magnet, err := utils.GetMagnetFromUrl(url)
|
|
if err != nil {
|
|
errs = append(errs, fmt.Sprintf("Failed to parse URL %s: %v", url, err))
|
|
continue
|
|
}
|
|
importReq := qbit.NewImportRequest(magnet, _arr, !notSymlink, downloadUncached)
|
|
if err := importReq.Process(ui.qbit); err != nil {
|
|
errs = append(errs, fmt.Sprintf("URL %s: %v", url, err))
|
|
continue
|
|
}
|
|
results = append(results, importReq)
|
|
}
|
|
}
|
|
|
|
// Handle torrent/magnet files
|
|
if files := r.MultipartForm.File["files"]; len(files) > 0 {
|
|
for _, fileHeader := range files {
|
|
file, err := fileHeader.Open()
|
|
if err != nil {
|
|
errs = append(errs, fmt.Sprintf("Failed to open file %s: %v", fileHeader.Filename, err))
|
|
continue
|
|
}
|
|
|
|
magnet, err := utils.GetMagnetFromFile(file, fileHeader.Filename)
|
|
if err != nil {
|
|
errs = append(errs, fmt.Sprintf("Failed to parse torrent file %s: %v", fileHeader.Filename, err))
|
|
continue
|
|
}
|
|
|
|
importReq := qbit.NewImportRequest(magnet, _arr, !notSymlink, downloadUncached)
|
|
err = importReq.Process(ui.qbit)
|
|
if err != nil {
|
|
errs = append(errs, fmt.Sprintf("File %s: %v", fileHeader.Filename, err))
|
|
continue
|
|
}
|
|
results = append(results, importReq)
|
|
}
|
|
}
|
|
|
|
request.JSONResponse(w, struct {
|
|
Results []*qbit.ImportRequest `json:"results"`
|
|
Errors []string `json:"errors,omitempty"`
|
|
}{
|
|
Results: results,
|
|
Errors: errs,
|
|
}, http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleRepairMedia(w http.ResponseWriter, r *http.Request) {
|
|
var req RepairRequest
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
svc := service.GetService()
|
|
|
|
var arrs []string
|
|
|
|
if req.ArrName != "" {
|
|
_arr := svc.Arr.Get(req.ArrName)
|
|
if _arr == nil {
|
|
http.Error(w, "No Arrs found to repair", http.StatusNotFound)
|
|
return
|
|
}
|
|
arrs = append(arrs, req.ArrName)
|
|
}
|
|
|
|
if req.Async {
|
|
go func() {
|
|
if err := svc.Repair.AddJob(arrs, req.MediaIds, req.AutoProcess, false); err != nil {
|
|
ui.logger.Error().Err(err).Msg("Failed to repair media")
|
|
}
|
|
}()
|
|
request.JSONResponse(w, "Repair process started", http.StatusOK)
|
|
return
|
|
}
|
|
|
|
if err := svc.Repair.AddJob([]string{req.ArrName}, req.MediaIds, req.AutoProcess, false); err != nil {
|
|
http.Error(w, fmt.Sprintf("Failed to repair: %v", err), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
request.JSONResponse(w, "Repair completed", http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleGetVersion(w http.ResponseWriter, r *http.Request) {
|
|
v := version.GetInfo()
|
|
request.JSONResponse(w, v, http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleGetTorrents(w http.ResponseWriter, r *http.Request) {
|
|
request.JSONResponse(w, ui.qbit.Storage.GetAllSorted("", "", nil, "added_on", false), http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleDeleteTorrent(w http.ResponseWriter, r *http.Request) {
|
|
hash := chi.URLParam(r, "hash")
|
|
category := r.URL.Query().Get("category")
|
|
removeFromDebrid := r.URL.Query().Get("removeFromDebrid") == "true"
|
|
if hash == "" {
|
|
http.Error(w, "No hash provided", http.StatusBadRequest)
|
|
return
|
|
}
|
|
ui.qbit.Storage.Delete(hash, category, removeFromDebrid)
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleDeleteTorrents(w http.ResponseWriter, r *http.Request) {
|
|
hashesStr := r.URL.Query().Get("hashes")
|
|
removeFromDebrid := r.URL.Query().Get("removeFromDebrid") == "true"
|
|
if hashesStr == "" {
|
|
http.Error(w, "No hashes provided", http.StatusBadRequest)
|
|
return
|
|
}
|
|
hashes := strings.Split(hashesStr, ",")
|
|
ui.qbit.Storage.DeleteMultiple(hashes, removeFromDebrid)
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleGetConfig(w http.ResponseWriter, r *http.Request) {
|
|
cfg := config.Get()
|
|
arrCfgs := make([]config.Arr, 0)
|
|
svc := service.GetService()
|
|
for _, a := range svc.Arr.GetAll() {
|
|
arrCfgs = append(arrCfgs, config.Arr{
|
|
Host: a.Host,
|
|
Name: a.Name,
|
|
Token: a.Token,
|
|
Cleanup: a.Cleanup,
|
|
SkipRepair: a.SkipRepair,
|
|
DownloadUncached: a.DownloadUncached,
|
|
})
|
|
}
|
|
cfg.Arrs = arrCfgs
|
|
request.JSONResponse(w, cfg, http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleUpdateConfig(w http.ResponseWriter, r *http.Request) {
|
|
// Decode the JSON body
|
|
var updatedConfig config.Config
|
|
if err := json.NewDecoder(r.Body).Decode(&updatedConfig); err != nil {
|
|
ui.logger.Error().Err(err).Msg("Failed to decode config update request")
|
|
http.Error(w, "Invalid request body: "+err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
// Get the current configuration
|
|
currentConfig := config.Get()
|
|
|
|
// Update fields that can be changed
|
|
currentConfig.LogLevel = updatedConfig.LogLevel
|
|
currentConfig.MinFileSize = updatedConfig.MinFileSize
|
|
currentConfig.MaxFileSize = updatedConfig.MaxFileSize
|
|
currentConfig.AllowedExt = updatedConfig.AllowedExt
|
|
currentConfig.DiscordWebhook = updatedConfig.DiscordWebhook
|
|
|
|
// Should this be added?
|
|
currentConfig.URLBase = updatedConfig.URLBase
|
|
currentConfig.BindAddress = updatedConfig.BindAddress
|
|
currentConfig.Port = updatedConfig.Port
|
|
|
|
// Update QBitTorrent config
|
|
currentConfig.QBitTorrent = updatedConfig.QBitTorrent
|
|
|
|
// Update Repair config
|
|
currentConfig.Repair = updatedConfig.Repair
|
|
|
|
// Update Debrids
|
|
if len(updatedConfig.Debrids) > 0 {
|
|
currentConfig.Debrids = updatedConfig.Debrids
|
|
// Clear legacy single debrid if using array
|
|
}
|
|
|
|
if len(updatedConfig.Arrs) > 0 {
|
|
currentConfig.Arrs = updatedConfig.Arrs
|
|
}
|
|
|
|
// Update Arrs through the service
|
|
svc := service.GetService()
|
|
svc.Arr.Clear() // Clear existing arrs
|
|
|
|
for _, a := range updatedConfig.Arrs {
|
|
svc.Arr.AddOrUpdate(&arr.Arr{
|
|
Name: a.Name,
|
|
Host: a.Host,
|
|
Token: a.Token,
|
|
Cleanup: a.Cleanup,
|
|
SkipRepair: a.SkipRepair,
|
|
DownloadUncached: a.DownloadUncached,
|
|
})
|
|
}
|
|
currentConfig.Arrs = updatedConfig.Arrs
|
|
if err := currentConfig.Save(); err != nil {
|
|
http.Error(w, "Error saving config: "+err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if restartFunc != nil {
|
|
go func() {
|
|
// Small delay to ensure the response is sent
|
|
time.Sleep(500 * time.Millisecond)
|
|
restartFunc()
|
|
}()
|
|
}
|
|
|
|
// Return success
|
|
request.JSONResponse(w, map[string]string{"status": "success"}, http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleGetRepairJobs(w http.ResponseWriter, r *http.Request) {
|
|
svc := service.GetService()
|
|
request.JSONResponse(w, svc.Repair.GetJobs(), http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleProcessRepairJob(w http.ResponseWriter, r *http.Request) {
|
|
id := chi.URLParam(r, "id")
|
|
if id == "" {
|
|
http.Error(w, "No job ID provided", http.StatusBadRequest)
|
|
return
|
|
}
|
|
svc := service.GetService()
|
|
if err := svc.Repair.ProcessJob(id); err != nil {
|
|
ui.logger.Error().Err(err).Msg("Failed to process repair job")
|
|
}
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
func (ui *Handler) handleDeleteRepairJob(w http.ResponseWriter, r *http.Request) {
|
|
// Read ids from body
|
|
var req struct {
|
|
IDs []string `json:"ids"`
|
|
}
|
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
if len(req.IDs) == 0 {
|
|
http.Error(w, "No job IDs provided", http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
svc := service.GetService()
|
|
svc.Repair.DeleteJobs(req.IDs)
|
|
w.WriteHeader(http.StatusOK)
|
|
}
|