Add support for exporting movie collections - Add GetCollectionMovies API function to retrieve user collections - Add ExportCollectionMovies function to export collections to CSV - Update configuration to support collection-specific settings - Add tests for collection export functionality

Author: JohanDevl

cmd/export_trakt/main.go

@@ -15,6 +15,7 @@ import (
 func main() {
 	// Parse command line flags
 	configPath := flag.String("config", "config/config.toml", "Path to configuration file")
+	exportType := flag.String("export", "watched", "Type of export (watched, collection, all)")
 	flag.Parse()
 
 	// Initialize logger
@@ -53,25 +54,61 @@ func main() {
 	// Initialize Trakt client
 	traktClient := api.NewClient(cfg, log)
 
+	// Initialize Letterboxd exporter
+	letterboxdExporter := export.NewLetterboxdExporter(cfg, log)
+
+	// Perform the export based on type
+	switch *exportType {
+	case "watched":
+		exportWatchedMovies(traktClient, letterboxdExporter, log)
+	case "collection":
+		exportCollection(traktClient, letterboxdExporter, log)
+	case "all":
+		exportWatchedMovies(traktClient, letterboxdExporter, log)
+		exportCollection(traktClient, letterboxdExporter, log)
+	default:
+		log.Error("errors.invalid_export_type", map[string]interface{}{"type": *exportType})
+		fmt.Printf("Invalid export type: %s. Valid types are 'watched', 'collection', or 'all'\n", *exportType)
+		os.Exit(1)
+	}
+
+	fmt.Println(translator.Translate("app.description", nil))
+}
+
+func exportWatchedMovies(client *api.Client, exporter *export.LetterboxdExporter, log logger.Logger) {
 	// Get watched movies
-	log.Info("export.retrieving_movies", nil)
-	movies, err := traktClient.GetWatchedMovies()
+	log.Info("export.retrieving_watched_movies", nil)
+	movies, err := client.GetWatchedMovies()
 	if err != nil {
 		log.Error("errors.api_request_failed", map[string]interface{}{"error": err.Error()})
 		os.Exit(1)
 	}
 
 	log.Info("export.movies_retrieved", map[string]interface{}{"count": len(movies)})
 
-	// Initialize Letterboxd exporter
-	letterboxdExporter := export.NewLetterboxdExporter(cfg, log)
-
 	// Export movies
-	log.Info("export.exporting_movies", nil)
-	if err := letterboxdExporter.ExportMovies(movies); err != nil {
+	log.Info("export.exporting_watched_movies", nil)
+	if err := exporter.ExportMovies(movies); err != nil {
 		log.Error("export.export_failed", map[string]interface{}{"error": err.Error()})
 		os.Exit(1)
 	}
+}
 
-	fmt.Println(translator.Translate("app.description", nil))
+func exportCollection(client *api.Client, exporter *export.LetterboxdExporter, log logger.Logger) {
+	// Get collection movies
+	log.Info("export.retrieving_collection", nil)
+	movies, err := client.GetCollectionMovies()
+	if err != nil {
+		log.Error("errors.api_request_failed", map[string]interface{}{"error": err.Error()})
+		os.Exit(1)
+	}
+
+	log.Info("export.collection_retrieved", map[string]interface{}{"count": len(movies)})
+
+	// Export collection
+	log.Info("export.exporting_collection", nil)
+	if err := exporter.ExportCollectionMovies(movies); err != nil {
+		log.Error("export.export_failed", map[string]interface{}{"error": err.Error()})
+		os.Exit(1)
+	}
 } 

config/config.toml

@@ -8,6 +8,8 @@ api_base_url = "https://api.trakt.tv"
 # Letterboxd Export Configuration
 [letterboxd]
 export_dir = "exports"
+watched_filename = "trakt-watched-films.csv"
+collection_filename = "trakt-collection-films.csv"
 
 # Export Settings
 [export]

pkg/api/trakt.go

@@ -37,6 +37,12 @@ type Movie struct {
 	LastWatchedAt string    `json:"last_watched_at"`
 }
 
+// CollectionMovie represents a movie in a collection
+type CollectionMovie struct {
+	Movie       MovieInfo `json:"movie"`
+	CollectedAt string    `json:"collected_at"`
+}
+
 // Client represents a Trakt API client
 type Client struct {
 	config     *config.Config
@@ -143,5 +149,68 @@ func (c *Client) GetWatchedMovies() ([]Movie, error) {
 		return nil, fmt.Errorf("failed to parse response: %w", err)
 	}
 
+	return movies, nil
+}
+
+// GetCollectionMovies retrieves the list of movies in the user's collection from Trakt
+func (c *Client) GetCollectionMovies() ([]CollectionMovie, error) {
+	req, err := http.NewRequest("GET", c.config.Trakt.APIBaseURL+"/sync/collection/movies", nil)
+	if err != nil {
+		c.logger.Error("errors.api_request_failed", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Add required headers
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("trakt-api-version", "2")
+	req.Header.Set("trakt-api-key", c.config.Trakt.ClientID)
+	req.Header.Set("Authorization", "Bearer "+c.config.Trakt.AccessToken)
+
+	resp, err := c.makeRequest(req)
+	if err != nil {
+		c.logger.Error("errors.api_request_failed", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return nil, fmt.Errorf("failed to execute request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// Handle rate limiting
+	if limit := resp.Header.Get("X-Ratelimit-Remaining"); limit != "" {
+		remaining, _ := strconv.Atoi(limit)
+		if remaining < 100 {
+			c.logger.Warn("api.rate_limit_warning", map[string]interface{}{
+				"remaining": remaining,
+			})
+		}
+	}
+
+	// Check response status
+	if resp.StatusCode != http.StatusOK {
+		var errorResp map[string]string
+		if err := json.NewDecoder(resp.Body).Decode(&errorResp); err != nil {
+			errorResp = map[string]string{"error": "unknown error"}
+		}
+		c.logger.Error("errors.api_request_failed", map[string]interface{}{
+			"status": resp.StatusCode,
+			"error":  errorResp["error"],
+		})
+		return nil, fmt.Errorf("API request failed with status %d: %s", resp.StatusCode, errorResp["error"])
+	}
+
+	// Parse response
+	var movies []CollectionMovie
+	if err := json.NewDecoder(resp.Body).Decode(&movies); err != nil {
+		c.logger.Error("errors.api_response_parse_failed", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return nil, fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	c.logger.Info("api.collection_movies_fetched", map[string]interface{}{
+		"count": len(movies),
+	})
 	return movies, nil
 } 

pkg/api/trakt_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/JohanDevl/Export_Trakt_4_Letterboxd/pkg/config"
 	"github.com/JohanDevl/Export_Trakt_4_Letterboxd/pkg/logger"
+	"github.com/stretchr/testify/assert"
 )
 
 // MockLogger implements the logger.Logger interface for testing
@@ -377,4 +378,116 @@ func TestResponseParsing(t *testing.T) {
 			tc.validate(t, movies)
 		})
 	}
+}
+
+func TestGetCollectionMovies(t *testing.T) {
+	// Set up mock HTTP server
+	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Check request method and path
+		assert.Equal(t, "GET", r.Method)
+		assert.Equal(t, "/sync/collection/movies", r.URL.Path)
+
+		// Check required headers
+		assert.Equal(t, "application/json", r.Header.Get("Content-Type"))
+		assert.Equal(t, "2", r.Header.Get("trakt-api-version"))
+		assert.Equal(t, "test-client-id", r.Header.Get("trakt-api-key"))
+		assert.Equal(t, "Bearer test-token", r.Header.Get("Authorization"))
+
+		// Set rate limiting headers
+		w.Header().Set("X-Ratelimit-Remaining", "150")
+
+		// Return mock response
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(`[
+			{
+				"movie": {
+					"title": "The Dark Knight",
+					"year": 2008,
+					"ids": {
+						"trakt": 16,
+						"slug": "the-dark-knight-2008",
+						"imdb": "tt0468569",
+						"tmdb": 155
+					}
+				},
+				"collected_at": "2023-01-15T23:40:30.000Z"
+			},
+			{
+				"movie": {
+					"title": "Inception",
+					"year": 2010,
+					"ids": {
+						"trakt": 417,
+						"slug": "inception-2010",
+						"imdb": "tt1375666",
+						"tmdb": 27205
+					}
+				},
+				"collected_at": "2023-03-20T18:25:43.000Z"
+			}
+		]`))
+	}))
+	defer mockServer.Close()
+
+	// Create client with mock server URL
+	mockConfig := &config.Config{
+		Trakt: config.TraktConfig{
+			ClientID:    "test-client-id",
+			AccessToken: "test-token",
+			APIBaseURL:  mockServer.URL,
+		},
+	}
+	mockLogger := &MockLogger{}
+	client := NewClient(mockConfig, mockLogger)
+
+	// Call the method to test
+	movies, err := client.GetCollectionMovies()
+
+	// Assert no error
+	assert.NoError(t, err)
+
+	// Assert movies were correctly parsed
+	assert.Equal(t, 2, len(movies))
+
+	// Assert first movie details
+	assert.Equal(t, "The Dark Knight", movies[0].Movie.Title)
+	assert.Equal(t, 2008, movies[0].Movie.Year)
+	assert.Equal(t, 16, movies[0].Movie.IDs.Trakt)
+	assert.Equal(t, "tt0468569", movies[0].Movie.IDs.IMDB)
+	assert.Equal(t, "2023-01-15T23:40:30.000Z", movies[0].CollectedAt)
+
+	// Assert second movie details
+	assert.Equal(t, "Inception", movies[1].Movie.Title)
+	assert.Equal(t, 2010, movies[1].Movie.Year)
+	assert.Equal(t, 417, movies[1].Movie.IDs.Trakt)
+	assert.Equal(t, "tt1375666", movies[1].Movie.IDs.IMDB)
+	assert.Equal(t, "2023-03-20T18:25:43.000Z", movies[1].CollectedAt)
+}
+
+func TestGetCollectionMoviesError(t *testing.T) {
+	// Set up mock server that returns an error
+	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusUnauthorized)
+		w.Write([]byte(`{"error": "Invalid OAuth token"}`))
+	}))
+	defer mockServer.Close()
+
+	// Create client with mock server URL
+	mockConfig := &config.Config{
+		Trakt: config.TraktConfig{
+			ClientID:    "test-client-id",
+			AccessToken: "invalid-token",
+			APIBaseURL:  mockServer.URL,
+		},
+	}
+	mockLogger := &MockLogger{}
+	client := NewClient(mockConfig, mockLogger)
+
+	// Call the method to test
+	movies, err := client.GetCollectionMovies()
+
+	// Assert error
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "API request failed with status 401")
+	assert.Nil(t, movies)
 } 

pkg/config/config.go

@@ -24,7 +24,9 @@ type TraktConfig struct {
 
 // LetterboxdConfig holds Letterboxd export configuration
 type LetterboxdConfig struct {
-	ExportDir string `toml:"export_dir"`
+	ExportDir          string `toml:"export_dir"`
+	WatchedFilename    string `toml:"watched_filename"`
+	CollectionFilename string `toml:"collection_filename"`
 }
 
 // ExportConfig holds export settings

pkg/export/letterboxd.go

@@ -36,7 +36,13 @@ func (e *LetterboxdExporter) ExportMovies(movies []api.Movie) error {
 		return fmt.Errorf("failed to create export directory: %w", err)
 	}
 
-	filename := fmt.Sprintf("letterboxd-export-%s.csv", time.Now().Format("2006-01-02"))
+	// Use configured filename, or generate one with timestamp if not specified
+	var filename string
+	if e.config.Letterboxd.WatchedFilename != "" {
+		filename = e.config.Letterboxd.WatchedFilename
+	} else {
+		filename = fmt.Sprintf("letterboxd-export-%s.csv", time.Now().Format("2006-01-02"))
+	}
 	filePath := filepath.Join(e.config.Letterboxd.ExportDir, filename)
 
 	file, err := os.Create(filePath)
@@ -85,4 +91,69 @@ func (e *LetterboxdExporter) ExportMovies(movies []api.Movie) error {
 		"path":  filePath,
 	})
 	return nil
+}
+
+// ExportCollectionMovies exports the user's movie collection to a CSV file in Letterboxd format
+func (e *LetterboxdExporter) ExportCollectionMovies(movies []api.CollectionMovie) error {
+	if err := os.MkdirAll(e.config.Letterboxd.ExportDir, 0755); err != nil {
+		e.log.Error("errors.export_dir_create_failed", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return fmt.Errorf("failed to create export directory: %w", err)
+	}
+
+	// Use configured filename, or generate one with timestamp if not specified
+	var filename string
+	if e.config.Letterboxd.CollectionFilename != "" {
+		filename = e.config.Letterboxd.CollectionFilename
+	} else {
+		filename = fmt.Sprintf("collection-export-%s.csv", time.Now().Format("2006-01-02"))
+	}
+	filePath := filepath.Join(e.config.Letterboxd.ExportDir, filename)
+
+	file, err := os.Create(filePath)
+	if err != nil {
+		e.log.Error("errors.file_create_failed", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return fmt.Errorf("failed to create export file: %w", err)
+	}
+	defer file.Close()
+
+	writer := csv.NewWriter(file)
+	defer writer.Flush()
+
+	// Write header
+	header := []string{"Title", "Year", "CollectedDate", "IMDb ID"}
+	if err := writer.Write(header); err != nil {
+		return fmt.Errorf("failed to write header: %w", err)
+	}
+
+	// Write movies
+	for _, movie := range movies {
+		// Parse collected date
+		collectedDate := ""
+		if movie.CollectedAt != "" {
+			if parsedTime, err := time.Parse(time.RFC3339, movie.CollectedAt); err == nil {
+				collectedDate = parsedTime.Format(e.config.Export.DateFormat)
+			}
+		}
+
+		record := []string{
+			movie.Movie.Title,
+			strconv.Itoa(movie.Movie.Year),
+			collectedDate,
+			movie.Movie.IDs.IMDB,
+		}
+
+		if err := writer.Write(record); err != nil {
+			return fmt.Errorf("failed to write movie record: %w", err)
+		}
+	}
+
+	e.log.Info("export.collection_export_complete", map[string]interface{}{
+		"count": len(movies),
+		"path":  filePath,
+	})
+	return nil
 }