Update Readme

Reviewed-on: #4

README.md

@@ -21,18 +21,31 @@ go build -o canvasarchiver ./cmd/canvasarchiver
    ./canvasarchiver
    ```
 
+   Or for files-only mode:
+   ```bash
+   ./canvasarchiver -fo
+   ```
+
 2. On first run, you'll be prompted to authenticate:
    - Visit the provided OAuth URL
    - Authorize the application
    - Copy the authorization code back to the terminal
 
-3. Enter your Course ID when prompted
+3. Enter your Course ID when prompted (or use `-me` to download all enrolled courses)
 
 4. The tool will download:
    - Regular course files (to `Course Files/`)
    - Module content (to `Modules/`)
    - Panopto recordings (to `Recordings/`)
 
+### Flags
+
+| Flag | Description |
+|------|-------------|
+| `-fo` | Files only mode - download all files to a single directory without module structure |
+| `-me` | Download all enrolled courses |
+| `-n` | Prefix modules with order numbers `[1]`, `[2]`, etc. |
+
 
 ## Configuration
 

cmd/canvasarchiver/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"flag"
 	"fmt"
 	"net/http"
 	"os"
@@ -12,6 +13,11 @@ import (
 )
 
 func main() {
+	filesOnly := flag.Bool("fo", false, "Files only mode - download all files to a single directory without module structure")
+	me := flag.Bool("me", false, "Download all enrolled courses")
+	moduleNumbers := flag.Bool("n", false, "Prefix modules with order numbers [1], [2], etc.")
+	flag.Parse()
+
 	httpClient := &http.Client{}
 
 	authenticator := auth.NewAuthenticator(httpClient)
@@ -21,11 +27,31 @@ func main() {
 		return
 	}
 
+	if *me {
+		canvasClient := canvas.NewClient(httpClient, accessToken, "", *filesOnly, *moduleNumbers)
+		courses, err := canvasClient.GetEnrolledCourses()
+		if err != nil {
+			fmt.Printf("Error fetching courses: %v\n", err)
+			return
+		}
+
+		fmt.Printf("[+] Found %d enrolled courses\n", len(courses))
+		for _, course := range courses {
+			fmt.Printf("  -> Downloading: %s (ID: %d)\n", course.Name, course.ID)
+			downloadCourse(httpClient, accessToken, fmt.Sprintf("%d", course.ID), *filesOnly, *moduleNumbers)
+		}
+		return
+	}
+
 	var courseID string
 	fmt.Print("Enter Course ID: ")
 	fmt.Scanln(&courseID)
 
-	canvasClient := canvas.NewClient(httpClient, accessToken, courseID)
+	downloadCourse(httpClient, accessToken, courseID, *filesOnly, *moduleNumbers)
+}
+
+func downloadCourse(httpClient *http.Client, accessToken, courseID string, filesOnly, moduleNumbers bool) {
+	canvasClient := canvas.NewClient(httpClient, accessToken, courseID, filesOnly, moduleNumbers)
 
 	if err := canvasClient.GetCourseInfo(); err != nil {
 		fmt.Printf("Error: %v\n", err)
@@ -40,5 +66,7 @@ func main() {
 
 	canvasClient.DownloadModules(courseRoot)
 
-	panopto.DownloadMainRecordings(httpClient, accessToken, courseID, courseRoot)
+	if !filesOnly {
+		panopto.DownloadMainRecordings(httpClient, accessToken, courseID, courseRoot)
+	}
 }

internal/canvas/client.go

@@ -17,17 +17,23 @@ import (
 )
 
 type Client struct {
-	HTTPClient  *http.Client
+	HTTPClient      *http.Client
-	AccessToken string
+	AccessToken     string
-	CourseID    string
+	CourseID        string
-	CourseName  string
+	CourseName      string
+	FilesOnly       bool
+	ModuleNumbers   bool
+	downloadedFiles map[string]bool
 }
 
-func NewClient(httpClient *http.Client, accessToken, courseID string) *Client {
+func NewClient(httpClient *http.Client, accessToken, courseID string, filesOnly, moduleNumbers bool) *Client {
 	return &Client{
-		HTTPClient:  httpClient,
+		HTTPClient:      httpClient,
-		AccessToken: accessToken,
+		AccessToken:     accessToken,
-		CourseID:    courseID,
+		CourseID:        courseID,
+		FilesOnly:       filesOnly,
+		ModuleNumbers:   moduleNumbers,
+		downloadedFiles: make(map[string]bool),
 	}
 }
 
@@ -47,6 +53,20 @@ func (c *Client) GetCourseInfo() error {
 	return nil
 }
 
+func (c *Client) GetEnrolledCourses() ([]models.Course, error) {
+	req, _ := http.NewRequest("GET", fmt.Sprintf("%s/api/v1/courses?enrollment_state=active&per_page=100", config.BaseURL), nil)
+	req.Header.Set("Authorization", "Bearer "+c.AccessToken)
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var courses []models.Course
+	json.NewDecoder(resp.Body).Decode(&courses)
+	return courses, nil
+}
+
 func (c *Client) DownloadCourseFiles(root string) {
 	fmt.Println("\n[*] Fetching regular course files...")
 
@@ -80,10 +100,24 @@ func (c *Client) DownloadCourseFiles(root string) {
 	fileCount := 0
 	for _, file := range files {
 
+		if c.FilesOnly {
+			if c.downloadedFiles[file.DisplayName] {
+				continue
+			}
+			c.downloadedFiles[file.DisplayName] = true
+		}
+
 		rawFolderPath := folderMap[file.FolderID]
 		safeFolderPath := utils.SanitizePath(rawFolderPath)
 
-		subDir := filepath.Join(root, "Course Files", safeFolderPath)
+		subDir := root
+		if !c.FilesOnly {
+			if safeFolderPath != "" && strings.ToLower(safeFolderPath) != "course files" {
+				subDir = filepath.Join(root, "Course Files", safeFolderPath)
+			} else {
+				subDir = filepath.Join(root, "Course Files")
+			}
+		}
 		os.MkdirAll(subDir, 0o755)
 		path := filepath.Join(subDir, utils.Sanitize(file.DisplayName))
 
@@ -124,10 +158,21 @@ func (c *Client) DownloadModules(courseRoot string) {
 	json.NewDecoder(resp.Body).Decode(&modules)
 	resp.Body.Close()
 
-	for _, mod := range modules {
+	for i, mod := range modules {
-		modBaseDir := filepath.Join(courseRoot, "Modules", utils.Sanitize(mod.Name))
+		modName := mod.Name
+		if c.ModuleNumbers {
+			modName = fmt.Sprintf("[%d] %s", i+1, mod.Name)
+		}
+
+		modBaseDir := courseRoot
+		if !c.FilesOnly {
+			modBaseDir = filepath.Join(courseRoot, "Modules", utils.Sanitize(modName))
+		}
 		os.MkdirAll(modBaseDir, 0o755)
-		fmt.Printf("\n[Module] %s\n", mod.Name)
+
+		if !c.FilesOnly {
+			fmt.Printf("\n[Module] %s\n", modName)
+		}
 
 		subHeaderStack := []string{}
 		lastIndent := 0
@@ -135,13 +180,16 @@ func (c *Client) DownloadModules(courseRoot string) {
 		for _, item := range mod.Items {
 
 			targetDir := modBaseDir
-			if len(subHeaderStack) > 0 {
+			if len(subHeaderStack) > 0 && !c.FilesOnly {
 				targetDir = filepath.Join(modBaseDir, filepath.Join(subHeaderStack...))
 			}
 			os.MkdirAll(targetDir, 0o755)
 
 			switch item.Type {
 			case "SubHeader":
+				if c.FilesOnly {
+					continue
+				}
 				currentIndent := item.Indent
 				if currentIndent <= lastIndent && len(subHeaderStack) > 0 {
 					levelsToKeep := currentIndent
@@ -162,11 +210,28 @@ func (c *Client) DownloadModules(courseRoot string) {
 				c.downloadModuleFile(item, targetDir)
 
 			case "ExternalTool":
+				if c.FilesOnly {
+					continue
+				}
 				indent := strings.Repeat("  ", len(subHeaderStack)+1)
 				fmt.Printf("%s- Found video tool: %s\n", indent, item.Title)
 				panopto.DownloadVideo(c.HTTPClient, c.AccessToken, c.CourseID, targetDir, item.URL, item.Title)
 
+			case "ExternalUrl":
+				if c.FilesOnly {
+					continue
+				}
+				if strings.Contains(item.ExternalURL, "panopto.eu") {
+					indent := strings.Repeat("  ", len(subHeaderStack)+1)
+					fmt.Printf("%s- Found direct video link: %s\n", indent, item.Title)
+
+					panopto.DownloadVideo(c.HTTPClient, c.AccessToken, c.CourseID, targetDir, item.ExternalURL, item.Title)
+				}
+
 			case "Page":
+				if c.FilesOnly {
+					continue
+				}
 				c.searchPageForVideos(item, targetDir)
 			}
 		}
@@ -192,11 +257,18 @@ func (c *Client) downloadModuleFile(item models.ModuleItem, dir string) {
 		return
 	}
 
+	if c.FilesOnly {
+		if c.downloadedFiles[fileMeta.DisplayName] {
+			return
+		}
+		c.downloadedFiles[fileMeta.DisplayName] = true
+	}
+
 	ext := filepath.Ext(fileMeta.DisplayName)
 	origBase := strings.TrimSuffix(fileMeta.DisplayName, ext)
 
 	fileName := fileMeta.DisplayName
-	if !strings.EqualFold(origBase, item.Title) && item.Title != "" {
+	if !c.FilesOnly && !strings.EqualFold(origBase, item.Title) && item.Title != "" {
 		fileName = fmt.Sprintf("%s (%s)%s", origBase, item.Title, ext)
 	}
 

internal/models/models.go

@@ -10,6 +10,7 @@ type TokenResponse struct {
 }
 
 type Course struct {
+	ID   int    `json:"id"`
 	Name string `json:"name"`
 }
 
@@ -30,10 +31,11 @@ type Module struct {
 }
 
 type ModuleItem struct {
-	Title     string `json:"title"`
+	Title       string `json:"title"`
-	Type      string `json:"type"`
+	Type        string `json:"type"`
-	URL       string `json:"url"`
+	URL         string `json:"url"`
-	HTMLURL   string `json:"html_url"`
+	HTMLURL     string `json:"html_url"`
-	ContentID int    `json:"content_id"`
+	ExternalURL string `json:"external_url"`
-	Indent    int    `json:"indent"`
+	ContentID   int    `json:"content_id"`
+	Indent      int    `json:"indent"`
 }

internal/panopto/downloader.go

@@ -45,12 +45,13 @@ func DownloadVideo(httpClient *http.Client, accessToken, courseID, modDir, input
 	}
 
 	var launchURL string
+	isDirectLink := false
+
 	if strings.Contains(inputURL, "/api/v1/") {
 		launchURL = inputURL
-	} else if strings.Contains(inputURL, "panopto.eu") {
-		launchURL = fmt.Sprintf("%s/api/v1/courses/%s/external_tools/sessionless_launch?url=%s",
-			config.BaseURL, courseID, url.QueryEscape(inputURL))
 	} else {
+
+		isDirectLink = true
 		launchURL = fmt.Sprintf("%s/api/v1/courses/%s/external_tools/sessionless_launch?id=%s&launch_type=course_navigation",
 			config.BaseURL, courseID, config.PanoptoID)
 	}
@@ -70,6 +71,7 @@ func DownloadVideo(httpClient *http.Client, accessToken, courseID, modDir, input
 	resp.Body.Close()
 
 	if launchData.URL == "" {
+		fmt.Printf("    [!] No launch URL found (Video skipped)\n")
 		return
 	}
 
@@ -84,17 +86,21 @@ func DownloadVideo(httpClient *http.Client, accessToken, courseID, modDir, input
 	json.NewDecoder(bResp.Body).Decode(&bridgeData)
 	bResp.Body.Close()
 
-	formReq, _ := http.NewRequest("GET", bridgeData.SessionURL, nil)
+	formResp, err := httpClient.Get(bridgeData.SessionURL)
-	formReq.Header.Set("User-Agent", config.UserAgent)
-	formResp, err := httpClient.Do(formReq)
 	if err != nil {
 		return
 	}
-	formHTML, _ := io.ReadAll(formResp.Body)
+	formHTMLBytes, _ := io.ReadAll(formResp.Body)
 	formResp.Body.Close()
+	formHTML := string(formHTMLBytes)
 
-	action := utils.ResolveAction(bridgeData.SessionURL, string(formHTML))
+	if strings.Contains(formHTML, "U hebt geen toegang") || strings.Contains(formHTML, "You do not have access") {
-	formData := utils.ExtractFormFields(string(formHTML))
+		fmt.Printf("    [!] Access denied by Panopto (U hebt geen toegang). Skipping.\n")
+		return
+	}
+
+	action := utils.ResolveAction(bridgeData.SessionURL, formHTML)
+	formData := utils.ExtractFormFields(formHTML)
 
 	pReq, _ := http.NewRequest("POST", action, strings.NewReader(formData.Encode()))
 	pReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
@@ -150,7 +156,31 @@ func DownloadVideo(httpClient *http.Client, accessToken, courseID, modDir, input
 		}
 	}
 
+	// This is for making sure yt-dlp does not auto-start downloading all videos, when access to a hyperlink is denied
 	if finalURL != "" && !strings.Contains(finalURL, "NonFatalError") {
+
+		targetURL := finalURL
+		if isDirectLink {
+			targetURL = inputURL
+
+			checkReq, _ := http.NewRequest("GET", targetURL, nil)
+			checkReq.Header.Set("User-Agent", config.UserAgent)
+
+			checkResp, err := panoptoClient.Do(checkReq)
+			if err == nil {
+				checkResp.Body.Close()
+
+				if checkResp.StatusCode == http.StatusFound || checkResp.StatusCode == http.StatusSeeOther {
+					loc, _ := checkResp.Location()
+					if loc != nil && (strings.Contains(loc.String(), "Login.aspx") || strings.Contains(loc.String(), "Auth")) {
+						fmt.Printf("    [!] Video inaccessible (redirects to Login). Skipping to prevent mass download.\n")
+						return
+					}
+				}
+			}
+
+		}
+
 		cookieFile := filepath.Join(modDir, ".cookies_temp.txt")
 		cData := "# Netscape HTTP Cookie File\n"
 		panoptoDomain, _ := url.Parse("https://vub.cloud.panopto.eu")
@@ -162,14 +192,14 @@ func DownloadVideo(httpClient *http.Client, accessToken, courseID, modDir, input
 		fmt.Printf("    [*] Downloading video: %s\n", title)
 
 		ytCmd := getYoutubeDLCommand()
-
 		cmd := exec.Command(ytCmd,
 			"--no-playlist",
 			"--cookies", cookieFile,
 			"--referer", config.BaseURL+"/",
 			"-P", modDir,
 			"-o", utils.Sanitize(title)+".%(ext)s",
-			finalURL)
+			targetURL)
+
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
 		if err := cmd.Run(); err != nil {