Makefile

@@ -1,40 +0,0 @@
-GOCMD=go
-GOBUILD=$(GOCMD) build
-GOCLEAN=$(GOCMD) clean
-GOTEST=$(GOCMD) test
-GOGET=$(GOCMD) get
-BINARY_NAME=drmdtool
-SRC_DIR=src
-
-all: test build
-
-build:
-	cd $(SRC_DIR) && $(GOBUILD) -o ../$(BINARY_NAME) -v
-
-test:
-	cd $(SRC_DIR) && $(GOTEST) -v ./...
-
-clean:
-	$(GOCLEAN)
-	rm -f $(BINARY_NAME)
-
-run:
-	cd $(SRC_DIR) && $(GOBUILD) -o ../$(BINARY_NAME) -v
-	./$(BINARY_NAME)
-
-deps:
-	$(GOGET) github.com/BurntSushi/toml
-	$(GOGET) github.com/beevik/etree
-	$(GOGET) github.com/asticode/go-astisub
-
-# Cross compilation
-build-linux:
-	cd $(SRC_DIR) && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GOBUILD) -o ../$(BINARY_NAME)_linux -v
-
-build-windows:
-	cd $(SRC_DIR) && CGO_ENABLED=0 GOOS=windows GOARCH=amd64 $(GOBUILD) -o ../$(BINARY_NAME).exe -v
-
-build-mac:
-	cd $(SRC_DIR) && CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 $(GOBUILD) -o ../$(BINARY_NAME)_mac -v
-
-.PHONY: all build test clean run deps build-linux build-windows build-mac

README.md

@@ -7,51 +7,14 @@ drmdtool is a utility for processing .drmd files using N_m3u8DL-RE.
 Create a `config.toml` file in the same directory as the drmdtool executable:
 
 ```toml
-[General]
 BaseDir = "/path/to/save/downloads"
 Format = "mkv"
-TempBaseDir = "/tmp/nre"
-EnableConsole = true
 
-[WatchFolder]
+[N_m3u8DL-RE]
-Path = "/path/to/watched/folder"
-PollingInterval = 10
-UsePolling = true
-UseInotify = false
-
-[N_m3u8DLRE]
 Path = "/path/to/N_m3u8DL-RE"
 ```
 
-### Configuration Options
+Adjust the paths and format as needed. (mkv, mp4)
-
-- **General**
-  - `BaseDir`: Directory where downloaded files will be saved.
-  - `Format`: Output format for the downloaded files (e.g., `mkv`, `mp4`).
-  - `TempBaseDir`: Temporary directory for intermediate files.
-  - `EnableConsole`: Boolean to enable or disable console output.
-
-- **WatchFolder**
-  - `Path`: Directory to watch for new `.drmd` files.
-  - `PollingInterval`: Interval in seconds for polling the watch folder.
-  - `UsePolling`: Boolean to enable or disable folder polling.
-  - `UseInotify`: Boolean to enable or disable inotify for file watching.
-
-- **N_m3u8DLRE**
-  - `Path`: Path to the N_m3u8DL-RE executable.
-
-### Environment Variable Overrides
-
-You can override the configuration options using environment variables. The following environment variables are supported:
-
-- `BASE_DIR`: Overrides `General.BaseDir`
-- `FORMAT`: Overrides `General.Format`
-- `TEMP_BASE_DIR`: Overrides `General.TempBaseDir`
-- `ENABLE_CONSOLE`: Overrides `General.EnableConsole` (set to `true` or `false`)
-- `WATCHED_FOLDER`: Overrides `WatchFolder.Path`
-- `USE_POLLING`: Overrides `WatchFolder.UsePolling` (set to `true` or `false`)
-- `USE_INOTIFY`: Overrides `WatchFolder.UseInotify` (set to `true` or `false`)
-- `POLLING_INTERVAL`: Overrides `WatchFolder.PollingInterval`
 
 ## Web UI Usage
 
@@ -64,6 +27,7 @@ You can override the configuration options using environment variables. The foll
 
 3. Use the interface to upload .drmd files and monitor download progress
 
+
 ## CLI Usage
 
 To process a file directly from the command line:
@@ -74,16 +38,8 @@ To process a file directly from the command line:
 
 This will download the file and save it in the base directory specified in the config.
 
-# Previews
+## TODO
-
+- ~~Filename Sanitation (Makes new directory on /... oops)~~
-## Index Page
+- ~~GoPlay Fix~~
-
+- Windows?
-![Index Page](images/index.png)
+- Proper UI?
-
-## Select Page
-
-![Select Page](images/select.png)
-
-## Progress Page
-
-![Progress Page](images/progress.png)

config.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/BurntSushi/toml"
+)
+
+type Config struct {
+	BaseDir     string
+	Format      string
+	TempBaseDir string
+	N_m3u8DLRE  struct {
+		Path string
+	}
+}
+
+var config Config
+
+func loadConfig() {
+	configFile, err := os.Open("config.toml")
+	if err != nil {
+		fmt.Println("Error opening config file:", err)
+		return
+	}
+	defer configFile.Close()
+
+	byteValue, _ := io.ReadAll(configFile)
+
+	if _, err := toml.Decode(string(byteValue), &config); err != nil {
+		fmt.Println("Error decoding config file:", err)
+		return
+	}
+
+	if config.N_m3u8DLRE.Path == "" {
+		fmt.Println("Error: N_m3u8DL-RE path is not specified in the config file")
+		return
+	}
+
+}

config.toml

@@ -1,14 +1,6 @@
-[General]
 BaseDir = "/mnt/media"
-Format = "mkv"
+Format = "mkv" 
 TempBaseDir = "/tmp/nre"
-EnableConsole = true
-
-[WatchFolder]
-Path = "/mnt/watched"
-PollingInterval = 10
-UsePolling = false
-UseInotify = true
 
 [N_m3u8DLRE]
-Path = "nre"
+Path = "nre"

downloaders.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"bytes"
 	"encoding/base64"
 	"fmt"
 	"io"
@@ -10,7 +9,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
-	"time"
 )
 
 func removeBOM(input []byte) []byte {
@@ -20,13 +18,12 @@ func removeBOM(input []byte) []byte {
 	return input
 }
 
-func downloadFile(drmdFilename string, item Item, jobInfo *JobInfo) error {
+func downloadFile(item Item, jobInfo *JobInfo) error {
-	logger.LogInfo("Download File", fmt.Sprintf("Starting download for: %s", item.Filename))
+	fmt.Println("Downloading:", item.Filename)
 
-	tempDir := filepath.Join(config.General.TempBaseDir, sanitizeFilename(item.Filename))
+	tempDir := filepath.Join(config.TempBaseDir, sanitizeFilename(item.Filename))
 	err := os.MkdirAll(tempDir, 0755)
 	if err != nil {
-		logger.LogError("Download File", fmt.Sprintf("Error creating temporary directory: %v", err))
 		return fmt.Errorf("error creating temporary directory: %v", err)
 	}
 
@@ -36,23 +33,19 @@ func downloadFile(drmdFilename string, item Item, jobInfo *JobInfo) error {
 	if !isValidURL(item.MPD) {
 		decodedMPD, err := base64.StdEncoding.DecodeString(item.MPD)
 		if err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error decoding base64 MPD: %v", err))
 			return fmt.Errorf("error decoding base64 MPD: %v", err)
 		}
 
 		tempFile, err := os.CreateTemp("", "temp_mpd_*.mpd")
 		if err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error creating temporary MPD file: %v", err))
 			return fmt.Errorf("error creating temporary MPD file: %v", err)
 		}
 		defer os.Remove(tempFile.Name())
 
 		if _, err := tempFile.Write(decodedMPD); err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error writing to temporary MPD file: %v", err))
 			return fmt.Errorf("error writing to temporary MPD file: %v", err)
 		}
 		if err := tempFile.Close(); err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error closing temporary MPD file: %v", err))
 			return fmt.Errorf("error closing temporary MPD file: %v", err)
 		}
 
@@ -60,36 +53,30 @@ func downloadFile(drmdFilename string, item Item, jobInfo *JobInfo) error {
 	} else if strings.HasPrefix(item.MPD, "https://pubads.g.doubleclick.net") {
 		resp, err := http.Get(item.MPD)
 		if err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error downloading MPD: %v", err))
 			return fmt.Errorf("error downloading MPD: %v", err)
 		}
 		defer resp.Body.Close()
 
 		mpdContent, err := io.ReadAll(resp.Body)
 		if err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error reading MPD content: %v", err))
 			return fmt.Errorf("error reading MPD content: %v", err)
 		}
 
 		fixedMPDContent, err := fixGoPlay(string(mpdContent))
 		if err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error fixing MPD content: %v", err))
 			return fmt.Errorf("error fixing MPD content: %v", err)
 		}
 
 		tempFile, err := os.CreateTemp("", "fixed_mpd_*.mpd")
 		if err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error creating temporary MPD file: %v", err))
 			return fmt.Errorf("error creating temporary MPD file: %v", err)
 		}
 		defer os.Remove(tempFile.Name())
 
 		if _, err := tempFile.WriteString(fixedMPDContent); err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error writing to temporary MPD file: %v", err))
 			return fmt.Errorf("error writing to temporary MPD file: %v", err)
 		}
 		if err := tempFile.Close(); err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error closing temporary MPD file: %v", err))
 			return fmt.Errorf("error closing temporary MPD file: %v", err)
 		}
 
@@ -101,25 +88,26 @@ func downloadFile(drmdFilename string, item Item, jobInfo *JobInfo) error {
 	if item.Subtitles != "" {
 		subtitlePaths, err := downloadAndConvertSubtitles(item.Subtitles)
 		if err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error processing subtitles: %v", err))
+			fmt.Printf("Error processing subtitles: %v\n", err)
 		} else {
 			for _, path := range subtitlePaths {
-				logger.LogInfo("Download File", fmt.Sprintf("Adding subtitle: %s", path))
+				fmt.Println("Adding subtitle:", path)
 				command += fmt.Sprintf(" --mux-import \"path=%s:lang=nl:name=Nederlands\"", path)
 			}
 		}
 	}
 
 	cmd := exec.Command("bash", "-c", command)
-	jobInfo.Cmd = cmd
 
-	var outputBuffer bytes.Buffer
+	jobsMutex.Lock()
-	cmd.Stdout = io.MultiWriter(&outputBuffer)
+	jobInfo.Cmd = cmd
+	jobsMutex.Unlock()
+
+	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 
 	err = cmd.Start()
 	if err != nil {
-		logger.LogError("Download File", fmt.Sprintf("Error starting download command: %v", err))
 		return fmt.Errorf("error starting download command: %v", err)
 	}
 
@@ -128,39 +116,24 @@ func downloadFile(drmdFilename string, item Item, jobInfo *JobInfo) error {
 		done <- cmd.Wait()
 	}()
 
-	go func() {
-		for {
-			if outputBuffer.Len() > 0 {
-				message := outputBuffer.Bytes()
-				if config.General.EnableConsole {
-					broadcast(drmdFilename, message)
-				}
-				outputBuffer.Reset()
-			}
-			time.Sleep(1 * time.Second)
-		}
-	}()
-
 	select {
 	case <-jobInfo.AbortChan:
 		if cmd.Process != nil {
 			cmd.Process.Kill()
 		}
 		os.RemoveAll(tempDir)
-		logger.LogInfo("Download File", "Download aborted")
 		return fmt.Errorf("download aborted")
 	case err := <-done:
 		if jobInfo.Paused {
-			logger.LogInfo("Download File", "Download paused")
 			return fmt.Errorf("download paused")
 		}
 		if err != nil {
-			logger.LogError("Download File", fmt.Sprintf("Error executing download command: %v", err))
 			return fmt.Errorf("error executing download command: %v", err)
 		}
 	}
 
-	logger.LogInfo("Download File", "Download completed successfully")
+	fmt.Println("Download completed successfully")
+	os.RemoveAll(tempDir)
 	return nil
 }
 
@@ -183,9 +156,9 @@ func getDownloadCommand(item Item, mpdPath string, tempDir string) string {
 	filename := fmt.Sprintf("\"%s\"", sanitizedFilename)
 	command += fmt.Sprintf(" --save-name %s", filename)
 
-	command += fmt.Sprintf(" --mux-after-done format=%s", config.General.Format)
+	command += fmt.Sprintf(" --mux-after-done format=%s", config.Format)
 
-	saveDir := config.General.BaseDir
+	saveDir := config.BaseDir
 	if metadata.Type == "serie" {
 		saveDir = filepath.Join(saveDir, "Series", metadata.Title, metadata.Season)
 	} else {

go.mod

@@ -8,13 +8,9 @@ require (
 	github.com/beevik/etree v1.4.1
 )
 
-require golang.org/x/sys v0.4.0 // indirect
-
 require (
 	github.com/asticode/go-astikit v0.20.0 // indirect
 	github.com/asticode/go-astits v1.8.0 // indirect
-	github.com/fsnotify/fsnotify v1.7.0
-	github.com/gorilla/websocket v1.5.3
 	golang.org/x/net v0.0.0-20200904194848-62affa334b73 // indirect
 	golang.org/x/text v0.3.2 // indirect
 )

go.sum

@@ -10,10 +10,6 @@ github.com/beevik/etree v1.4.1 h1:PmQJDDYahBGNKDcpdX8uPy1xRCwoCGVUiW669MEirVI=
 github.com/beevik/etree v1.4.1/go.mod h1:gPNJNaBGVZ9AwsidazFZyygnd+0pAU38N4D+WemwKNs=
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
-github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
-github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
-github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/pkg/exec v0.0.0-20150614095509-0bd164ad2a5a h1:EN123kAtAAE2pg/+TvBsUBZfHCWNNFyL2ZBPPfNWAc0=
 github.com/pkg/exec v0.0.0-20150614095509-0bd164ad2a5a/go.mod h1:b95YoNrAnScjaWG+asr8lxqlrsPUcT2ZEBcjvVGshMo=
 github.com/pkg/profile v1.4.0/go.mod h1:NWz/XGvpEW1FyYQ7fCx4dqYBLlfTcE+A9FLAkNKqjFE=
@@ -30,8 +26,6 @@ golang.org/x/net v0.0.0-20200904194848-62affa334b73/go.mod h1:/O7V0waA8r7cgGh81R
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18=
-golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=

handlers.go

@@ -0,0 +1,234 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+)
+
+func handleRoot(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path != "/" {
+		http.NotFound(w, r)
+		return
+	}
+
+	progressMutex.Lock()
+	jobs := make(map[string]*ProgressInfo)
+	for k, v := range progress {
+		jobs[k] = v
+	}
+	progressMutex.Unlock()
+
+	err := templates.ExecuteTemplate(w, "index", struct{ Jobs map[string]*ProgressInfo }{jobs})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func handleUpload(w http.ResponseWriter, r *http.Request) {
+	file, header, err := r.FormFile("file")
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	defer file.Close()
+
+	tempFile, err := os.CreateTemp(uploadDir, header.Filename)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	defer tempFile.Close()
+
+	_, err = io.Copy(tempFile, file)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	tempFilename := filepath.Base(tempFile.Name())
+
+	_, err = parseInputFile(tempFile.Name())
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	http.Redirect(w, r, "/select?filename="+tempFilename, http.StatusSeeOther)
+}
+
+func handleSelect(w http.ResponseWriter, r *http.Request) {
+	filename := r.URL.Query().Get("filename")
+	items, err := parseInputFile(filepath.Join(uploadDir, filename))
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	groupedItems := groupItemsBySeason(items)
+
+	err = templates.ExecuteTemplate(w, "select", struct {
+		Filename string
+		Items    map[string][]Item
+	}{
+		Filename: filename,
+		Items:    groupedItems,
+	})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func handleProcess(w http.ResponseWriter, r *http.Request) {
+	filename := r.FormValue("filename")
+	selectedItems := r.Form["items"]
+
+	items, err := parseInputFile(filepath.Join(uploadDir, filename))
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	filteredItems := filterSelectedItems(items, selectedItems)
+
+	go func() {
+		err := processItems(filename, filteredItems)
+		if err != nil {
+			fmt.Printf("Error processing file: %v\n", err)
+		}
+
+		os.Remove(filepath.Join(uploadDir, filename))
+	}()
+
+	http.Redirect(w, r, "/progress?filename="+filename, http.StatusSeeOther)
+}
+
+func handleProgress(w http.ResponseWriter, r *http.Request) {
+	filename := r.URL.Query().Get("filename")
+	fmt.Printf("Handling progress request for filename: %s\n", filename)
+
+	if r.Header.Get("Accept") == "application/json" {
+		progressInfo := getProgress(filename)
+		fmt.Printf("Progress info for %s: %+v\n", filename, progressInfo)
+
+		if progressInfo == nil {
+			w.WriteHeader(http.StatusNotFound)
+			json.NewEncoder(w).Encode(map[string]string{"error": "No progress information found"})
+			return
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		err := json.NewEncoder(w).Encode(progressInfo)
+		if err != nil {
+			fmt.Printf("Error encoding progress info: %v\n", err)
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			return
+		}
+		return
+	}
+
+	err := templates.ExecuteTemplate(w, "progress", struct{ Filename string }{filename})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func handlePause(w http.ResponseWriter, r *http.Request) {
+	filename := r.URL.Query().Get("filename")
+	if filename == "" {
+		http.Error(w, "Filename is required", http.StatusBadRequest)
+		return
+	}
+
+	jobsMutex.Lock()
+	jobInfo, exists := jobs[filename]
+	jobsMutex.Unlock()
+
+	if !exists {
+		http.Error(w, "Job not found", http.StatusNotFound)
+		return
+	}
+
+	jobInfo.Paused = true
+	if jobInfo.Cmd != nil && jobInfo.Cmd.Process != nil {
+		jobInfo.Cmd.Process.Kill()
+	}
+
+	fmt.Fprintf(w, "Pause signal sent for %s", filename)
+}
+
+func handleResume(w http.ResponseWriter, r *http.Request) {
+	filename := r.URL.Query().Get("filename")
+	if filename == "" {
+		http.Error(w, "Filename is required", http.StatusBadRequest)
+		return
+	}
+
+	jobsMutex.Lock()
+	jobInfo, exists := jobs[filename]
+	jobsMutex.Unlock()
+
+	if !exists {
+		http.Error(w, "Job not found", http.StatusNotFound)
+		return
+	}
+
+	jobInfo.Paused = false
+	jobInfo.ResumeChan <- struct{}{}
+
+	fmt.Fprintf(w, "Resume signal sent for %s", filename)
+}
+
+func handleAbort(w http.ResponseWriter, r *http.Request) {
+	filename := r.URL.Query().Get("filename")
+	if filename == "" {
+		http.Error(w, "Filename is required", http.StatusBadRequest)
+		return
+	}
+
+	jobsMutex.Lock()
+	jobInfo, exists := jobs[filename]
+	jobsMutex.Unlock()
+
+	if !exists {
+		http.Error(w, "Job not found", http.StatusNotFound)
+		return
+	}
+
+	close(jobInfo.AbortChan)
+	if jobInfo.Cmd != nil && jobInfo.Cmd.Process != nil {
+		jobInfo.Cmd.Process.Kill()
+	}
+
+	if jobInfo.TempDir != "" {
+		os.RemoveAll(jobInfo.TempDir)
+	}
+
+	fmt.Fprintf(w, "Abort signal sent for %s", filename)
+}
+
+func handleClearCompleted(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	clearCompletedJobs()
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(map[string]bool{"success": true})
+}
+
+func clearCompletedJobs() {
+	progressMutex.Lock()
+	defer progressMutex.Unlock()
+
+	for filename, info := range progress {
+		if info.Percentage >= 100 {
+			delete(progress, filename)
+		}
+	}
+}

main.go

@@ -12,8 +12,6 @@ import (
 	"embed"
 )
 
-var logger *Logger
-
 type Item struct {
 	MPD         string
 	Keys        string
@@ -39,6 +37,11 @@ var progress = make(map[string]*ProgressInfo)
 
 const uploadDir = "uploads"
 
+type ProgressInfo struct {
+	Percentage  float64
+	CurrentFile string
+}
+
 var templates *template.Template
 
 //go:embed templates
@@ -50,8 +53,6 @@ func init() {
 	}
 
 	templates = template.Must(template.ParseFS(templateFS, "templates/*"))
-
-	logger = NewLogger("")
 }
 
 func main() {
@@ -60,12 +61,11 @@ func main() {
 	flag.Parse()
 
 	if *inputFile == "" {
-		go watchFolder()
 		startWebServer()
 	} else {
 		items, err := parseInputFile(*inputFile)
 		if err != nil {
-			logger.LogError("Main", fmt.Sprintf("Error parsing input file: %v", err))
+			fmt.Printf("Error parsing input file: %v\n", err)
 			return
 		}
 		processItems(*inputFile, items)
@@ -82,12 +82,21 @@ func startWebServer() {
 	http.HandleFunc("/pause", handlePause)
 	http.HandleFunc("/resume", handleResume)
 	http.HandleFunc("/clear-completed", handleClearCompleted)
-	http.HandleFunc("/ws", handleWebSocket)
 
-	logger.LogInfo("Main", "Starting web server on http://0.0.0.0:8080")
+	fmt.Println("Starting web server on http://0.0.0.0:8080")
 	http.ListenAndServe(":8080", nil)
 }
 
+func updateProgress(filename string, value float64, currentFile string) {
+	progressMutex.Lock()
+	defer progressMutex.Unlock()
+	progress[filename] = &ProgressInfo{
+		Percentage:  value,
+		CurrentFile: currentFile,
+	}
+	fmt.Printf("Progress updated for %s: %.2f%%, Current file: %s\n", filename, value, currentFile)
+}
+
 func getProgress(filename string) *ProgressInfo {
 	progressMutex.Lock()
 	defer progressMutex.Unlock()

src/config.go

@@ -1,144 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/BurntSushi/toml"
-)
-
-type Config struct {
-	General struct {
-		BaseDir       string
-		Format        string
-		TempBaseDir   string
-		EnableConsole bool
-	}
-	WatchFolder struct {
-		Path            string
-		UsePolling      bool
-		UseInotify      bool
-		PollingInterval int
-	}
-	N_m3u8DLRE struct {
-		Path string
-	}
-}
-
-var config Config
-
-func loadConfig() {
-	configFile, err := os.Open("config.toml")
-	if err != nil {
-		logger.LogError("Config", fmt.Sprintf("Error opening config file: %v", err))
-		os.Exit(1)
-	}
-	defer configFile.Close()
-
-	byteValue, _ := io.ReadAll(configFile)
-
-	if _, err := toml.Decode(string(byteValue), &config); err != nil {
-		logger.LogError("Config", fmt.Sprintf("Error decoding config file: %v", err))
-		os.Exit(1)
-	}
-
-	overrideConfigWithEnv()
-
-	if err := validatePaths(); err != nil {
-		logger.LogError("Config", fmt.Sprintf("Configuration error: %v", err))
-		os.Exit(1)
-	}
-
-	if config.WatchFolder.PollingInterval <= 0 {
-		config.WatchFolder.PollingInterval = 10
-	}
-
-	logConfig()
-}
-
-func overrideConfigWithEnv() {
-	if envBaseDir := os.Getenv("BASE_DIR"); envBaseDir != "" {
-		config.General.BaseDir = envBaseDir
-	}
-	if envFormat := os.Getenv("FORMAT"); envFormat != "" {
-		config.General.Format = envFormat
-	}
-	if envTempBaseDir := os.Getenv("TEMP_BASE_DIR"); envTempBaseDir != "" {
-		config.General.TempBaseDir = envTempBaseDir
-	}
-	if envEnableConsole := os.Getenv("ENABLE_CONSOLE"); envEnableConsole != "" {
-		config.General.EnableConsole = strings.ToLower(envEnableConsole) == "true"
-	}
-	if envWatchedFolder := os.Getenv("WATCHED_FOLDER"); envWatchedFolder != "" {
-		config.WatchFolder.Path = envWatchedFolder
-	}
-	if envUsePolling := os.Getenv("USE_POLLING"); envUsePolling != "" {
-		config.WatchFolder.UsePolling = strings.ToLower(envUsePolling) == "true"
-	}
-	if envUseInotify := os.Getenv("USE_INOTIFY"); envUseInotify != "" {
-		config.WatchFolder.UseInotify = strings.ToLower(envUseInotify) == "true"
-	}
-	if envPollingInterval := os.Getenv("POLLING_INTERVAL"); envPollingInterval != "" {
-		if interval, err := strconv.Atoi(envPollingInterval); err == nil {
-			config.WatchFolder.PollingInterval = interval
-		}
-	}
-}
-
-func validatePaths() error {
-	paths := []struct {
-		name string
-		path string
-	}{
-		{"BaseDir", config.General.BaseDir},
-	}
-
-	for _, p := range paths {
-		if p.path == "" {
-			return fmt.Errorf("%s is not specified", p.name)
-		}
-		if _, err := os.Stat(p.path); os.IsNotExist(err) {
-			return fmt.Errorf("%s does not exist: %s", p.name, p.path)
-		} else if err != nil {
-			return fmt.Errorf("error accessing %s: %v", p.name, err)
-		}
-	}
-
-	if config.WatchFolder.UsePolling || config.WatchFolder.UseInotify {
-		if config.WatchFolder.Path == "" {
-			return fmt.Errorf("WatchedFolder is not specified")
-		}
-		if _, err := os.Stat(config.WatchFolder.Path); os.IsNotExist(err) {
-			return fmt.Errorf("WatchedFolder does not exist: %s", config.WatchFolder.Path)
-		} else if err != nil {
-			return fmt.Errorf("error accessing WatchedFolder: %v", err)
-		}
-	}
-
-	return nil
-}
-
-func logConfig() {
-	configInfo := fmt.Sprintf(`
-Configuration Loaded:
-  General:
-    BaseDir: %s
-    Format: %s
-    TempBaseDir: %s
-    EnableConsole: %t
-  WatchFolder:
-    Path: %s
-    UsePolling: %t
-    UseInotify: %t
-    PollingInterval: %d
-  N_m3u8DLRE:
-    Path: %s
-`, config.General.BaseDir, config.General.Format, config.General.TempBaseDir, config.General.EnableConsole,
-		config.WatchFolder.Path, config.WatchFolder.UsePolling, config.WatchFolder.UseInotify, config.WatchFolder.PollingInterval,
-		config.N_m3u8DLRE.Path)
-
-	logger.LogInfo("Config", configInfo)
-}

src/handlers.go

@@ -1,445 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	"github.com/gorilla/websocket"
-)
-
-type ProgressInfo struct {
-	Percentage  float64
-	CurrentFile string
-	Paused      bool
-}
-
-func handleRoot(w http.ResponseWriter, r *http.Request) {
-	progressMutex.Lock()
-	defer progressMutex.Unlock()
-
-	jobsInfo := make(map[string]struct {
-		Percentage  float64
-		CurrentFile string
-		Paused      bool
-	})
-
-	for filename, info := range progress {
-		jobsInfo[filename] = struct {
-			Percentage  float64
-			CurrentFile string
-			Paused      bool
-		}{
-			Percentage:  info.Percentage,
-			CurrentFile: info.CurrentFile,
-			Paused:      info.Paused,
-		}
-	}
-
-	err := templates.ExecuteTemplate(w, "index", struct {
-		Jobs map[string]struct {
-			Percentage  float64
-			CurrentFile string
-			Paused      bool
-		}
-	}{jobsInfo})
-	if err != nil {
-		logger.LogError("Handle Root", fmt.Sprintf("Error executing template: %v", err))
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-func handleUpload(w http.ResponseWriter, r *http.Request) {
-	logger.LogInfo("Handle Upload", "Starting file upload")
-	err := r.ParseMultipartForm(32 << 20)
-	if err != nil {
-		logger.LogError("Handle Upload", fmt.Sprintf("Error parsing multipart form: %v", err))
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	files := r.MultipartForm.File["files"]
-	if len(files) == 0 {
-		logger.LogError("Handle Upload", "No files uploaded")
-		http.Error(w, "No files uploaded", http.StatusBadRequest)
-		return
-	}
-
-	uploadedFiles := []string{}
-
-	for _, fileHeader := range files {
-		file, err := fileHeader.Open()
-		if err != nil {
-			logger.LogError("Handle Upload", fmt.Sprintf("Error opening file: %v", err))
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		defer file.Close()
-
-		tempFile, err := os.CreateTemp(uploadDir, fileHeader.Filename)
-		if err != nil {
-			logger.LogError("Handle Upload", fmt.Sprintf("Error creating temporary file: %v", err))
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		defer tempFile.Close()
-
-		_, err = io.Copy(tempFile, file)
-		if err != nil {
-			logger.LogError("Handle Upload", fmt.Sprintf("Error copying file: %v", err))
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		uploadedFiles = append(uploadedFiles, filepath.Base(tempFile.Name()))
-
-		_, err = parseInputFile(tempFile.Name())
-		if err != nil {
-			logger.LogError("Handle Upload", fmt.Sprintf("Error parsing input file: %v", err))
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-	}
-
-	validFiles := []string{}
-	for _, file := range uploadedFiles {
-		if file != "" {
-			validFiles = append(validFiles, file)
-		}
-	}
-
-	if len(validFiles) == 0 {
-		logger.LogError("Handle Upload", "No valid files were uploaded")
-		http.Error(w, "No valid files were uploaded", http.StatusBadRequest)
-		return
-	}
-
-	logger.LogInfo("Handle Upload", fmt.Sprintf("Redirecting to select with files: %v", validFiles))
-	http.Redirect(w, r, "/select?files="+url.QueryEscape(strings.Join(validFiles, ",")), http.StatusSeeOther)
-}
-
-func handleSelect(w http.ResponseWriter, r *http.Request) {
-	filesParam := r.URL.Query().Get("files")
-	filenames := strings.Split(filesParam, ",")
-
-	allItems := make(map[string]map[string][]Item)
-
-	for _, filename := range filenames {
-		if filename == "" {
-			continue
-		}
-		fullPath := filepath.Join(uploadDir, filename)
-
-		if _, err := os.Stat(fullPath); os.IsNotExist(err) {
-			logger.LogError("Handle Select", fmt.Sprintf("File does not exist: %s", fullPath))
-			continue
-		}
-
-		items, err := parseInputFile(fullPath)
-		if err != nil {
-			logger.LogError("Handle Select", fmt.Sprintf("Error parsing input file: %v", err))
-			continue
-		}
-
-		sortItems(items)
-
-		groupedItems := groupItemsBySeason(items)
-		allItems[filename] = groupedItems
-	}
-
-	if len(allItems) == 0 {
-		logger.LogError("Handle Select", "No valid files were processed")
-		http.Error(w, "No valid files were processed", http.StatusBadRequest)
-		return
-	}
-
-	err := templates.ExecuteTemplate(w, "select", struct {
-		Filenames string
-		AllItems  map[string]map[string][]Item
-	}{
-		Filenames: filesParam,
-		AllItems:  allItems,
-	})
-	if err != nil {
-		logger.LogError("Handle Select", fmt.Sprintf("Error executing template: %v", err))
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-func handleProcess(w http.ResponseWriter, r *http.Request) {
-	logger.LogInfo("Handle Process", "Starting process")
-	if err := r.ParseForm(); err != nil {
-		logger.LogError("Handle Process", fmt.Sprintf("Error parsing form: %v", err))
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	selectedItems := r.Form["items"]
-	if len(selectedItems) == 0 {
-		logger.LogError("Handle Process", "No items selected")
-		http.Error(w, "No items selected", http.StatusBadRequest)
-		return
-	}
-
-	itemsByFile := make(map[string][]string)
-	for _, item := range selectedItems {
-		parts := strings.SplitN(item, ":", 2)
-		if len(parts) != 2 {
-			logger.LogError("Handle Process", "Invalid item format")
-			continue
-		}
-		filename, itemName := parts[0], parts[1]
-		itemsByFile[filename] = append(itemsByFile[filename], itemName)
-	}
-
-	for filename, items := range itemsByFile {
-		logger.LogInfo("Handle Process", fmt.Sprintf("Processing file: %s", filename))
-		fullPath := filepath.Join(uploadDir, filename)
-		allItems, err := parseInputFile(fullPath)
-		if err != nil {
-			logger.LogError("Handle Process", fmt.Sprintf("Error parsing input file: %v", err))
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		selectedItems := filterSelectedItems(allItems, items)
-		sortItems(selectedItems)
-		go processItems(filename, selectedItems)
-	}
-
-	http.Redirect(w, r, "/", http.StatusSeeOther)
-}
-
-func handleProgress(w http.ResponseWriter, r *http.Request) {
-	filename := r.URL.Query().Get("filename")
-
-	if r.Header.Get("Accept") == "application/json" {
-		progressInfo := getProgress(filename)
-
-		if progressInfo == nil {
-			w.WriteHeader(http.StatusNotFound)
-			json.NewEncoder(w).Encode(map[string]string{"error": "No progress information found"})
-			return
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		err := json.NewEncoder(w).Encode(progressInfo)
-		if err != nil {
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			return
-		}
-		return
-	}
-
-	err := templates.ExecuteTemplate(w, "progress", struct{ Filename string }{filename})
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-func handlePause(w http.ResponseWriter, r *http.Request) {
-	filename := r.URL.Query().Get("filename")
-	if filename == "" {
-		logger.LogError("Pause Handler", "Filename is required")
-		http.Error(w, "Filename is required", http.StatusBadRequest)
-		return
-	}
-
-	jobsMutex.Lock()
-	jobInfo, exists := jobs[filename]
-	jobsMutex.Unlock()
-
-	if !exists {
-		logger.LogError("Pause Handler", "Job not found")
-		http.Error(w, "Job not found", http.StatusNotFound)
-		return
-	}
-
-	jobInfo.Paused = true
-	if jobInfo.Cmd != nil && jobInfo.Cmd.Process != nil {
-		logger.LogJobState(filename, "pausing")
-		jobInfo.Cmd.Process.Kill()
-	}
-
-	progressMutex.Lock()
-	if progressInfo, ok := progress[filename]; ok {
-		progressInfo.Paused = true
-	}
-	progressMutex.Unlock()
-
-	fmt.Fprintf(w, "Pause signal sent for %s", filename)
-}
-
-func handleResume(w http.ResponseWriter, r *http.Request) {
-	filename := r.URL.Query().Get("filename")
-	if filename == "" {
-		http.Error(w, "Filename is required", http.StatusBadRequest)
-		return
-	}
-
-	jobsMutex.Lock()
-	jobInfo, exists := jobs[filename]
-	jobsMutex.Unlock()
-
-	if !exists {
-		http.Error(w, "Job not found", http.StatusNotFound)
-		return
-	}
-
-	jobInfo.Paused = false
-	jobInfo.ResumeChan <- struct{}{}
-
-	progressMutex.Lock()
-	if progressInfo, ok := progress[filename]; ok {
-		progressInfo.Paused = false
-	}
-	progressMutex.Unlock()
-
-	fmt.Fprintf(w, "Resume signal sent for %s", filename)
-}
-
-func handleAbort(w http.ResponseWriter, r *http.Request) {
-	filename := r.URL.Query().Get("filename")
-	if filename == "" {
-		http.Error(w, "Filename is required", http.StatusBadRequest)
-		return
-	}
-
-	jobsMutex.Lock()
-	jobInfo, exists := jobs[filename]
-	jobsMutex.Unlock()
-
-	if !exists {
-		http.Error(w, "Job not found", http.StatusNotFound)
-		return
-	}
-
-	close(jobInfo.AbortChan)
-	if jobInfo.Cmd != nil && jobInfo.Cmd.Process != nil {
-		jobInfo.Cmd.Process.Kill()
-	}
-
-	if jobInfo.TempDir != "" {
-		os.RemoveAll(jobInfo.TempDir)
-	}
-
-	fmt.Fprintf(w, "Abort signal sent for %s", filename)
-}
-
-func handleClearCompleted(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-
-	clearCompletedJobs()
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(map[string]bool{"success": true})
-}
-
-func clearCompletedJobs() {
-	progressMutex.Lock()
-	defer progressMutex.Unlock()
-
-	for filename, info := range progress {
-		if info.Percentage >= 100 {
-			delete(progress, filename)
-		}
-	}
-}
-
-func updateProgress(filename string, value float64, currentFile string) {
-	progressMutex.Lock()
-	defer progressMutex.Unlock()
-
-	jobsMutex.Lock()
-	jobInfo, exists := jobs[filename]
-	jobsMutex.Unlock()
-
-	paused := false
-	if exists {
-		paused = jobInfo.Paused
-	}
-
-	if existingProgress, ok := progress[filename]; ok {
-		existingProgress.Percentage = value
-		existingProgress.CurrentFile = currentFile
-		existingProgress.Paused = paused
-	} else {
-		progress[filename] = &ProgressInfo{
-			Percentage:  value,
-			CurrentFile: currentFile,
-			Paused:      paused,
-		}
-	}
-}
-
-var upgrader = websocket.Upgrader{}
-var clients = make(map[string]map[*websocket.Conn]bool)
-var mu sync.Mutex
-
-func handleWebSocket(w http.ResponseWriter, r *http.Request) {
-	fmt.Println(config.General.EnableConsole)
-	if !config.General.EnableConsole {
-		http.Error(w, "Console output is disabled", http.StatusForbidden)
-		return
-	}
-
-	filename := r.URL.Query().Get("filename")
-	if filename == "" {
-		http.Error(w, "Filename is required", http.StatusBadRequest)
-		return
-	}
-
-	conn, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		logger.LogError("WebSocket", fmt.Sprintf("Error while upgrading connection: %v", err))
-		return
-	}
-	defer conn.Close()
-
-	logger.LogInfo("WebSocket", fmt.Sprintf("WebSocket connection established for filename: %s", filename))
-
-	mu.Lock()
-	if clients[filename] == nil {
-		clients[filename] = make(map[*websocket.Conn]bool)
-	}
-	clients[filename][conn] = true
-	mu.Unlock()
-
-	for {
-		if _, _, err := conn.NextReader(); err != nil {
-			break
-		}
-	}
-
-	mu.Lock()
-	delete(clients[filename], conn)
-	mu.Unlock()
-
-	logger.LogInfo("WebSocket", fmt.Sprintf("WebSocket connection closed for filename: %s", filename))
-}
-
-func broadcast(filename string, message []byte) {
-	if !config.General.EnableConsole {
-		return
-	}
-
-	mu.Lock()
-	defer mu.Unlock()
-
-	for client := range clients[filename] {
-		if err := client.WriteMessage(websocket.TextMessage, message); err != nil {
-			client.Close()
-			delete(clients[filename], client)
-			logger.LogError("Broadcast", fmt.Sprintf("Error writing message to client: %v", err))
-		}
-	}
-}

src/logger.go

@@ -1,36 +0,0 @@
-package main
-
-import (
-	"log"
-	"os"
-)
-
-type Logger struct {
-	*log.Logger
-}
-
-const (
-	Reset  = "\033[0m"
-	Red    = "\033[31m"
-	Green  = "\033[32m"
-	Yellow = "\033[33m"
-	Blue   = "\033[34m"
-)
-
-func NewLogger(prefix string) *Logger {
-	return &Logger{
-		Logger: log.New(os.Stdout, prefix, log.Ldate|log.Ltime|log.Lshortfile),
-	}
-}
-
-func (l *Logger) LogInfo(jobName, message string) {
-	l.Printf("%s[INFO] [%s] %s%s", Green, jobName, message, Reset)
-}
-
-func (l *Logger) LogError(jobName, message string) {
-	l.Printf("%s[ERROR] [%s] %s%s", Red, jobName, message, Reset)
-}
-
-func (l *Logger) LogJobState(jobName, state string) {
-	l.Printf("%s[JOB STATE] [%s] %s%s", Yellow, jobName, state, Reset)
-}

src/main_test.go

@@ -1,125 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"os"
-	"reflect"
-	"testing"
-)
-
-func TestSanitizeFilename(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected string
-	}{
-		{"file:name.mp4", "file_name.mp4"},
-		{"file/name.mp4", "file_name.mp4"},
-		{"file\\name.mp4", "file_name.mp4"},
-		{"file?name.mp4", "file_name.mp4"},
-		{"file*name.mp4", "file_name.mp4"},
-		{"file<name>.mp4", "file_name_.mp4"},
-		{".hidden", "hidden"},
-	}
-
-	for _, test := range tests {
-		result := sanitizeFilename(test.input)
-		if result != test.expected {
-			t.Errorf("sanitizeFilename(%q) = %q, want %q", test.input, result, test.expected)
-		}
-	}
-}
-
-func TestIsValidURL(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected bool
-	}{
-		{"https://example.com", true},
-		{"http://example.com", true},
-		{"ftp://example.com", true},
-		{"not a url", false},
-	}
-
-	for _, test := range tests {
-		result := isValidURL(test.input)
-		if result != test.expected {
-			t.Errorf("isValidURL(%q) = %v, want %v", test.input, result, test.expected)
-		}
-	}
-}
-
-func TestParseMetadata(t *testing.T) {
-	tests := []struct {
-		input    string
-		expected Metadata
-	}{
-		{"Show Title; serie; 01", Metadata{Title: "Show Title", Type: "serie", Season: "S01"}},
-		{"Movie Title; movie; ", Metadata{Title: "Movie Title", Type: "movie", Season: "S"}},
-		{"Invalid Metadata", Metadata{}},
-	}
-
-	for _, test := range tests {
-		result := parseMetadata(test.input)
-		if !reflect.DeepEqual(result, test.expected) {
-			t.Errorf("parseMetadata(%q) = %v, want %v", test.input, result, test.expected)
-		}
-	}
-}
-
-func TestParseInputFile(t *testing.T) {
-	tempFile, err := os.CreateTemp("", "test_input_*.json")
-	if err != nil {
-		t.Fatalf("Failed to create temp file: %v", err)
-	}
-	defer os.Remove(tempFile.Name())
-
-	testData := Items{
-		Items: []Item{
-			{MPD: "http://example.com/video1.mpd", Filename: "video1.mp4"},
-			{MPD: "http://example.com/video2.mpd", Filename: "video2.mp4"},
-		},
-	}
-	jsonData, _ := json.Marshal(testData)
-	if _, err := tempFile.Write(jsonData); err != nil {
-		t.Fatalf("Failed to write to temp file: %v", err)
-	}
-	tempFile.Close()
-
-	items, err := parseInputFile(tempFile.Name())
-	if err != nil {
-		t.Fatalf("parseInputFile() returned an error: %v", err)
-	}
-
-	if len(items) != len(testData.Items) {
-		t.Errorf("parseInputFile() returned %d items, want %d", len(items), len(testData.Items))
-	}
-
-	for i, item := range items {
-		if !reflect.DeepEqual(item, testData.Items[i]) {
-			t.Errorf("parseInputFile() item %d = %v, want %v", i, item, testData.Items[i])
-		}
-	}
-}
-
-func TestGroupItemsBySeason(t *testing.T) {
-	items := []Item{
-		{Filename: "show1_s01e01.mp4", Metadata: "Show 1; serie; 01"},
-		{Filename: "show1_s01e02.mp4", Metadata: "Show 1; serie; 01"},
-		{Filename: "show2_s01e01.mp4", Metadata: "Show 2; serie; 01"},
-		{Filename: "movie1.mp4", Metadata: "Movie 1; movie; "},
-	}
-
-	grouped := groupItemsBySeason(items)
-
-	expectedGroups := map[string]int{
-		"Show 1 - S01": 2,
-		"Show 2 - S01": 1,
-		"Movies":       1,
-	}
-
-	for group, count := range expectedGroups {
-		if len(grouped[group]) != count {
-			t.Errorf("groupItemsBySeason() group %q has %d items, want %d", group, len(grouped[group]), count)
-		}
-	}
-}

src/watcher.go

@@ -1,142 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/fsnotify/fsnotify"
-)
-
-func watchFolder() {
-	if config.WatchFolder.UsePolling {
-		go pollFolder()
-	}
-
-	if config.WatchFolder.UseInotify {
-		go inotifyWatch()
-	}
-}
-
-func inotifyWatch() {
-	watcher, err := fsnotify.NewWatcher()
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer watcher.Close()
-
-	done := make(chan bool)
-
-	go func() {
-		for {
-			select {
-			case event, ok := <-watcher.Events:
-				if !ok {
-					return
-				}
-				if event.Op&fsnotify.Create == fsnotify.Create {
-					if strings.HasSuffix(event.Name, ".drmd") {
-						fmt.Println("New .drmd detected:", event.Name)
-						processWatchedFile(event.Name)
-					}
-				}
-			case err, ok := <-watcher.Errors:
-				if !ok {
-					return
-				}
-				log.Println("Error:", err)
-			}
-		}
-	}()
-
-	err = watcher.Add(config.WatchFolder.Path)
-	if err != nil {
-		log.Fatal(err)
-	}
-	<-done
-}
-
-func pollFolder() {
-	ticker := time.NewTicker(time.Duration(config.WatchFolder.PollingInterval) * time.Second)
-	defer ticker.Stop()
-
-	for range ticker.C {
-		files, err := filepath.Glob(filepath.Join(config.WatchFolder.Path, "*.drmd"))
-		if err != nil {
-			log.Println("Error polling folder:", err)
-			continue
-		}
-
-		for _, file := range files {
-			fmt.Println("New .drmd detected via polling:", file)
-			go processWatchedFile(file)
-		}
-	}
-}
-
-func processWatchedFile(filePath string) {
-	for {
-		initialSize, err := getFileSize(filePath)
-		if err != nil {
-			logger.LogError("Watcher", fmt.Sprintf("Error getting file size: %v", err))
-			return
-		}
-
-		time.Sleep(1 * time.Second)
-
-		currentSize, err := getFileSize(filePath)
-		if err != nil {
-			logger.LogError("Watcher", fmt.Sprintf("Error getting file size: %v", err))
-			return
-		}
-
-		if initialSize == currentSize {
-			break
-		}
-	}
-
-	file, err := os.Open(filePath)
-	if err != nil {
-		logger.LogError("Watcher", fmt.Sprintf("Error opening file: %v", err))
-		return
-	}
-	defer file.Close()
-
-	originalFilename := filepath.Base(filePath)
-	tempFile, err := os.CreateTemp(uploadDir, originalFilename)
-	if err != nil {
-		logger.LogError("Watcher", fmt.Sprintf("Error creating temporary file: %v", err))
-		return
-	}
-	defer tempFile.Close()
-
-	_, err = io.Copy(tempFile, file)
-	if err != nil {
-		logger.LogError("Watcher", fmt.Sprintf("Error copying file: %v", err))
-		return
-	}
-
-	if err := os.Remove(filePath); err != nil {
-		logger.LogError("Watcher", fmt.Sprintf("Error deleting original file: %v", err))
-	}
-
-	items, err := parseInputFile(tempFile.Name())
-	if err != nil {
-		logger.LogError("Watcher", fmt.Sprintf("Error parsing input file: %v", err))
-		return
-	}
-
-	go processItems(filepath.Base(tempFile.Name()), items)
-}
-
-func getFileSize(filePath string) (int64, error) {
-	fileInfo, err := os.Stat(filePath)
-	if err != nil {
-		return 0, err
-	}
-	return fileInfo.Size(), nil
-}

subtitles.go

@@ -15,16 +15,13 @@ func downloadAndConvertSubtitles(subtitlesURLs string) ([]string, error) {
 	urls := strings.Split(subtitlesURLs, ",")
 
 	for _, url := range urls {
-		logger.LogInfo("Subtitle Download", fmt.Sprintf("Downloading subtitle from %s", url))
 		vttPath, err := downloadSubtitle(url)
 		if err != nil {
-			logger.LogError("Subtitle Download", fmt.Sprintf("Error downloading subtitle: %v", err))
 			return nil, fmt.Errorf("error downloading subtitle: %v", err)
 		}
 
 		srtPath, err := convertVTTtoSRT(vttPath)
 		if err != nil {
-			logger.LogError("Subtitle Download", fmt.Sprintf("Error converting subtitle: %v", err))
 			return nil, fmt.Errorf("error converting subtitle: %v", err)
 		}
 
@@ -35,28 +32,23 @@ func downloadAndConvertSubtitles(subtitlesURLs string) ([]string, error) {
 }
 
 func downloadSubtitle(url string) (string, error) {
-	logger.LogInfo("Download Subtitle", fmt.Sprintf("Starting download from %s", url))
 	resp, err := http.Get(url)
 	if err != nil {
-		logger.LogError("Download Subtitle", fmt.Sprintf("Error getting subtitle URL: %v", err))
 		return "", err
 	}
 	defer resp.Body.Close()
 
 	tempFile, err := os.CreateTemp("", "subtitle_*.vtt")
 	if err != nil {
-		logger.LogError("Download Subtitle", fmt.Sprintf("Error creating temp file: %v", err))
 		return "", err
 	}
 	defer tempFile.Close()
 
 	_, err = io.Copy(tempFile, resp.Body)
 	if err != nil {
-		logger.LogError("Download Subtitle", fmt.Sprintf("Error copying to temp file: %v", err))
 		return "", err
 	}
 
-	logger.LogInfo("Download Subtitle", "Subtitle downloaded successfully")
 	return tempFile.Name(), nil
 }
 
@@ -64,6 +56,5 @@ func convertVTTtoSRT(vttPath string) (string, error) {
 	srtPath := strings.TrimSuffix(vttPath, ".vtt") + ".srt"
 	s1, _ := astisub.OpenFile(vttPath)
 	s1.Write(srtPath)
-	logger.LogInfo("Convert VTT to SRT", fmt.Sprintf("Converted %s to %s", vttPath, srtPath))
 	return srtPath, nil
 }

templates/index

@@ -11,7 +11,7 @@
             color: #d4d4d4;
             line-height: 1.6;
             padding: 20px;
-            max-width: 900px;
+            max-width: 800px;
             margin: 0 auto;
             box-sizing: border-box;
         }
@@ -74,9 +74,6 @@
             display: inline-block;
             width: 5em;
         }
-        .paused {
-            color: #ffa500;
-        }
         @media (max-width: 600px) {
             body {
                 padding: 10px;
@@ -112,7 +109,7 @@
 <body>
     <h1>Simple Downloader</h1>
     <form action="/upload" method="post" enctype="multipart/form-data">
-        <input type="file" name="files" accept=".drmd" multiple>
+        <input type="file" name="file" accept=".drmd">
         <input type="submit" value="Upload and Process">
     </form>
     <h2>Currently Running Jobs</h2>
@@ -123,11 +120,7 @@
                     <a href="/progress?filename={{$filename}}">{{$filename}}</a>
                 </div>
                 <div class="job-info">
-                    Progress: <span class="progress-text">{{printf "%5.1f%%" $info.Percentage}}</span>
+                    Progress: <span class="progress-text">{{printf "%5.1f%%" $info.Percentage}}</span> Current file: {{$info.CurrentFile}}
-                    Current file: {{$info.CurrentFile}}
-                    {{if $info.Paused}}
-                        <span class="paused">(Paused)</span>
-                    {{end}}
                 </div>
             </li>
         {{else}}

templates/progress

@@ -11,7 +11,7 @@
             color: #d4d4d4;
             line-height: 1.6;
             padding: 20px;
-            max-width: 900px;
+            max-width: 800px;
             margin: 0 auto;
             box-sizing: border-box;
         }
@@ -68,7 +68,7 @@
         #abort-button:hover {
             background-color: #d32f2f;
         }
-        #pause-button, #resume-button, #toggle-console {
+        #pause-button, #resume-button {
             background-color: #4CAF50;
             color: white;
             border: none;
@@ -77,7 +77,7 @@
             border-radius: 4px;
             cursor: pointer;
         }
-        #pause-button:hover, #resume-button:hover, #toggle-console:hover {
+        #pause-button:hover, #resume-button:hover {
             background-color: #45a049;
         }
         #resume-button {
@@ -96,17 +96,6 @@
         #back-button:hover {
             background-color: #1976D2;
         }
-        #console {
-            display: none; /* Initially hidden */
-            background-color: black;
-            color: white;
-            height: 300px; /* Adjust height as needed */
-            overflow-y: scroll;
-            white-space: pre; /* Preserve whitespace */
-            font-family: monospace; /* Use monospace font */
-            margin-top: 10px;
-            border: 1px solid #ccc;
-        }
         @media (max-width: 600px) {
             body {
                 padding: 10px;
@@ -138,17 +127,12 @@
     <div>
         <button id="abort-button" onclick="abortDownload()">Abort Download</button>
         <button id="pause-button" onclick="pauseDownload()">Pause Download</button>
-        <button id="resume-button" onclick="resumeDownload()" style="display: none;">Resume Download</button>
+        <button id="resume-button" onclick="resumeDownload()">Resume Download</button>
-        <button id="toggle-console">Toggle Console View</button>
         <button id="back-button" onclick="window.location.href='/'">Back to Index</button>
     </div>
-    <div style="display: none;" id="console"></div>
     <script>
-        let isPaused = false;
-        const filename = "{{.Filename}}";
-
         function updateProgress() {
-            fetch(`/progress?filename=${filename}`, {
+            fetch('/progress?filename={{.Filename}}', {
                 headers: {
                     'Accept': 'application/json'
                 }
@@ -159,28 +143,15 @@
                     document.getElementById('progress-bar').style.width = progress + '%';
                     document.getElementById('progress-text').innerText = progress + '%';
                     document.getElementById('currentFile').innerText = 'Current file: ' + (data.CurrentFile || 'None');
-                    
+                    if (progress < 100) {
-                    isPaused = data.Paused;
-                    updatePauseResumeButtons();
-                    
-                    if (progress < 100 && !isPaused) {
                         setTimeout(updateProgress, 1000);
                     }
                 });
         }
-
+        updateProgress();
-        function updatePauseResumeButtons() {
-            if (isPaused) {
-                document.getElementById('pause-button').style.display = 'none';
-                document.getElementById('resume-button').style.display = 'inline-block';
-            } else {
-                document.getElementById('pause-button').style.display = 'inline-block';
-                document.getElementById('resume-button').style.display = 'none';
-            }
-        }
 
         function abortDownload() {
-            fetch(`/abort?filename=${filename}`, { method: 'POST' })
+            fetch('/abort?filename={{.Filename}}', { method: 'POST' })
                 .then(response => {
                     if (response.ok) {
                         console.log('Abort signal sent. The download will stop soon.');
@@ -191,12 +162,12 @@
         }
 
         function pauseDownload() {
-            fetch(`/pause?filename=${filename}`, { method: 'POST' })
+            fetch('/pause?filename={{.Filename}}', { method: 'POST' })
                 .then(response => {
                     if (response.ok) {
                         console.log('Pause signal sent. The download will pause soon.');
-                        isPaused = true;
+                        document.getElementById('pause-button').style.display = 'none';
-                        updatePauseResumeButtons();
+                        document.getElementById('resume-button').style.display = 'inline-block';
                     } else {
                         alert('Failed to pause the download.');
                     }
@@ -204,45 +175,17 @@
         }
 
         function resumeDownload() {
-            fetch(`/resume?filename=${filename}`, { method: 'POST' })
+            fetch('/resume?filename={{.Filename}}', { method: 'POST' })
                 .then(response => {
                     if (response.ok) {
                         console.log('Resume signal sent. The download will resume soon.');
-                        isPaused = false;
+                        document.getElementById('resume-button').style.display = 'none';
-                        updatePauseResumeButtons();
+                        document.getElementById('pause-button').style.display = 'inline-block';
-                        updateProgress();
                     } else {
                         alert('Failed to resume the download.');
                     }
                 });
         }
-
-        const consoleDiv = document.getElementById('console');
-        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-        const ws = new WebSocket(`${protocol}//${window.location.host}/ws?filename=${filename}`);
-
-        ws.onmessage = function(event) {
-            consoleDiv.textContent += event.data; 
-            consoleDiv.scrollTop = consoleDiv.scrollHeight; 
-        };
-
-        ws.onclose = function() {
-            console.log('WebSocket connection closed');
-        };
-
-        ws.onerror = function(error) {
-            console.error('WebSocket error:', error);
-        };
-
-        document.getElementById('toggle-console').onclick = function() {
-            if (consoleDiv.style.display === "none") {
-                consoleDiv.style.display = "block";
-            } else {
-                consoleDiv.style.display = "none";
-            }
-        };
-
-        updateProgress();
     </script>
 </body>
 </html>

templates/select

@@ -11,7 +11,7 @@
             color: #d4d4d4;
             line-height: 1.6;
             padding: 20px;
-            max-width: 900px;
+            max-width: 800px;
             margin: 0 auto;
             box-sizing: border-box;
         }
@@ -50,44 +50,27 @@
         button:hover, input[type="submit"]:hover {
             background-color: #45a049;
         }
-        #fix-order-button {
-            background-color: #2196F3;
-            color: white;
-            border: none;
-            padding: 10px 15px;
-            margin: 5px;
-            border-radius: 4px;
-            cursor: pointer;
-        }
-        #fix-order-button:hover {
-            background-color: #1976D2;
-        }
     </style>
 </head>
 <body>
     <h1>Select Items to Download</h1>
     <form action="/process" method="post">
-        <input type="hidden" name="filenames" value="{{.Filenames}}">
+        <input type="hidden" name="filename" value="{{.Filename}}">
-        {{range $filename, $fileItems := .AllItems}}
+        {{range $season, $items := .Items}}
-            <h2>{{$filename}}</h2>
+            <div class="season">
-            {{range $season, $items := $fileItems}}
+                <div class="season-title">
-                <div class="season" id="season-{{$filename}}-{{$season}}">
+                    <input type="checkbox" class="season-checkbox" id="season-{{$season}}" checked onchange="toggleSeason('{{$season}}')">
-                    <div class="season-title">
+                    <label for="season-{{$season}}">{{$season}}</label>
-                        <input type="checkbox" class="season-checkbox" id="season-checkbox-{{$filename}}-{{$season}}" checked onchange="toggleSeason('{{$filename}}-{{$season}}')">
-                        <label for="season-checkbox-{{$filename}}-{{$season}}">{{$season}}</label>
-                    </div>
-                    <div class="season-items">
-                    {{range $item := $items}}
-                        <div class="item">
-                            <label>
-                                <input type="checkbox" name="items" value="{{$filename}}:{{$item.Filename}}" checked class="episode-{{$filename}}-{{$season}}">
-                                {{$item.Filename}}
-                            </label>
-                        </div>
-                    {{end}}
-                    </div>
                 </div>
-            {{end}}
+                {{range $item := $items}}
+                    <div class="item">
+                        <label>
+                            <input type="checkbox" name="items" value="{{$item.Filename}}" checked class="episode-{{$season}}">
+                            {{$item.Filename}}
+                        </label>
+                    </div>
+                {{end}}
+            </div>
         {{end}}
         <div>
             <button type="button" onclick="selectAll(true)">Select All</button>
@@ -108,7 +91,7 @@
         }
 
         function toggleSeason(season) {
-            var seasonCheckbox = document.getElementById('season-checkbox-' + season);
+            var seasonCheckbox = document.getElementById('season-' + season);
             var episodeCheckboxes = document.getElementsByClassName('episode-' + season);
             for (var i = 0; i < episodeCheckboxes.length; i++) {
                 episodeCheckboxes[i].checked = seasonCheckbox.checked;

utils.go

@@ -9,7 +9,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"regexp"
-	"sort"
 	"strconv"
 	"strings"
 	"sync"
@@ -139,24 +138,16 @@ func findOrCreateSegmentTimeline(adaptationSet *etree.Element) *etree.Element {
 	return segmentTemplate.CreateElement("SegmentTimeline")
 }
 
-func parseInputFile(filename string) ([]Item, error) {
+func parseInputFile(inputFile string) ([]Item, error) {
-	fileInfo, err := os.Stat(filename)
+	jsonFile, err := os.Open(inputFile)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error opening file %s: %v", inputFile, err)
-	}
-	if fileInfo.IsDir() {
-		return nil, fmt.Errorf("%s is a directory", filename)
 	}
+	defer jsonFile.Close()
 
-	file, err := os.Open(filename)
+	byteValue, err := io.ReadAll(jsonFile)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error reading file %s: %v", inputFile, err)
-	}
-	defer file.Close()
-
-	byteValue, err := io.ReadAll(file)
-	if err != nil {
-		return nil, err
 	}
 
 	byteValue = removeBOM(byteValue)
@@ -164,7 +155,7 @@ func parseInputFile(filename string) ([]Item, error) {
 	var items Items
 	err = json.Unmarshal(byteValue, &items)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error unmarshaling JSON: %v", err)
 	}
 
 	return items.Items, nil
@@ -197,43 +188,6 @@ func filterSelectedItems(items []Item, selectedItems []string) []Item {
 	return filtered
 }
 
-func sortItems(items []Item) {
-	sort.Slice(items, func(i, j int) bool {
-		iMeta := parseMetadata(items[i].Metadata)
-		jMeta := parseMetadata(items[j].Metadata)
-
-		if iMeta.Title != jMeta.Title {
-			return iMeta.Title < jMeta.Title
-		}
-
-		iSeason := extractNumber(iMeta.Season)
-		jSeason := extractNumber(jMeta.Season)
-
-		if iSeason != jSeason {
-			return iSeason < jSeason
-		}
-
-		iEpisode := extractEpisodeNumber(items[i].Filename)
-		jEpisode := extractEpisodeNumber(items[j].Filename)
-
-		return iEpisode < jEpisode
-	})
-}
-
-func extractNumber(s string) int {
-	num, _ := strconv.Atoi(strings.TrimLeft(s, "S"))
-	return num
-}
-
-func extractEpisodeNumber(filename string) int {
-	parts := strings.Split(filename, "E")
-	if len(parts) > 1 {
-		num, _ := strconv.Atoi(parts[1])
-		return num
-	}
-	return 0
-}
-
 func processItems(filename string, items []Item) error {
 	jobsMutex.Lock()
 	jobInfo := &JobInfo{
@@ -253,40 +207,35 @@ func processItems(filename string, items []Item) error {
 		}
 	}()
 
-	sortItems(items)
-
 	for i := 0; i < len(items); i++ {
 		select {
 		case <-jobInfo.AbortChan:
 			updateProgress(filename, 100, "Aborted")
-			logger.LogJobState(filename, "aborted")
 			return fmt.Errorf("download aborted")
 		default:
 			if jobInfo.Paused {
 				select {
 				case <-jobInfo.ResumeChan:
 					jobInfo.Paused = false
-					logger.LogJobState(filename, "resumed")
+					fmt.Printf("Resuming download for %s\n", filename)
 				case <-jobInfo.AbortChan:
 					updateProgress(filename, 100, "Aborted")
-					logger.LogJobState(filename, "aborted")
 					return fmt.Errorf("download aborted")
 				}
 			}
 			updateProgress(filename, float64(i)/float64(len(items))*100, items[i].Filename)
-			err := downloadFile(filename, items[i], jobInfo)
+			err := downloadFile(items[i], jobInfo)
 			if err != nil {
 				if err.Error() == "download paused" {
-					logger.LogJobState(filename, "paused")
 					removeCompletedEpisodes(filename, items[:i])
 					i--
 					continue
 				}
+				fmt.Printf("Error downloading file: %v\n", err)
 			}
 		}
 	}
 	updateProgress(filename, 100, "")
-	logger.LogJobState(filename, "completed successfully")
 	return nil
 }