fixy

backend/app/api/routes.py

@@ -16,7 +16,7 @@ from app.services.image_analyzer import analyze_image
 from app.core.config import get_settings
 from app.utils.exceptions import DeepfakeDetectionError, SetupRequiredError
 from app.core.limiter import limiter
-from app.config_manager import save_guild_config
+from app.config_manager import _load_all_configs, save_guild_config
 
 logger = logging.getLogger(__name__)
 
@@ -87,6 +87,18 @@ async def save_discord_guild_setup(guild_id: str, payload: GuildConfigSchema):
         "config": config_dict
     }
 
+@router.get("/guilds/{guild_id}/config", tags=["Setup"])
+async def get_discord_guild_config(guild_id: str):
+    """Zwraca zapisaną konfigurację dla konkretnego serwera Discord."""
+    configs = _load_all_configs()
+    guild_config = configs.get(guild_id, {})
+    
+    return {
+        "active_text_model": guild_config.get("active_text_model", "none"),
+        "active_image_model": guild_config.get("active_image_model", "none"),
+        "log_channel_id": guild_config.get("log_channel_id", None)
+    }
+
 @router.post(
     "/analyze",
     response_model=AnalysisResponse,
@@ -102,6 +114,8 @@ async def save_discord_guild_setup(guild_id: str, payload: GuildConfigSchema):
 )
 @limiter.limit("1/5seconds")
 async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisResponse:
+    guild_id = payload.guild_id
+    
     if isinstance(payload, TextAnalysisRequest):
         content_type = "text"
     elif isinstance(payload, ImageAnalysisRequest):
@@ -113,12 +127,6 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
         )
 
     settings = get_settings()
-    models = settings.AVAILABLE_MODELS.get(content_type)
-    if not models:
-        raise HTTPException(status_code=400, detail=f"No model available for {content_type} analysis")
-    
-    model = models[0]
-    logger.info(f"Received {content_type} analysis request, model: {model}")
 
     try:
         if content_type == "text":
@@ -127,7 +135,7 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
             if len(payload.text) < 50:
                 raise ValueError("Text content must be at least 50 characters")
             
-            analysis_result = await analyze_text(payload.text)
+            analysis_result = await analyze_text(payload.text, guild_id)
 
         elif content_type == "image":
             image_bytes = await download_file(str(payload.image_url))
@@ -136,10 +144,12 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
             if len(image_bytes) > settings.MAX_CONTENT_SIZES["image"]:
                 raise ValueError(f"Image size exceeds maximum of {settings.MAX_CONTENT_SIZES['image']} bytes")
             
-            analysis_result = await analyze_image(image_bytes)
+            analysis_result = await analyze_image(image_bytes, guild_id)
 
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
+    except SetupRequiredError as e:
+        raise HTTPException(status_code=400, detail=str(e))
     except DeepfakeDetectionError as e:
         raise HTTPException(status_code=e.status_code, detail=e.message)
     except Exception as e:
@@ -147,11 +157,12 @@ async def analyze(request: Request, payload: AnalysisRequest) -> AnalysisRespons
         raise HTTPException(status_code=500, detail=f"Failed to analyze {content_type}")
 
     logger.info(f"{content_type.capitalize()} analysis completed. Result: {analysis_result}")
+    used_model = analysis_result.get("used_model", settings.AVAILABLE_MODELS.get(content_type)[0])
     
     return AnalysisResponse(
         is_deepfake=analysis_result["is_deepfake"],
         confidence=analysis_result["confidence"],
         analysis_time=analysis_result["analysis_time"],
-        used_model=model,
+        used_model=used_model,
         content_type=content_type,
     )

backend/app/models/schemas.py

@@ -5,6 +5,7 @@ from typing import Union, Literal, Optional, Dict, List
 class TextAnalysisRequest(BaseModel):
     content_type: Literal["text"]
     text: str = Field(..., description="Text content to analyze for deepfake detection")
+    guild_id: str = Field(..., description="ID serwera Discord, z którego pochodzi żądanie")
     
     class Config:
         json_schema_extra = {
@@ -18,6 +19,7 @@ class TextAnalysisRequest(BaseModel):
 class ImageAnalysisRequest(BaseModel):
     content_type: Literal["image"]
     image_url: HttpUrl = Field(..., description="URL of the image to analyze")
+    guild_id: str = Field(..., description="ID serwera Discord, z którego pochodzi żądanie")
     
     class Config:
         json_schema_extra = {
@@ -28,37 +30,10 @@ class ImageAnalysisRequest(BaseModel):
         }
 
 
-class VideoAnalysisRequest(BaseModel):
-    content_type: Literal["video"]
-    video_url: HttpUrl = Field(..., description="URL of the video to analyze")
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "content_type": "video",
-                "video_url": "https://example.com/video.mp4"
-            }
-        }
-
-
-class FileAnalysisRequest(BaseModel):
-    content_type: Literal["file"]
-    file_url: HttpUrl = Field(..., description="URL of the file to analyze")
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "content_type": "file",
-                "file_url": "https://example.com/video.mp4"
-            }
-        }
-
 
 AnalysisRequest = Union[
     TextAnalysisRequest,
-    ImageAnalysisRequest,
-    VideoAnalysisRequest,
-    FileAnalysisRequest,
+    ImageAnalysisRequest
 ]
 
 

configManager.js

@@ -1,44 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-const filePath = path.resolve("./guildConfigs.json");
-
-// Domyślne ustawienia (teraz modele są zapisywane dynamicznie w obiekcie)
-export const DEFAULT_CONFIG = {
-	logChannelId: null,
-	models: {} 
-};
-
-export function loadConfig(guildId) {
-	if (!fs.existsSync(filePath)) {
-		fs.writeFileSync(filePath, JSON.stringify({}));
-	}
-	try {
-		const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-		const config = data[guildId] || { ...DEFAULT_CONFIG };
-		
-		// Upewniamy się, że obiekt "models" zawsze istnieje
-		if (!config.models) {
-			config.models = {};
-		}
-		return config;
-	} catch (err) {
-		console.error("Błąd podczas odczytu konfiguracji:", err);
-		return { ...DEFAULT_CONFIG };
-	}
-}
-
-export function saveConfig(guildId, newConfig) {
-	if (!fs.existsSync(filePath)) {
-		fs.writeFileSync(filePath, JSON.stringify({}));
-	}
-	try {
-		const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-		data[guildId] = { ...DEFAULT_CONFIG, ...data[guildId], ...newConfig };
-		fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-		return true;
-	} catch (err) {
-		console.error("Błąd podczas zapisu konfiguracji:", err);
-		return false;
-	}
-}

guildConfigs.json

@@ -1 +0,0 @@
-{}

index.js

@@ -20,8 +20,6 @@ import {
   ChannelType
 } from "discord.js";
 
-import { loadConfig, saveConfig } from "./configManager.js";
-
 const client = new Client({
 	intents: [
 		GatewayIntentBits.Guilds,
@@ -77,6 +75,28 @@ async function fetchAvailableModels() {
 	return null;
 }
 
+async function fetchGuildConfig(guildId) {
+	try {
+		const response = await fetch(`${API_URL}/guilds/${guildId}/config`);
+		if (response.ok) {
+			const data = await response.json();
+			return {
+				logChannelId: data.log_channel_id,
+				models: {
+					text: data.active_text_model || "none",
+					image: data.active_image_model || "none"
+				}
+			};
+		}
+	} catch (err) {
+		console.error(`[CONFIG ERROR] Błąd pobierania konfiguracji dla gildii ${guildId}:`, err.message);
+	}
+	return {
+		logChannelId: null,
+		models: {}
+	};
+}
+
 function preparePayload(input, explicitContentType = null) {
 	const trimmed = input.trim();
 
@@ -194,7 +214,7 @@ function generateSetupView(tempConfig, availableModels) {
 }
 
 async function sendLogToDiscord(guild, embedToSend) {
-	const config = loadConfig(guild.id);
+	const config = await fetchGuildConfig(guild.id);
 	if (!config.logChannelId) return;
 
 	try {
@@ -214,12 +234,7 @@ async function handleAnalysis(interaction, userContent, targetMessage = null, ex
 
 	try {
 		const { type, payload } = preparePayload(userContent, explicitContentType);
-		
-		// DYNAMICZNE POBIERANIE MODELU Z PLIKU KONFIGURACYJNEGO DLA DANEGO FORMATU (np. text, image, video)
-		const chosenModel = serverConfig.models[type];
-		if (chosenModel) {
-			payload.model = chosenModel;
-		}
+		payload.guild_id = interaction.guildId;
 
 		console.log(`Wysyłanie zapytania typu: ${type} do API z modelem: ${payload.model || "domyślny"}...`);
 
@@ -329,28 +344,25 @@ client.on(Events.InteractionCreate, async (interaction) => {
 
 		if (interaction.commandName === "setup") {
 			const guildId = interaction.guildId;
-			const currentConfig = loadConfig(guildId);
-
+            
 			await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
 
-			// Pobieramy aktywne modele bezpośrednio z FastAPI
+			// Pobieramy konfigurację bezpośrednio z FastAPI
+			const currentConfig = await fetchGuildConfig(guildId);
 			const availableModels = await fetchAvailableModels();
 
-			// Jeśli backend nie działa, natychmiast przerywamy i wyświetlamy błąd
 			if (!availableModels || Object.keys(availableModels).length === 0) {
 				return interaction.editReply({
 					content: "❌ **Błąd konfiguracji:** Nie udało się nawiązać połączenia z backendem (FastAPI). Uruchom swój backend w Pythonie i spróbuj ponownie!"
 				});
 			}
 
-			// Inicjalizujemy domyślne modele w konfiguracji, jeśli nie były wcześniej ustawione
 			for (const [contentType, models] of Object.entries(availableModels)) {
 				if (!currentConfig.models[contentType] && models.length > 0) {
 					currentConfig.models[contentType] = models[0];
 				}
 			}
 
-			// Zapisujemy sesję z konfiguracją oraz pobranymi modelami
 			activeSetupSessions.set(guildId, { 
 				config: { ...currentConfig }, 
 				availableModels 
@@ -432,8 +444,9 @@ client.on(Events.InteractionCreate, async (interaction) => {
 							"Content-Type": "application/json"
 						},
 						body: JSON.stringify({
-							active_text_model: tempSession.config.active_text_model || "none",
-							log_channel_id: tempSession.config.log_channel_id || null
+							active_text_model: tempSession.config.models?.text || "none",
+							active_image_model: tempSession.config.models?.image || "none",
+							log_channel_id: tempSession.config.logChannelId || null
 						})
 					});