versions

.gitea/workflows/ci-dev.yml

@@ -93,6 +93,8 @@ jobs:
         echo "Building DEV image with layer caching..."
         docker build \
           $CACHE_ARGS \
+          --build-arg BUILD_TYPE=dev \
+          --build-arg IMAGE_TAG=dev \
           --tag nfoguard:dev \
           --tag nfoguard:dev-${{ github.sha }} \
           --tag "$CACHE_IMAGE" \

.gitea/workflows/ci.yml

@@ -94,6 +94,8 @@ jobs:
         echo "Building with layer caching..."
         docker build \
           $CACHE_ARGS \
+          --build-arg BUILD_TYPE=production \
+          --build-arg IMAGE_TAG=latest \
           --tag nfoguard:latest \
           --tag nfoguard:${{ github.sha }} \
           --tag "$CACHE_IMAGE" \

Dockerfile

@@ -1,8 +1,16 @@
 FROM python:3.11-slim
 
+# Build arguments for version tagging
+ARG BUILD_TYPE=production
+ARG IMAGE_TAG=latest
+
 # Set working directory
 WORKDIR /app
 
+# Set environment variables for version detection
+ENV BUILD_TYPE=${BUILD_TYPE}
+ENV IMAGE_TAG=${IMAGE_TAG}
+
 # Single layer for all system setup to minimize image size
 RUN apt-get update && apt-get install -y --no-install-recommends \
     sqlite3 curl gosu \

clients/radarr_db_client.py

@@ -270,7 +270,7 @@ class RadarrDbClient:
         FROM "History" h
         WHERE h."MovieId" = %s
         ORDER BY h."Date" ASC
-        LIMIT 3
+        LIMIT 5
         """
         
         if self.db_type == "sqlite":
@@ -287,19 +287,24 @@ class RadarrDbClient:
                 rows = cursor.fetchall()
                 
                 if rows:
-                    _log("INFO", f"Movie {movie_id} history debug - first 3 events:")
+                    _log("INFO", f"Movie {movie_id} history debug - first 5 events:")
                     for i, row in enumerate(rows):
                         event_type = row['event_type'] if self.db_type == "postgresql" else row[0] 
                         event_date = row['event_date'] if self.db_type == "postgresql" else row[1]
                         _log("INFO", f"  Event {i+1}: Type={event_type}, Date={event_date}")
                     
                     first_event_type = rows[0]['event_type'] if self.db_type == "postgresql" else rows[0][0]
-                    # EventType 8 = movieFileRenamed (not 7 as originally thought!)
+                    # EventType 8 = movieFileRenamed
-                    is_rename_first = first_event_type == 8
+                    # Also check for EventType 7 = movieFileRenamed in some Radarr versions
+                    is_rename_first = first_event_type in [7, 8]
                     _log("INFO", f"Movie {movie_id}: First event type={first_event_type}, is_rename_first={is_rename_first}")
+                    
+                    if is_rename_first:
+                        _log("INFO", f"🎯 Movie {movie_id} detected as rename-first scenario - will prefer release dates over import dates")
+                    
                     return is_rename_first
                 else:
-                    _log("INFO", f"Movie {movie_id}: No history events found")
+                    _log("WARNING", f"Movie {movie_id}: No history events found - this could indicate missing data")
                     
         except Exception as e:
             _log("ERROR", f"Error checking first event type for movie {movie_id}: {e}")

nfoguard.py

@@ -538,31 +538,41 @@ class MovieProcessor:
                 movie_id = radarr_movie.get("id")
                 if movie_id:
                     import_date, import_source = self.radarr.get_movie_import_date(movie_id, fallback_to_file_date=config.allow_file_date_fallback)
+                    _log("INFO", f"Movie {imdb_id}: Radarr import result: date={import_date}, source={import_source}")
             
             # Check for special case: rename-first scenario (should prefer release dates)
             if import_source == "radarr:db.prefer_release_dates":
-                _log("INFO", f"Movie {imdb_id} has rename-first history - skipping import, preferring release dates")
+                _log("INFO", f"🎯 Movie {imdb_id} has rename-first history - skipping import, preferring release dates")
                 # Fall through to release date logic below
             # Check if we got a real import date or just file date fallback
             elif import_date and import_source != "radarr:db.file.dateAdded":
+                _log("INFO", f"✅ Movie {imdb_id}: Using import date {import_date} from {import_source}")
                 return import_date, import_source, released
             
-            # Get digital release date for comparison
+            # Get digital release date for comparison/fallback
+            _log("INFO", f"🔍 Movie {imdb_id}: Trying digital release date fallback...")
             digital_date, digital_source = self._get_digital_release_date(imdb_id)
+            _log("INFO", f"Movie {imdb_id}: Digital release result: date={digital_date}, source={digital_source}")
             
             # If we only have file date and release date exists, prefer it if reasonable and enabled
             if import_date and import_source == "radarr:db.file.dateAdded" and digital_date and config.prefer_release_dates_over_file_dates:
                 # Compare dates - prefer release date if it's reasonable
                 if self._should_prefer_release_over_file_date(digital_date, digital_source, released, imdb_id):
+                    _log("INFO", f"✅ Movie {imdb_id}: Preferring digital release date {digital_date} over file date")
                     return digital_date, digital_source, released
                 else:
+                    _log("INFO", f"✅ Movie {imdb_id}: Keeping file date {import_date} - digital date not reasonable")
                     return import_date, import_source, released
             
             # Use whichever we have
             if import_date:
+                _log("INFO", f"✅ Movie {imdb_id}: Using import date {import_date} from {import_source}")
                 return import_date, import_source, released
             elif digital_date:
+                _log("INFO", f"✅ Movie {imdb_id}: Using digital release date {digital_date} from {digital_source}")
                 return digital_date, digital_source, released
+            else:
+                _log("WARNING", f"⚠️ Movie {imdb_id}: No import date OR digital release date found - will try other fallbacks")
         
         else:  # digital_then_import
             # Try digital release first
@@ -771,6 +781,13 @@ try:
 except:
     version = "0.1.0"
 
+# Check if running in dev environment (set during Docker build)
+build_type = os.environ.get('BUILD_TYPE', 'production')
+image_tag = os.environ.get('IMAGE_TAG', 'latest')
+
+if (build_type == 'dev' or 'dev' in image_tag.lower()):
+    version = f"{version}-dev"
+
 app = FastAPI(
     title="NFOGuard",
     description="Webhook server for preserving media import dates",