use axum::{ Json, extract::{Path, Query, State}, http::StatusCode, }; use common::models::{ CreateQuestionBankPayload, ImportQuestionFromMySQLPayload, QuestionBank, QuestionBankFilters, QuestionBankType, UpdateQuestionBankPayload, }; use common::{auth::Claims, middleware::Org}; use serde::{Deserialize, Serialize}; use sqlx::PgPool; use uuid::Uuid; // ==================== MySQL Study Plans & Courses ==================== #[derive(Debug, sqlx::FromRow, Serialize, Deserialize)] pub struct MySqlStudyPlan { pub id: i32, pub mysql_id: i32, pub organization_id: Uuid, pub name: String, pub course_type: String, pub is_active: bool, pub created_at: chrono::DateTime, pub updated_at: chrono::DateTime, } #[derive(Debug, sqlx::FromRow, Serialize, Deserialize)] pub struct MySqlCourse { pub id: i32, pub mysql_id: i32, pub organization_id: Uuid, pub study_plan_id: i32, pub name: String, pub level: Option, pub course_type: String, pub level_calculated: Option, pub is_active: bool, pub created_at: chrono::DateTime, pub updated_at: chrono::DateTime, } /// Save or update study plans and courses from MySQL during import pub async fn save_mysql_courses_and_plans( pool: &PgPool, org_id: Uuid, plans: Vec, courses: Vec, ) -> Result<(), String> { let plans_count = plans.len(); let courses_count = courses.len(); tracing::info!("Saving {} study plans and {} courses from MySQL", plans_count, courses_count); // Save study plans first for plan in plans { let course_type = calculate_course_type(&plan.nombre_plan); tracing::debug!("Saving study plan: {} (ID: {})", plan.nombre_plan, plan.id_plan_de_estudios); sqlx::query( r#" INSERT INTO mysql_study_plans (mysql_id, organization_id, name, course_type) VALUES ($1, $2, $3, $4) ON CONFLICT (mysql_id) DO UPDATE SET name = EXCLUDED.name, course_type = EXCLUDED.course_type, updated_at = NOW() "# ) .bind(plan.id_plan_de_estudios) .bind(org_id) .bind(&plan.nombre_plan) .bind(&course_type) .execute(pool) .await .map_err(|e| format!("Failed to save study plan: {}", e))?; } // Save courses for course in courses { // Determine course_type from duration (40h = regular, 80h = intensive) let course_type = calculate_course_type_from_duration(course.duracion); let level_calculated = calculate_course_level(course.nivel_curso); tracing::debug!("Saving course: {} (ID: {}, Plan ID: {})", course.nombre_curso, course.id_cursos, course.id_plan_de_estudios); // Get study_plan_id from mysql_study_plans let study_plan_id: i32 = sqlx::query_scalar( "SELECT id FROM mysql_study_plans WHERE mysql_id = $1 AND organization_id = $2" ) .bind(course.id_plan_de_estudios) .bind(org_id) .fetch_one(pool) .await .map_err(|e| format!("Failed to find study plan: {}", e))?; sqlx::query( r#" INSERT INTO mysql_courses ( mysql_id, organization_id, study_plan_id, name, level, duracion, course_type, level_calculated ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) ON CONFLICT (mysql_id) DO UPDATE SET name = EXCLUDED.name, level = EXCLUDED.level, duracion = EXCLUDED.duracion, course_type = EXCLUDED.course_type, level_calculated = EXCLUDED.level_calculated, updated_at = NOW() "# ) .bind(course.id_cursos) .bind(org_id) .bind(study_plan_id) .bind(&course.nombre_curso) .bind(course.nivel_curso) .bind(course.duracion) .bind(&course_type) .bind(&level_calculated) .execute(pool) .await .map_err(|e| format!("Failed to save course: {}", e))?; } tracing::info!("Successfully saved {} study plans and {} courses", plans_count, courses_count); Ok(()) } fn calculate_course_type(plan_name: &str) -> String { let plan_lower = plan_name.to_lowercase(); if plan_lower.contains("intensive") || plan_lower.contains("intensivo") { "intensive".to_string() } else { "regular".to_string() } } fn calculate_course_type_from_duration(duracion: Option) -> String { match duracion { Some(d) if d as i64 >= 70 => "intensive".to_string(), // 80h or more = intensive _ => "regular".to_string(), // 40h or less = regular } } fn calculate_course_level(nivel: Option) -> String { match nivel { None => "intermediate".to_string(), Some(n) if n <= 2 => "beginner".to_string(), Some(n) if n <= 4 => "beginner_1".to_string(), Some(n) if n <= 6 => "beginner_2".to_string(), Some(n) if n <= 8 => "intermediate".to_string(), Some(n) if n <= 10 => "intermediate_1".to_string(), Some(n) if n <= 12 => "intermediate_2".to_string(), Some(_) => "advanced".to_string(), } } // ==================== Create ==================== /// POST /api/question-bank - Create a new question in the bank pub async fn create_question( Org(org_ctx): Org, claims: Claims, State(pool): State, Json(payload): Json, ) -> Result, (StatusCode, String)> { let question: QuestionBank = sqlx::query_as( r#" INSERT INTO question_bank ( organization_id, created_by, question_text, question_type, options, correct_answer, explanation, points, difficulty, tags, skill_assessed, media_url, media_type, audio_status ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, 'pending') RETURNING * "# ) .bind(org_ctx.id) .bind(claims.sub) .bind(&payload.question_text) .bind(&payload.question_type) .bind(&payload.options) .bind(&payload.correct_answer) .bind(&payload.explanation) .bind(payload.points.unwrap_or(1)) .bind(payload.difficulty.as_deref().unwrap_or("medium")) .bind(payload.tags.as_deref()) .bind(payload.skill_assessed.as_deref()) .bind(payload.media_type.as_deref()) .fetch_one(&pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?; Ok(Json(question)) } // ==================== List ==================== /// GET /api/question-bank - List questions with filters pub async fn list_questions( Org(org_ctx): Org, State(pool): State, Query(filters): Query, ) -> Result>, (StatusCode, String)> { let questions = if filters.question_type.is_none() && filters.difficulty.is_none() && filters.source.is_none() && filters.search.is_none() && filters.has_audio.is_none() { // No filters - simple query sqlx::query_as::<_, QuestionBank>( "SELECT * FROM question_bank WHERE organization_id = $1 AND is_archived = false ORDER BY created_at DESC" ) .bind(org_ctx.id) .fetch_all(&pool) .await } else if filters.question_type.is_some() { sqlx::query_as::<_, QuestionBank>( "SELECT * FROM question_bank WHERE organization_id = $1 AND is_archived = false AND question_type = $2 ORDER BY created_at DESC" ) .bind(org_ctx.id) .bind(filters.question_type.unwrap()) .fetch_all(&pool) .await } else if filters.difficulty.is_some() { sqlx::query_as::<_, QuestionBank>( "SELECT * FROM question_bank WHERE organization_id = $1 AND is_archived = false AND difficulty = $2 ORDER BY created_at DESC" ) .bind(org_ctx.id) .bind(filters.difficulty.as_ref().unwrap()) .fetch_all(&pool) .await } else if filters.source.is_some() { sqlx::query_as::<_, QuestionBank>( "SELECT * FROM question_bank WHERE organization_id = $1 AND is_archived = false AND source = $2 ORDER BY created_at DESC" ) .bind(org_ctx.id) .bind(filters.source.as_ref().unwrap()) .fetch_all(&pool) .await } else if filters.has_audio == Some(true) { sqlx::query_as::<_, QuestionBank>( "SELECT * FROM question_bank WHERE organization_id = $1 AND is_archived = false AND audio_status = 'ready' ORDER BY created_at DESC" ) .bind(org_ctx.id) .fetch_all(&pool) .await } else { // Default fallback sqlx::query_as::<_, QuestionBank>( "SELECT * FROM question_bank WHERE organization_id = $1 AND is_archived = false ORDER BY created_at DESC" ) .bind(org_ctx.id) .fetch_all(&pool) .await } .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?; Ok(Json(questions)) } // ==================== Get ==================== /// GET /api/question-bank/{id} - Get a single question pub async fn get_question( Org(org_ctx): Org, Path(id): Path, State(pool): State, ) -> Result, (StatusCode, String)> { let question: QuestionBank = sqlx::query_as( r#" SELECT * FROM question_bank WHERE id = $1 AND organization_id = $2 AND is_archived = false "# ) .bind(id) .bind(org_ctx.id) .fetch_one(&pool) .await .map_err(|e| match e { sqlx::Error::RowNotFound => (StatusCode::NOT_FOUND, "Question not found".to_string()), _ => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()), })?; Ok(Json(question)) } // ==================== Update ==================== /// PUT /api/question-bank/{id} - Update a question pub async fn update_question( Org(org_ctx): Org, Path(id): Path, State(pool): State, Json(payload): Json, ) -> Result, (StatusCode, String)> { let question: QuestionBank = sqlx::query_as( r#" UPDATE question_bank SET question_text = COALESCE($3, question_text), question_type = COALESCE($4, question_type), options = COALESCE($5, options), correct_answer = COALESCE($6, correct_answer), explanation = COALESCE($7, explanation), points = COALESCE($8, points), difficulty = COALESCE($9, difficulty), tags = COALESCE($10, tags), is_active = COALESCE($11, is_active), is_archived = COALESCE($12, is_archived), updated_at = NOW() WHERE id = $1 AND organization_id = $2 RETURNING * "# ) .bind(id) .bind(org_ctx.id) .bind(payload.question_text) .bind(payload.question_type.map(|t| t.to_string())) .bind(&payload.options) .bind(&payload.correct_answer) .bind(&payload.explanation) .bind(payload.points) .bind(payload.difficulty) .bind(payload.tags.as_deref()) .bind(payload.is_active) .bind(payload.is_archived) .fetch_one(&pool) .await .map_err(|e| match e { sqlx::Error::RowNotFound => (StatusCode::NOT_FOUND, "Question not found".to_string()), _ => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()), })?; Ok(Json(question)) } // ==================== Delete ==================== /// DELETE /api/question-bank/{id} - Delete (archive) a question pub async fn delete_question( Org(org_ctx): Org, Path(id): Path, State(pool): State, ) -> Result { let result = sqlx::query( r#" UPDATE question_bank SET is_archived = true, updated_at = NOW() WHERE id = $1 AND organization_id = $2 "# ) .bind(id) .bind(org_ctx.id) .execute(&pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?; if result.rows_affected() == 0 { return Err((StatusCode::NOT_FOUND, "Question not found".to_string())); } Ok(StatusCode::NO_CONTENT) } // ==================== Import from MySQL ==================== /// POST /api/question-bank/import-mysql - Import questions from MySQL question bank pub async fn import_from_mysql( Org(org_ctx): Org, claims: Claims, State(pool): State, Json(payload): Json, ) -> Result>, (StatusCode, String)> { use serde_json::json; // Connect to MySQL let mysql_url = std::env::var("MYSQL_DATABASE_URL") .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "MYSQL_DATABASE_URL not configured".to_string()))?; let mysql_pool = sqlx::MySqlPool::connect(&mysql_url) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to connect to MySQL: {}", e)))?; // Fetch all study plans and courses from MySQL to sync them let mysql_plans: Vec = sqlx::query_as( r#" SELECT DISTINCT pe.idPlanDeEstudios AS id_plan_de_estudios, pe.Nombre AS nombre_plan FROM plandeestudios pe WHERE pe.Activo = 1 ORDER BY pe.Nombre "# ) .fetch_all(&mysql_pool) .await .map_err(|e| { let error_msg = format!("Failed to fetch: {}", e); tracing::error!("MySQL Error: {}", error_msg); tracing::error!("Check column names in your MySQL database (plandeestudios, curso tables)"); (StatusCode::INTERNAL_SERVER_ERROR, error_msg) })?; tracing::info!("Fetched {} study plans from MySQL", mysql_plans.len()); let mysql_courses: Vec = sqlx::query_as( r#" SELECT DISTINCT c.idCursos AS id_cursos, c.NombreCurso AS nombre_curso, c.NivelCurso AS nivel_curso, pe.idPlanDeEstudios AS id_plan_de_estudios, pe.Nombre AS nombre_plan, c.Duracion AS duracion FROM curso c JOIN plandeestudios pe ON c.idPlanDeEstudios = pe.idPlanDeEstudios WHERE c.Activo = 1 AND pe.Activo = 1 ORDER BY pe.Nombre, c.NivelCurso "# ) .fetch_all(&mysql_pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch courses: {}", e)))?; tracing::info!("Fetched {} courses from MySQL", mysql_courses.len()); // Save plans and courses to PostgreSQL tracing::info!("Saving plans and courses to PostgreSQL..."); save_mysql_courses_and_plans(&pool, org_ctx.id, mysql_plans, mysql_courses) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to save courses/plans: {}", e)))?; // Fetch questions from MySQL let mysql_questions: Vec = if payload.import_all.unwrap_or(false) { // Import ALL questions (no limit) sqlx::query_as( r#" SELECT bp.idPregunta, bp.descripcion, bp.idTipoPregunta, bp.activo, c.idCursos, c.NombreCurso, pe.idPlanDeEstudios, pe.Nombre as PlanNombre FROM bancopreguntas bp JOIN curso c ON bp.idCursos = c.idCursos JOIN plandeestudios pe ON bp.idPlanDeEstudios = pe.idPlanDeEstudios WHERE bp.activo = 1 AND c.Activo = 1 AND pe.Activo = 1 ORDER BY bp.idPregunta "# ) .fetch_all(&mysql_pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch questions: {}", e)))? } else if let Some(course_id) = payload.mysql_course_id { // Import all questions for a specific course (no limit) sqlx::query_as( r#" SELECT bp.idPregunta, bp.descripcion, bp.idTipoPregunta, bp.activo, c.idCursos, c.NombreCurso, pe.idPlanDeEstudios, pe.Nombre as PlanNombre FROM bancopreguntas bp JOIN curso c ON bp.idCursos = c.idCursos JOIN plandeestudios pe ON bp.idPlanDeEstudios = pe.idPlanDeEstudios WHERE bp.idCursos = ? AND bp.activo = 1 AND c.Activo = 1 AND pe.Activo = 1 ORDER BY bp.idPregunta "# ) .bind(course_id) .fetch_all(&mysql_pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch questions: {}", e)))? } else if let Some(question_ids) = payload.question_ids { // Fetch specific question IDs - use simple approach let mut imported_questions: Vec = vec![]; for q_id in question_ids { let mq: Option = sqlx::query_as( r#" SELECT bp.idPregunta, bp.descripcion, bp.idTipoPregunta, bp.activo, c.idCursos, c.NombreCurso, pe.idPlanDeEstudios, pe.Nombre as PlanNombre FROM bancopreguntas bp JOIN curso c ON bp.idCursos = c.idCursos JOIN plandeestudios pe ON bp.idPlanDeEstudios = pe.idPlanDeEstudios WHERE bp.idPregunta = ? AND bp.activo = 1 AND c.Activo = 1 AND pe.Activo = 1 "# ) .bind(q_id) .fetch_optional(&mysql_pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch question {}: {}", q_id, e)))?; if let Some(question) = mq { // Map MySQL question type to platform question type let question_type = map_mysql_question_type(question.id_tipo_pregunta, None); let options = if question_type == QuestionBankType::MultipleChoice { Some(json!(["Opción A", "Opción B", "Opción C", "Opción D"])) } else if question_type == QuestionBankType::TrueFalse { Some(json!(["Verdadero", "Falso"])) } else { None }; let source_metadata = json!({ "mysql_table": "bancopreguntas", "idPregunta": question.id_pregunta, "idCursos": question.id_cursos, "nombre_curso": question.nombre_curso, "idPlanDeEstudios": question.id_plan_de_estudios, "plan_nombre": question.plan_nombre, "idTipoPregunta": question.id_tipo_pregunta, "imported_at": chrono::Utc::now().to_rfc3339(), }); let qb: QuestionBank = sqlx::query_as( r#" INSERT INTO question_bank ( organization_id, created_by, question_text, question_type, options, correct_answer, source, source_metadata, audio_status, is_active ) VALUES ($1, $2, $3, $4, $5, $6, 'imported-mysql', $7, 'pending', true) RETURNING * "# ) .bind(org_ctx.id) .bind(claims.sub) .bind(&question.descripcion) .bind(&question_type) .bind(&options) .bind(&serde_json::Value::Null) .bind(&source_metadata) .fetch_one(&pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to import question {}: {}", question.id_pregunta, e)))?; imported_questions.push(qb); } } mysql_pool.close().await; return Ok(Json(imported_questions)); } else { return Err((StatusCode::BAD_REQUEST, "Must provide course_id, question_ids, or import_all".to_string())); }; mysql_pool.close().await; if mysql_questions.is_empty() { return Err((StatusCode::NOT_FOUND, "No questions found in MySQL to import".to_string())); } // Import questions into PostgreSQL let mut imported_questions: Vec = vec![]; let mut skipped_count = 0; for mq in mysql_questions { // Check if question already imported let exists: (bool,) = sqlx::query_as( "SELECT EXISTS(SELECT 1 FROM question_bank WHERE imported_mysql_id = $1 AND organization_id = $2)" ) .bind(mq.id_pregunta) .bind(org_ctx.id) .fetch_one(&pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to check existing: {}", e)))?; if exists.0 { skipped_count += 1; continue; // Skip already imported question } // Map MySQL question type to platform question type let question_type = map_mysql_question_type(mq.id_tipo_pregunta, None); // Create options for multiple choice (if applicable) let options = if question_type == QuestionBankType::MultipleChoice { Some(json!(["Opción A", "Opción B", "Opción C", "Opción D"])) } else if question_type == QuestionBankType::TrueFalse { Some(json!(["Verdadero", "Falso"])) } else { None }; let source_metadata = json!({ "mysql_table": "bancopreguntas", "idPregunta": mq.id_pregunta, "idCursos": mq.id_cursos, "nombre_curso": mq.nombre_curso, "idPlanDeEstudios": mq.id_plan_de_estudios, "plan_nombre": mq.plan_nombre, "idTipoPregunta": mq.id_tipo_pregunta, "imported_at": chrono::Utc::now().to_rfc3339(), }); let question: QuestionBank = sqlx::query_as( r#" INSERT INTO question_bank ( organization_id, created_by, question_text, question_type, options, correct_answer, source, source_metadata, imported_mysql_id, imported_mysql_course_id, audio_status, is_active ) VALUES ($1, $2, $3, $4, $5, $6, 'imported-mysql', $7, $8, $9, 'pending', true) RETURNING * "# ) .bind(org_ctx.id) .bind(claims.sub) .bind(&mq.descripcion) .bind(&question_type) .bind(&options) .bind(&serde_json::Value::Null) // Correct answer to be filled by user .bind(&source_metadata) .bind(mq.id_pregunta) .bind(mq.id_cursos) .fetch_one(&pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to import question {}: {}", mq.id_pregunta, e)))?; imported_questions.push(question); } tracing::info!("Imported {} questions from MySQL (skipped {} already imported)", imported_questions.len(), skipped_count); Ok(Json(imported_questions)) } // ==================== Helpers ==================== fn map_mysql_question_type(mysql_type: i32, tipo_nombre: Option<&str>) -> QuestionBankType { // Map MySQL question types to platform types // First try by name, then by ID as fallback if let Some(nombre) = tipo_nombre { let nombre_lower = nombre.to_lowercase(); if nombre_lower.contains("selecc") || nombre_lower.contains("múltiple") || nombre_lower.contains("multiple") || nombre_lower.contains("alternativa") { return QuestionBankType::MultipleChoice; } if nombre_lower.contains("verdadero") || nombre_lower.contains("falso") { return QuestionBankType::TrueFalse; } if nombre_lower.contains("emparej") || nombre_lower.contains("match") { return QuestionBankType::Matching; } if nombre_lower.contains("orden") { return QuestionBankType::Ordering; } if nombre_lower.contains("complet") { return QuestionBankType::FillInTheBlanks; } if nombre_lower.contains("ensayo") || nombre_lower.contains("essay") { return QuestionBankType::Essay; } if nombre_lower.contains("corta") || nombre_lower.contains("short") || nombre_lower.contains("texto") { return QuestionBankType::ShortAnswer; } // Audio type in MySQL is typically listening comprehension with multiple choice answers if nombre_lower.contains("audio") || nombre_lower.contains("listening") { return QuestionBankType::MultipleChoice; } } // Fallback to ID mapping match mysql_type { 1 => QuestionBankType::MultipleChoice, // Alternativa 2 => QuestionBankType::MultipleChoice, // Audio (listening comprehension) 3 => QuestionBankType::ShortAnswer, // Texto 4 => QuestionBankType::Matching, 5 => QuestionBankType::Ordering, 6 => QuestionBankType::FillInTheBlanks, 7 => QuestionBankType::Essay, _ => QuestionBankType::MultipleChoice, } } /// Parse MySQL answers JSON and extract options and correct answer fn parse_mysql_answers( answers_json: Option<&str>, question_type: QuestionBankType, ) -> (Option, Option) { if let Some(json_str) = answers_json { if let Ok(answers) = serde_json::from_str::>(json_str) { if !answers.is_empty() { // Extract options (all answer texts) let options: Vec = answers .iter() .filter_map(|a| a.get("texto").and_then(|t| t.as_str()).map(String::from)) .collect(); // Extract correct answer(s) let correct_indices: Vec = answers .iter() .enumerate() .filter(|(_, a)| a.get("es_correcta").and_then(|c| c.as_bool()).unwrap_or(false)) .map(|(i, _)| i) .collect(); let options_json = if !options.is_empty() { Some(serde_json::json!(options)) } else { None }; let correct_answer = if question_type == QuestionBankType::TrueFalse || question_type == QuestionBankType::MultipleChoice { // For multiple choice, store index/indices if correct_indices.len() == 1 { Some(serde_json::json!(correct_indices[0])) } else if correct_indices.len() > 1 { Some(serde_json::json!(correct_indices)) } else { Some(serde_json::json!(0)) // Default to first } } else { // For other types, store the text correct_indices.first() .and_then(|&i| answers.get(i)) .and_then(|a| a.get("texto").and_then(|t| t.as_str())) .map(|t| serde_json::json!(t)) }; return (options_json, correct_answer); } } } // Default values if no answers provided let default_options = match question_type { QuestionBankType::MultipleChoice => Some(serde_json::json!(["Opción A", "Opción B", "Opción C", "Opción D"])), QuestionBankType::TrueFalse => Some(serde_json::json!(["Verdadero", "Falso"])), _ => None, }; (default_options, Some(serde_json::json!(0))) } // ==================== MySQL Integration ==================== /// GET /api/question-bank/mysql-courses - List courses from MySQL for import pub async fn list_mysql_courses( Org(_org_ctx): Org, State(_pool): State, ) -> Result>, (StatusCode, String)> { // Connect to MySQL let mysql_url = std::env::var("MYSQL_DATABASE_URL") .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "MYSQL_DATABASE_URL not configured".to_string()))?; let mysql_pool = sqlx::MySqlPool::connect(&mysql_url) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to connect to MySQL: {}", e)))?; // Fetch courses with their plan names let courses: Vec = sqlx::query_as( r#" SELECT DISTINCT c.idCursos AS id_cursos, c.NombreCurso AS nombre_curso, c.NivelCurso AS nivel_curso, pe.idPlanDeEstudios AS id_plan_de_estudios, pe.Nombre AS nombre_plan, c.Duracion AS duracion FROM curso c JOIN plandeestudios pe ON c.idPlanDeEstudios = pe.idPlanDeEstudios WHERE c.Activo = 1 AND pe.Activo = 1 ORDER BY pe.Nombre, c.NivelCurso "# ) .fetch_all(&mysql_pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch courses: {}", e)))?; mysql_pool.close().await; Ok(Json(courses)) } /// GET /api/question-bank/mysql-plans - Get all study plans from PostgreSQL (imported from MySQL) pub async fn get_mysql_plans( Org(org_ctx): Org, State(pool): State, ) -> Result>, (StatusCode, String)> { // Fetch all study plans from PostgreSQL let plans: Vec = sqlx::query_as( r#" SELECT mysql_id as id_plan_de_estudios, name as nombre_plan FROM mysql_study_plans WHERE organization_id = $1 AND is_active = true ORDER BY name "# ) .bind(org_ctx.id) .fetch_all(&pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch plans: {}", e)))?; Ok(Json(plans)) } /// GET /api/question-bank/mysql-courses - Get courses filtered by plan from PostgreSQL pub async fn get_mysql_courses_by_plan( Org(org_ctx): Org, State(pool): State, Query(filters): Query, ) -> Result>, (StatusCode, String)> { // Fetch courses filtered by plan from PostgreSQL let courses: Vec = sqlx::query_as( r#" SELECT c.mysql_id as id_cursos, c.name as nombre_curso, c.level as nivel_curso, sp.mysql_id as id_plan_de_estudios, sp.name as nombre_plan, c.duracion as duracion FROM mysql_courses c JOIN mysql_study_plans sp ON c.study_plan_id = sp.id WHERE c.organization_id = $1 AND c.is_active = true AND sp.mysql_id = $2 ORDER BY c.level "# ) .bind(org_ctx.id) .bind(filters.plan_id) .fetch_all(&pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch courses: {}", e)))?; Ok(Json(courses)) } #[derive(Debug, Deserialize)] pub struct MySqlCoursesFilters { pub plan_id: i32, } #[derive(Debug, Clone, sqlx::FromRow, Serialize)] pub struct MySqlPlanInfo { pub id_plan_de_estudios: i32, pub nombre_plan: String, } #[derive(Debug, Clone, Serialize, Deserialize, sqlx::FromRow)] pub struct MySqlCourseInfo { pub id_cursos: i32, pub nombre_curso: String, pub nivel_curso: Option, pub id_plan_de_estudios: i32, pub nombre_plan: String, pub duracion: Option, // Duration in hours (40=regular, 80=intensive) - MySQL float type } #[derive(Debug, Serialize, Deserialize)] pub struct ImportAllFromMySQLPayload { pub import_metadata_only: Option, // Only import metadata (courses/plans), not questions } /// POST /api/question-bank/import-mysql-all - Import ALL questions from MySQL (bulk import) pub async fn import_all_from_mysql( Org(org_ctx): Org, claims: Claims, State(pool): State, body: String, ) -> Result, (StatusCode, String)> { use serde_json::json; // Parse optional JSON body let import_metadata_only = if body.trim().is_empty() { false } else { serde_json::from_str::(&body) .map(|p| p.import_metadata_only.unwrap_or(false)) .unwrap_or(false) }; // Connect to MySQL let mysql_url = std::env::var("MYSQL_DATABASE_URL") .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "MYSQL_DATABASE_URL not configured".to_string()))?; let mysql_pool = sqlx::MySqlPool::connect(&mysql_url) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to connect to MySQL: {}", e)))?; // Fetch all study plans and courses from MySQL to sync them let mysql_plans: Vec = sqlx::query_as( r#" SELECT DISTINCT pe.idPlanDeEstudios AS id_plan_de_estudios, pe.Nombre AS nombre_plan FROM plandeestudios pe WHERE pe.Activo = 1 ORDER BY pe.Nombre "# ) .fetch_all(&mysql_pool) .await .map_err(|e| { let error_msg = format!("Failed to fetch: {}", e); tracing::error!("MySQL Error: {}", error_msg); tracing::error!("Check column names in your MySQL database (plandeestudios, curso tables)"); (StatusCode::INTERNAL_SERVER_ERROR, error_msg) })?; tracing::info!("Fetched {} study plans from MySQL", mysql_plans.len()); let mysql_courses: Vec = sqlx::query_as( r#" SELECT DISTINCT c.idCursos AS id_cursos, c.NombreCurso AS nombre_curso, c.NivelCurso AS nivel_curso, pe.idPlanDeEstudios AS id_plan_de_estudios, pe.Nombre AS nombre_plan, c.Duracion AS duracion FROM curso c JOIN plandeestudios pe ON c.idPlanDeEstudios = pe.idPlanDeEstudios WHERE c.Activo = 1 AND pe.Activo = 1 ORDER BY pe.Nombre, c.NivelCurso "# ) .fetch_all(&mysql_pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch courses: {}", e)))?; tracing::info!("Fetched {} courses from MySQL", mysql_courses.len()); // Save plans and courses to PostgreSQL tracing::info!("Saving plans and courses to PostgreSQL..."); save_mysql_courses_and_plans(&pool, org_ctx.id, mysql_plans.clone(), mysql_courses.clone()) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to save courses/plans: {}", e)))?; // If only metadata import is requested, return early if import_metadata_only { return Ok(Json(json!({ "success": true, "message": "Metadatos importados exitosamente", "metadata": { "study_plans_imported": mysql_plans.len(), "courses_imported": mysql_courses.len(), "courses": mysql_courses.iter().map(|c| json!({ "id_cursos": c.id_cursos, "nombre_curso": c.nombre_curso, "nombre_plan": c.nombre_plan, "duracion": c.duracion, "nivel_curso": c.nivel_curso })).collect::>() } }))); } // Fetch ALL questions from MySQL with answers (using JSON aggregation for answers) let mysql_questions: Vec = sqlx::query_as( r#" SELECT bp.idPregunta AS id_pregunta, bp.descripcion AS descripcion, bp.idTipoPregunta AS id_tipo_pregunta, bp.activo AS activo, c.idCursos AS id_cursos, c.NombreCurso AS nombre_curso, c.NivelCurso AS nivel_curso, pe.idPlanDeEstudios AS id_plan_de_estudios, pe.Nombre AS plan_nombre, tp.descripcion AS tipo_pregunta_nombre, CAST( ( SELECT JSON_ARRAYAGG( JSON_OBJECT( 'idRespuesta', br.idRespuesta, 'texto', br.descripcion, 'es_correcta', br.resultado = 1 ) ) FROM bancorespuestas br WHERE br.idPregunta = bp.idPregunta AND br.activo = 1 ) AS CHAR ) AS respuestas_json FROM bancopreguntas bp JOIN curso c ON bp.idCursos = c.idCursos JOIN plandeestudios pe ON bp.idPlanDeEstudios = pe.idPlanDeEstudios JOIN tipopregunta tp ON bp.idTipoPregunta = tp.idTipoPregunta WHERE bp.activo = 1 AND pe.Activo = 1 AND c.Activo = 1 ORDER BY pe.Nombre, c.NombreCurso, bp.idPregunta "# ) .fetch_all(&mysql_pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch questions: {}", e)))?; mysql_pool.close().await; if mysql_questions.is_empty() { return Ok(Json(json!({ "success": false, "imported": 0, "skipped": 0, "updated": 0, "error": "No questions found in MySQL" }))); } // Import questions into PostgreSQL let mut imported_count = 0; let mut skipped_count = 0; let mut updated_count = 0; for mq in mysql_questions { // Check if question already exists let existing: Option<(Uuid, bool)> = sqlx::query_as( "SELECT id, is_active FROM question_bank WHERE imported_mysql_id = $1 AND organization_id = $2" ) .bind(mq.id_pregunta) .bind(org_ctx.id) .fetch_optional(&pool) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Check failed: {}", e)))?; match existing { Some((id, is_active)) => { // Question exists - update if it was inactive or has new data if !is_active { // Reactivate and update let _ = sqlx::query( "UPDATE question_bank SET is_active = true, question_text = $3, updated_at = NOW() WHERE id = $1 AND organization_id = $2" ) .bind(id) .bind(org_ctx.id) .bind(&mq.descripcion) .execute(&pool) .await; updated_count += 1; } else { skipped_count += 1; // Already exists and active, skip } } None => { // New question - insert with answers from MySQL let question_type = map_mysql_question_type(mq.id_tipo_pregunta, mq.tipo_pregunta_nombre.as_deref()); // Parse answers from MySQL let (options, correct_answer) = parse_mysql_answers(mq.respuestas_json.as_deref(), question_type); let has_answers = mq.respuestas_json.is_some(); let question_type_name = mq.tipo_pregunta_nombre.clone(); let source_metadata = serde_json::json!({ "mysql_table": "bancopreguntas", "idPregunta": mq.id_pregunta, "idCursos": mq.id_cursos, "nombre_curso": mq.nombre_curso, "nivel_curso": mq.nivel_curso, "idPlanDeEstudios": mq.id_plan_de_estudios, "plan_nombre": mq.plan_nombre, "idTipoPregunta": mq.id_tipo_pregunta, "tipo_pregunta_nombre": question_type_name, "imported_at": chrono::Utc::now().to_rfc3339(), "import_method": "bulk_import_all", "has_answers": has_answers, }); let _ = sqlx::query( r#" INSERT INTO question_bank ( organization_id, created_by, question_text, question_type, options, correct_answer, source, source_metadata, imported_mysql_id, imported_mysql_course_id, audio_status, is_active ) VALUES ($1, $2, $3, $4, $5, $6, 'imported-mysql', $7, $8, $9, 'pending', true) "# ) .bind(org_ctx.id) .bind(claims.sub) .bind(&mq.descripcion) .bind(&question_type) .bind(&options) .bind(&correct_answer) .bind(&source_metadata) .bind(mq.id_pregunta) .bind(mq.id_cursos) .execute(&pool) .await; imported_count += 1; } } } tracing::info!( "Bulk import from MySQL: {} imported, {} skipped, {} updated", imported_count, skipped_count, updated_count ); Ok(Json(json!({ "success": true, "imported": imported_count, "skipped": skipped_count, "updated": updated_count, "metadata": { "study_plans_imported": mysql_plans.len(), "courses_imported": mysql_courses.len() } }))) } #[derive(Debug, Serialize)] pub struct ImportResult { pub imported: i32, pub skipped: i32, pub updated: i32, pub error: Option, } // Excel import - pendiente de fix // /// POST /api/question-bank/import-excel - Import questions from Excel file // pub async fn import_from_excel( // Org(org_ctx): Org, // claims: Claims, // State(pool): State, // multipart: axum::extract::Multipart, // ) -> Result, (StatusCode, String)> { // // Implementation pending // unimplemented!() // } #[derive(Debug, sqlx::FromRow, Serialize, Deserialize)] pub struct MySqlQuestionFull { pub id_pregunta: i32, pub descripcion: String, pub id_tipo_pregunta: i32, pub activo: bool, pub id_cursos: i32, pub nombre_curso: String, pub nivel_curso: Option, pub id_plan_de_estudios: i32, pub plan_nombre: String, pub respuestas_json: Option, // JSON array de respuestas pub tipo_pregunta_nombre: Option, // Nombre del tipo de pregunta } #[derive(Debug, sqlx::FromRow)] struct MySqlQuestion { id_pregunta: i32, descripcion: String, id_tipo_pregunta: i32, activo: bool, id_cursos: i32, nombre_curso: String, id_plan_de_estudios: i32, plan_nombre: String, } // ==================== AI Generation ==================== #[derive(Debug, Deserialize)] pub struct AIGenerateQuestionPayload { pub question_text: Option, pub question_type: Option, pub difficulty: Option, pub skill: Option, } #[derive(Debug, Serialize, Deserialize)] pub struct AIQuestionResponse { pub question_text: String, pub options: Vec, pub correct_answer: serde_json::Value, pub explanation: String, } /// POST /question-bank/ai-generate - Generate question options/answers using AI (Ollama only) pub async fn ai_generate_question( _org_ctx: Org, _claims: Claims, Json(payload): Json, ) -> Result, (StatusCode, String)> { use std::env; use std::time::Duration; let question_text = payload.question_text.unwrap_or_else(|| "English grammar question".to_string()); let difficulty = payload.difficulty.unwrap_or_else(|| "medium".to_string()); let skill = payload.skill.unwrap_or_else(|| "grammar".to_string()); // Build prompt for AI let system_prompt = format!( r#"You are an expert English Teacher creating quiz questions. Create a multiple-choice question with the following parameters: - Topic/Context: {} - Difficulty: {} - Skill assessed: {} Return ONLY a JSON object with this exact structure: {{ "question_text": "The question text here", "options": ["Option A", "Option B", "Option C", "Option D"], "correct_answer": 0, "explanation": "Detailed explanation of why this is correct" }}"#, question_text, difficulty, skill ); // Call Ollama AI with extended timeout let base_url = env::var("LOCAL_OLLAMA_URL").unwrap_or_else(|_| "http://localhost:11434".to_string()); let model = env::var("LOCAL_LLM_MODEL").unwrap_or_else(|_| "llama3.2:3b".to_string()); let url = format!("{}/api/chat", base_url); let client = reqwest::Client::builder() .timeout(Duration::from_secs(600)) // 10 minutes timeout for slower machines .build() .unwrap_or_else(|_| reqwest::Client::new()); tracing::info!("Calling Ollama at {} with model {}", url, model); let response = client .post(&url) .json(&serde_json::json!({ "model": model, "messages": [ { "role": "system", "content": system_prompt }, { "role": "user", "content": "Generate the question in JSON format" } ], "stream": false, "format": "json" })) .send() .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("AI request failed: {}", e)))?; if !response.status().is_success() { return Err((StatusCode::INTERNAL_SERVER_ERROR, format!("AI API error: {}", response.status()))); } let result: serde_json::Value = response.json().await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to parse AI response: {}", e)))?; // Extract content from Ollama response let content = result .get("message") .and_then(|m| m.get("content")) .and_then(|c| c.as_str()) .ok_or((StatusCode::INTERNAL_SERVER_ERROR, "Invalid AI response format".to_string()))?; // Parse AI response as JSON let ai_question: AIQuestionResponse = serde_json::from_str(content) .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to parse question JSON: {}", e)))?; Ok(Json(ai_question)) } // ==================== Import Courses from MySQL ==================== #[derive(Debug, Serialize, Deserialize)] pub struct ImportCourseFromMySQLPayload { pub mysql_course_id: i32, pub title: Option, // Optional custom title (defaults to MySQL course name) pub description: Option, // Optional description pub pacing_mode: Option, // self_paced or instructor_led } #[derive(Debug, Serialize)] pub struct ImportCourseResult { pub course_id: Uuid, pub course_title: String, pub mysql_course_id: i32, pub modules_created: i32, pub lessons_created: i32, pub message: String, } /// POST /api/question-bank/import-course-mysql - Import a course from MySQL with basic structure pub async fn import_course_from_mysql( Org(org_ctx): Org, claims: Claims, State(pool): State, Json(payload): Json, ) -> Result, (StatusCode, String)> { use common::models::Course; // Connect to MySQL let mysql_url = std::env::var("MYSQL_DATABASE_URL") .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "MYSQL_DATABASE_URL not configured".to_string()))?; let mysql_pool = sqlx::MySqlPool::connect(&mysql_url) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to connect to MySQL: {}", e)))?; // Fetch course info from MySQL let mysql_course: MySqlCourseInfo = sqlx::query_as( r#" SELECT c.idCursos AS id_cursos, c.NombreCurso AS nombre_curso, c.NivelCurso AS nivel_curso, pe.idPlanDeEstudios AS id_plan_de_estudios, pe.Nombre AS nombre_plan, c.Duracion AS duracion FROM curso c JOIN plandeestudios pe ON c.idPlanDeEstudios = pe.idPlanDeEstudios WHERE c.idCursos = ? AND c.Activo = 1 AND pe.Activo = 1 "# ) .bind(payload.mysql_course_id) .fetch_one(&mysql_pool) .await .map_err(|e| { if let sqlx::Error::RowNotFound = e { (StatusCode::NOT_FOUND, format!("Course with ID {} not found in MySQL", payload.mysql_course_id)) } else { (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to fetch course from MySQL: {}", e)) } })?; tracing::info!("Importing course from MySQL: {} (ID: {})", mysql_course.nombre_curso, mysql_course.id_cursos); // Start transaction let mut tx = pool.begin().await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to start transaction: {}", e)))?; // Determine course type and level for structure generation let course_type = calculate_course_type_from_duration(mysql_course.duracion); let level = calculate_course_level(mysql_course.nivel_curso); tracing::info!("Course type: {}, Level: {}", course_type, level); // Create course in PostgreSQL let course_title = payload.title.unwrap_or_else(|| format!("{} ({})", mysql_course.nombre_curso, mysql_course.nombre_plan)); let pacing_mode = payload.pacing_mode.unwrap_or_else(|| "self_paced".to_string()); let description = payload.description.unwrap_or_else(|| format!("Curso importado desde MySQL - Plan: {}", mysql_course.nombre_plan)); let new_course: Course = sqlx::query_as( r#" INSERT INTO courses ( organization_id, instructor_id, title, pacing_mode, description, passing_percentage, certificate_template, imported_mysql_course_id ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING * "# ) .bind(org_ctx.id) .bind(claims.sub) .bind(&course_title) .bind(&pacing_mode) .bind(&description) .bind(60.0) // Default passing percentage .bind(serde_json::json!({ "template": "default", "show_logo": true, "show_instructor": true })) .bind(mysql_course.id_cursos) .fetch_one(&mut *tx) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to create course: {}", e)))?; tracing::info!("Created course in PostgreSQL: {}", new_course.id); // Generate basic course structure based on course type and level let (modules_count, lessons_count) = generate_course_structure( &mut tx, new_course.id, org_ctx.id, &course_type, &level, &mysql_course.nombre_curso, ) .await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e))?; // Commit transaction tx.commit().await .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to commit transaction: {}", e)))?; tracing::info!( "Successfully imported course {} with {} modules and {} lessons", new_course.id, modules_count, lessons_count ); Ok(Json(ImportCourseResult { course_id: new_course.id, course_title: new_course.title.clone(), mysql_course_id: mysql_course.id_cursos, modules_created: modules_count, lessons_created: lessons_count, message: format!("Curso '{}' importado exitosamente con {} módulos y {} lecciones", new_course.title, modules_count, lessons_count), })) } /// Generate basic course structure based on type and level async fn generate_course_structure<'a>( tx: &mut sqlx::Transaction<'a, sqlx::Postgres>, course_id: Uuid, org_id: Uuid, course_type: &str, level: &str, course_name: &str, ) -> Result<(i32, i32), String> { // Define module structure based on course type // Regular (40h): 4 modules // Intensive (80h): 8 modules let modules_config = match course_type { "intensive" => vec![ ("Fundamentos Básicos", 6), ("Gramática Esencial", 6), ("Vocabulario Intermedio", 6), ("Comprensión Auditiva", 6), ("Expresión Oral", 6), ("Lectura y Escritura", 6), ("Práctica Avanzada", 6), ("Proyecto Final", 4), ], _ => vec![ ("Introducción y Fundamentos", 5), ("Gramática Básica", 5), ("Vocabulario Esencial", 5), ("Práctica Integradora", 5), ], }; let mut total_modules = 0; let mut total_lessons = 0; for (module_idx, (module_name, lessons_count)) in modules_config.iter().enumerate() { // Create module let module: common::models::Module = sqlx::query_as( r#" INSERT INTO modules (course_id, organization_id, title, position) VALUES ($1, $2, $3, $4) RETURNING * "# ) .bind(course_id) .bind(org_id) .bind(format!("Módulo {}: {}", module_idx + 1, module_name)) .bind(module_idx as i32) .fetch_one(&mut **tx) .await .map_err(|e| format!("Failed to create module {}: {}", module_idx + 1, e))?; total_modules += 1; // Create lessons for this module for lesson_idx in 0..*lessons_count { let lesson_position = (module_idx * lessons_count + lesson_idx) as i32; let lesson_title = format!("Lección {}.{}", module_idx + 1, lesson_idx + 1); // Determine content type based on position (rotate through types) let content_types = ["video", "document", "interactive", "quiz"]; let content_type = content_types[lesson_idx % content_types.len()]; sqlx::query( r#" INSERT INTO lessons ( module_id, organization_id, title, content_type, content_url, position, is_graded, summary ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) "# ) .bind(module.id) .bind(org_id) .bind(&lesson_title) .bind(content_type) .bind("") // Empty content URL (to be filled by instructor) .bind(lesson_position) .bind(lesson_idx % 4 == 3) // Every 4th lesson is graded (quiz) .bind(format!("Contenido de la lección: {}", lesson_title)) .execute(&mut **tx) .await .map_err(|e| format!("Failed to create lesson {}: {}", lesson_position, e))?; total_lessons += 1; } } Ok((total_modules, total_lessons)) }