Deploy: Initial Backend Release v1.0

.gitignore

@@ -0,0 +1,6 @@
+__pycache__
+*.pyc
+.env
+.venv
+venv
+.DS_Store

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.10-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PORT=7860
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsndfile1 \
+    git \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN useradd -m -u 1000 user
+RUN chown -R user:user /app
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/api/deps.py

@@ -0,0 +1,87 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import jwt, JWTError
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.core.config import settings
+from app.models.models import Manajemen
+from sqlalchemy import select
+import logging
+
+logger = logging.getLogger(__name__)
+
+# OAuth2 Scheme
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.API_V1_STR}/auth/login/talent")
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_db)
+) -> dict:
+    """
+    Validasi Token untuk Talent (Mobile App)
+    """
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        user_id: int = payload.get("id")
+        role: str = payload.get("role")
+        
+        if user_id is None or role != "talent":
+            logger.warning(f"Talent Auth Failed: UserID={user_id}, Role={role}")
+            raise credentials_exception
+            
+        return {"idtalent": user_id, "role": role}
+        
+    except JWTError as e:
+        logger.error(f"JWT Error (Talent): {str(e)}")
+        raise credentials_exception
+
+async def get_current_admin_user(
+    token: str = Depends(oauth2_scheme),
+    db: AsyncSession = Depends(get_db)
+) -> Manajemen:
+    """
+    Validasi Token untuk Admin (Web Dashboard)
+    """
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Admin credentials invalid",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        # 1. Decode Token
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        user_id: int = payload.get("id")
+        role: str = payload.get("role")
+        
+        # 2. Validate Role
+        if user_id is None:
+            logger.warning("Admin Auth Failed: No User ID in token")
+            raise credentials_exception
+            
+        # Allow both 'manajemen' and 'admin' roles for flexibility
+        if role not in ["manajemen", "admin"]:
+            logger.warning(f"Admin Auth Failed: Invalid Role '{role}' for user {user_id}")
+            raise credentials_exception
+            
+        # 3. Check Database
+        query = select(Manajemen).where(Manajemen.idmanajemen == user_id)
+        result = await db.execute(query)
+        admin = result.scalar_one_or_none()
+        
+        if admin is None:
+            logger.warning(f"Admin Auth Failed: User ID {user_id} not found in DB")
+            raise credentials_exception
+            
+        return admin
+        
+    except JWTError as e:
+        logger.error(f"JWT Error (Admin): {str(e)}")
+        raise credentials_exception
+    except Exception as e:
+        logger.error(f"Auth Unexpected Error: {str(e)}")
+        raise credentials_exception

app/api/v1/endpoints/auth.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, Depends, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.repositories.talent_repository import TalentRepository
+from app.services.auth_service import AuthService
+from app.schemas.auth import LoginRequest, TalentCreate
+from app.schemas.response import ResponseBase
+
+router = APIRouter()
+
+@router.post("/login", response_model=ResponseBase) 
+async def login_admin(
+    request: LoginRequest,
+    db: AsyncSession = Depends(get_db)
+):
+    repo = TalentRepository(db) 
+    service = AuthService(repo)
+    result = await service.authenticate_admin(request, db)
+    return ResponseBase(data=result, message="Admin login successful")
+
+# Endpoint Talent (Mobile)
+@router.post("/login/talent", response_model=ResponseBase)
+async def login_talent(
+    request: LoginRequest,
+    db: AsyncSession = Depends(get_db)
+):
+    repo = TalentRepository(db)
+    service = AuthService(repo)
+    result = await service.authenticate_talent(request)
+    return ResponseBase(data=result, message="Login successful")
+
+@router.post("/register/talent", response_model=ResponseBase, status_code=status.HTTP_201_CREATED)
+async def register_talent(
+    request: TalentCreate,
+    db: AsyncSession = Depends(get_db)
+):
+    repo = TalentRepository(db)
+    service = AuthService(repo)
+    result = await service.register_talent(request)
+    return ResponseBase(message="Talent created successfully", data={"email": result.email})

app/api/v1/endpoints/conversation.py

@@ -0,0 +1,48 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.services.conversation_service import ConversationService
+from app.schemas.conversation import ChatInput, ChatResponse, ConversationStart, TopicListResponse
+from app.schemas.response import ResponseBase
+from app.api.deps import get_current_user
+
+router = APIRouter()
+
+@router.get("/topics", response_model=ResponseBase[TopicListResponse])
+async def get_topics(db: AsyncSession = Depends(get_db)):
+    service = ConversationService(db)
+    topics = await service.get_topics()
+    return ResponseBase(data={"topics": topics})
+
+@router.get("/start", response_model=ResponseBase[ConversationStart])
+async def start_conversation(
+    db: AsyncSession = Depends(get_db)
+):
+    service = ConversationService(db)
+    result = await service.start_session()
+    
+    return ResponseBase(
+        message="Ready",
+        data=ConversationStart(
+            topic=result["topic"], 
+            initial_question=result["message"]
+        )
+    )
+
+@router.post("/chat", response_model=ResponseBase[ChatResponse])
+async def chat(
+    input_data: ChatInput,
+    db: AsyncSession = Depends(get_db),
+    current_user: dict = Depends(get_current_user)
+):
+    service = ConversationService(db)
+    talent_id = current_user["idtalent"]
+    
+    result = await service.process_chat(
+        user_input=input_data.user_input,
+        duration=input_data.duration,
+        talent_id=talent_id,
+        topic_id=input_data.topic_id
+    )
+    
+    return ResponseBase(data=ChatResponse(**result))

app/api/v1/endpoints/dashboard.py

@@ -0,0 +1,82 @@
+from fastapi import APIRouter, Depends, Query, Body
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.services.dashboard_service import DashboardService
+from app.schemas.dashboard import (
+    DashboardResponse, PaginatedListResponse, 
+    AdminProfile, AdminUpdate, AdminPasswordUpdate
+)
+from app.schemas.response import ResponseBase
+from app.api.deps import get_current_admin_user
+from app.models.models import Manajemen
+from app.utils.time_utils import TimeUtils
+from typing import Optional
+from datetime import datetime
+
+router = APIRouter(dependencies=[Depends(get_current_admin_user)])
+
+@router.get("/dashboard", response_model=ResponseBase[DashboardResponse])
+async def get_dashboard(
+    startDate: Optional[str] = Query(None),
+    endDate: Optional[str] = Query(None),
+    activityLimit: int = Query(10, ge=1, le=200),
+    daysBack: int = Query(30, ge=1),
+    db: AsyncSession = Depends(get_db)
+):
+    service = DashboardService(db)
+    
+    start_dt = datetime.strptime(startDate, "%Y-%m-%d") if startDate else None
+    end_dt = datetime.strptime(endDate, "%Y-%m-%d") if endDate else None
+    
+    data = await service.get_admin_dashboard(
+        limit=activityLimit,
+        days_back=daysBack,
+        start_date=start_dt,
+        end_date=end_dt
+    )
+    return ResponseBase(data=data, message="Dashboard data retrieved")
+
+@router.get("/learners/top-active", response_model=ResponseBase[PaginatedListResponse])
+async def get_top_active(
+    searchQuery: str = Query(None), page: int = 1, limit: int = 10, db: AsyncSession = Depends(get_db)
+):
+    service = DashboardService(db)
+    data = await service.get_leaderboard("topActive", page, limit, searchQuery)
+    return ResponseBase(data=data)
+
+@router.get("/learners/highest-scoring", response_model=ResponseBase[PaginatedListResponse])
+async def get_highest_scoring(
+    category: str = Query("phoneme_material_exercise"), searchQuery: str = Query(None), page: int = 1, limit: int = 10, db: AsyncSession = Depends(get_db)
+):
+    service = DashboardService(db)
+    data = await service.get_leaderboard(category, page, limit, searchQuery)
+    return ResponseBase(data=data)
+
+@router.get("/profile", response_model=ResponseBase[AdminProfile])
+async def get_profile(
+    current_admin: Manajemen = Depends(get_current_admin_user)
+):
+    return ResponseBase(data=AdminProfile(
+        idUser=f"ADM{current_admin.idmanajemen:03d}", 
+        name=current_admin.namamanajemen, 
+        email=current_admin.email, 
+        role="Manajemen",
+        createdAt="2025-01-01 00:00:00", 
+        lastLogin=TimeUtils.format_to_wib(TimeUtils.get_current_time())
+    ))
+
+@router.put("/profile", response_model=ResponseBase)
+async def update_profile(
+    request: AdminUpdate, db: AsyncSession = Depends(get_db), current_admin: Manajemen = Depends(get_current_admin_user)
+):
+    service = DashboardService(db)
+    await service.update_admin(current_admin.idmanajemen, request.nama, request.email)
+    return ResponseBase(message="Profile updated successfully")
+
+@router.put("/profile/change-password", response_model=ResponseBase)
+async def change_password(
+    request: AdminPasswordUpdate, db: AsyncSession = Depends(get_db), current_admin: Manajemen = Depends(get_current_admin_user)
+):
+    service = DashboardService(db)
+    await service.change_admin_password(current_admin.idmanajemen, request.new_password)
+    return ResponseBase(message="Password updated successfully")

app/api/v1/endpoints/exam.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Depends, UploadFile, File, Form, Header, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.services.exam_service import ExamService
+from app.schemas.response import ResponseBase
+from app.schemas.exam import ExamStartResponse, ExamResultResponse
+from app.api.deps import get_current_user
+
+router = APIRouter()
+
+@router.get("/start/{idmateriujian}", response_model=ResponseBase)
+async def start_ujian(
+    idmateriujian: int,
+    authorization: str = Header(None),
+    db: AsyncSession = Depends(get_db)
+):
+    user = get_current_user(authorization)
+    talent_id = user["idtalent"]
+    
+    service = ExamService(db)
+    result = await service.start_exam_session(talent_id, idmateriujian)
+    return ResponseBase(data=result)
+
+@router.post("/compare", response_model=ResponseBase)
+async def compare_exam_voice(
+    idContent: int = Form(...),
+    idUjian: int = Form(...),
+    file: UploadFile = File(...),
+    db: AsyncSession = Depends(get_db)
+):
+    service = ExamService(db)
+    audio_bytes = await file.read()
+    result = await service.process_answer(idUjian, idContent, audio_bytes)
+    return ResponseBase(data=result)
+
+@router.get("/result/{idujian}", response_model=ResponseBase[ExamResultResponse])
+async def get_exam_result(
+    idujian: int,
+    authorization: str = Header(None),
+    db: AsyncSession = Depends(get_db)
+):
+    # Verify user owns the exam? (Optional but recommended)
+    service = ExamService(db)
+    result = await service.finish_exam(idujian)
+    return ResponseBase(data=result)
+
+# Endpoint delete untuk reset ujian (jika user ingin ulang)
+@router.delete("/delete/{idujian}", response_model=ResponseBase)
+async def delete_exam_session(
+    idujian: int,
+    db: AsyncSession = Depends(get_db)
+):
+    # Implementasi delete di repository jika diperlukan
+    # Untuk sekarang return success dummy
+    return ResponseBase(message="Exam session reset")

app/api/v1/endpoints/history.py

@@ -0,0 +1,68 @@
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.repositories.history_repository import HistoryRepository
+from app.schemas.response import ResponseBase
+from app.utils.time_utils import TimeUtils
+
+router = APIRouter()
+
+@router.get("/phoneme", response_model=ResponseBase)
+async def get_phoneme_history(
+    page: int = 1, size: int = 10,
+    db: AsyncSession = Depends(get_db)
+):
+    talent_id = 1
+    repo = HistoryRepository(db)
+    items = await repo.get_phoneme_history(talent_id, skip=(page-1)*size, limit=size)
+    
+    data = []
+    for item in items:
+        raw = item["raw"]
+        data.append({
+            "idsoal": raw.idsoal,
+            "typelatihan": raw.typelatihan,
+            "soal": item["soal_text"],
+            "nilai": raw.nilai,
+            "waktulatihan": TimeUtils.format_to_wib(raw.waktulatihan),
+            "phoneme_comparison": raw.phoneme_comparison
+        })
+    return ResponseBase(data=data)
+
+@router.get("/conversation", response_model=ResponseBase)
+async def get_conversation_history(
+    db: AsyncSession = Depends(get_db)
+):
+    talent_id = 1
+    repo = HistoryRepository(db)
+    rows = await repo.get_conversation_history(talent_id)
+    
+    data = []
+    for model, topic in rows:
+        data.append({
+            "topic": topic,
+            "wpm": model.wpm,
+            "grammar": model.grammar,
+            "waktulatihan": TimeUtils.format_to_wib(model.waktulatihan)
+        })
+    return ResponseBase(data=data)
+
+@router.get("/exam", response_model=ResponseBase)
+async def get_exam_history(
+    db: AsyncSession = Depends(get_db)
+):
+    talent_id = 1
+    repo = HistoryRepository(db)
+    history_data = await repo.get_exam_history(talent_id)
+    
+    formatted_data = []
+    for h in history_data:
+        exam = h["exam"]
+        formatted_data.append({
+            "idujian": exam.idujian,
+            "kategori": exam.kategori,
+            "nilai_total": exam.nilai,
+            "waktuujian": TimeUtils.format_to_wib(exam.waktuujian),
+            "details": h["details"]
+        })
+    return ResponseBase(data=formatted_data)

app/api/v1/endpoints/interview_flow.py

@@ -0,0 +1,63 @@
+from fastapi import APIRouter, Depends, Request
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.services.interview_service import InterviewService
+from app.schemas.response import ResponseBase
+from app.schemas.conversation import ChatInput
+from app.api.deps import get_current_user
+import uuid
+
+router = APIRouter()
+
+@router.get("/start", response_model=ResponseBase)
+async def start_interview(
+    request: Request,
+    db: AsyncSession = Depends(get_db)
+):
+    service = InterviewService(db)
+    session_id = str(uuid.uuid4()) 
+    result = await service.start_session(session_id)
+
+    return ResponseBase(data=result)
+
+@router.get("/status", response_model=ResponseBase)
+async def get_interview_status(
+    request: Request,
+    db: AsyncSession = Depends(get_db)
+):
+    """Resume session if exists"""
+    service = InterviewService(db)
+    session_id = request.headers.get("X-Session-ID")
+    if not session_id:
+        return ResponseBase(success=False, message="Missing Session ID")
+        
+    result = await service.get_session_status(session_id)
+    return ResponseBase(data=result.get("status"), success=result["success"])
+
+@router.post("/answer", response_model=ResponseBase)
+async def answer_question(
+    request: Request,
+    input_data: ChatInput,
+    db: AsyncSession = Depends(get_db)
+):
+    service = InterviewService(db)
+    session_id = request.headers.get("X-Session-ID")
+    if not session_id:
+        return ResponseBase(success=False, message="Missing X-Session-ID header")
+        
+    result = await service.process_answer(session_id, input_data.user_input, input_data.duration)
+    return ResponseBase(data=result)
+
+@router.post("/summary", response_model=ResponseBase)
+async def get_summary(
+    request: Request,
+    current_user: dict = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    service = InterviewService(db)
+    session_id = request.headers.get("X-Session-ID")
+    if not session_id:
+         return ResponseBase(success=False, message="Missing X-Session-ID header")
+
+    result = await service.generate_summary(session_id, current_user["idtalent"])
+    return ResponseBase(data=result)

app/api/v1/endpoints/material.py

@@ -0,0 +1,407 @@
+from fastapi import APIRouter, Depends, UploadFile, File, Form, status, Path, Response, Query
+from fastapi.responses import StreamingResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.services.material_service import MaterialService
+from app.repositories.material_repository import MaterialRepository
+from app.schemas.material import (
+    PhonemeWordCreate, PhonemeWordUpdate,
+    PhonemeSentenceCreate, PhonemeSentenceUpdate,
+    ExamCreate, ExamUpdate,
+    InterviewQuestionCreate, InterviewQuestionUpdate, InterviewQuestionResponse,
+    SwapOrderRequest
+)
+from app.schemas.response import ResponseBase
+from app.utils.time_utils import TimeUtils
+from app.utils.template_generator import TemplateGenerator
+from app.api.deps import get_current_admin_user
+
+router = APIRouter(dependencies=[Depends(get_current_admin_user)])
+
+# --- TEMPLATE DOWNLOAD ENDPOINTS ---
+@router.get("/phoneme-material/import-template")
+async def get_word_template():
+    buffer = TemplateGenerator.get_phoneme_word_template()
+    return StreamingResponse(
+        buffer,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": "attachment; filename=phoneme_word_template.xlsx"}
+    )
+
+@router.get("/exercise-phoneme/import-template")
+async def get_sentence_template():
+    buffer = TemplateGenerator.get_phoneme_sentence_template()
+    return StreamingResponse(
+        buffer,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": "attachment; filename=phoneme_sentence_template.xlsx"}
+    )
+
+@router.get("/exam-phoneme/import-template")
+async def get_exam_template():
+    buffer = TemplateGenerator.get_phoneme_exam_template()
+    return StreamingResponse(
+        buffer,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": "attachment; filename=phoneme_exam_template.xlsx"}
+    )
+
+@router.get("/interview-questions/import-template")
+async def get_interview_template():
+    buffer = TemplateGenerator.get_phoneme_word_template()
+    return StreamingResponse(
+        buffer,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": "attachment; filename=interview_questions_template.xlsx"}
+    )
+
+# =======================
+# PHONEME WORDS
+# =======================
+
+@router.get("/phoneme-material", response_model=ResponseBase)
+async def get_phoneme_materials(
+    search: str = Query(None),
+    page: int = Query(1, ge=1),
+    limit: int = Query(10, ge=1),
+    db: AsyncSession = Depends(get_db)
+):
+    service = MaterialService(MaterialRepository(db))
+    result = await service.get_phoneme_materials_list(page, limit, search)
+    return ResponseBase(data=result)
+
+@router.post("/phoneme-material", response_model=ResponseBase)
+async def add_word(request: PhonemeWordCreate, db: AsyncSession = Depends(get_db)):
+    repo = MaterialRepository(db)
+    data = {
+        "kategori": request.phoneme_category, "kata": request.word,
+        "meaning": request.meaning, "definition": request.word_definition,
+        "fonem": request.phoneme
+    }
+    result = await repo.create_word(data)
+    return ResponseBase(message="Word added", data={"id": result.idmaterifonemkata})
+
+@router.put("/phoneme-material/words/{word_id}", response_model=ResponseBase)
+async def update_word(word_id: int, request: PhonemeWordUpdate, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    data = {}
+    if request.word: data["kata"] = request.word
+    if request.meaning: data["meaning"] = request.meaning
+    if request.word_definition: data["definition"] = request.word_definition
+    if request.phoneme: data["fonem"] = request.phoneme
+    
+    await service.update_word(word_id, data)
+    return ResponseBase(message="Word updated")
+
+@router.delete("/phoneme-material/words/{word_id}", response_model=ResponseBase)
+async def delete_word(word_id: int, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    await service.delete_word(word_id)
+    return ResponseBase(message="Word deleted")
+
+@router.post("/phoneme-material/import", response_model=ResponseBase)
+async def import_words(file: UploadFile = File(...), db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    content = await file.read()
+    result = await service.import_words_from_excel(content)
+    return ResponseBase(message="Import completed", data=result)
+
+@router.get("/phoneme-material/{category}/detail", response_model=ResponseBase)
+async def get_words_by_category_detail(
+    category: str, 
+    page: int = 1, 
+    limit: int = 10, 
+    db: AsyncSession = Depends(get_db)
+):
+    repo = MaterialRepository(db)
+    all_words = await repo.get_words_by_category(category)
+    total = len(all_words)
+    start = (page - 1) * limit
+    end = start + limit
+    paginated_words = all_words[start:end]
+    
+    data = []
+    for w in paginated_words:
+        data.append({
+            "id": w.idmaterifonemkata,
+            "word": w.kata,
+            "meaning": w.meaning,
+            "definition": w.definition,
+            "phoneme": w.fonem
+        })
+        
+    return ResponseBase(data={
+        "data": data,
+        "pagination": {
+            "currentPage": page,
+            "totalRecords": total,
+            "totalPages": (total + limit - 1) // limit
+        }
+    })
+
+# =======================
+# PHONEME SENTENCES
+# =======================
+
+@router.get("/exercise-phoneme", response_model=ResponseBase)
+async def get_exercise_materials(
+    search: str = Query(None),
+    page: int = Query(1, ge=1),
+    limit: int = Query(10, ge=1),
+    db: AsyncSession = Depends(get_db)
+):
+    service = MaterialService(MaterialRepository(db))
+    result = await service.get_exercise_materials_list(page, limit, search)
+    return ResponseBase(data=result)
+
+@router.post("/exercise-phoneme/sentences", response_model=ResponseBase)
+async def add_sentence(request: PhonemeSentenceCreate, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    data = {
+        "kategori": request.phoneme_category,
+        "kalimat": request.sentence,
+        "fonem": request.phoneme
+    }
+    result = await service.create_sentence(data)
+    return ResponseBase(message="Sentence added", data={"id": result.idmaterifonemkalimat})
+
+@router.put("/exercise-phoneme/sentences/{sentence_id}", response_model=ResponseBase)
+async def update_sentence(sentence_id: int, request: PhonemeSentenceUpdate, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    data = {}
+    if request.sentence: data["kalimat"] = request.sentence
+    if request.phoneme: data["fonem"] = request.phoneme
+    await service.update_sentence(sentence_id, data)
+    return ResponseBase(message="Sentence updated")
+
+@router.delete("/exercise-phoneme/sentences/{sentence_id}", response_model=ResponseBase)
+async def delete_sentence(sentence_id: int, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    await service.delete_sentence(sentence_id)
+    return ResponseBase(message="Sentence deleted")
+
+@router.post("/exercise-phoneme/import", response_model=ResponseBase)
+async def import_sentences(file: UploadFile = File(...), db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    content = await file.read()
+    result = await service.import_sentences_from_excel(content)
+    return ResponseBase(message="Import completed", data=result)
+
+@router.get("/exercise-phoneme/{category}/detail", response_model=ResponseBase)
+async def get_sentences_by_category_detail(
+    category: str, 
+    page: int = 1, 
+    limit: int = 10, 
+    db: AsyncSession = Depends(get_db)
+):
+    repo = MaterialRepository(db)
+    all_sentences = await repo.get_sentences_by_category(category)
+    total = len(all_sentences)
+    start = (page - 1) * limit
+    end = start + limit
+    paginated = all_sentences[start:end]
+    
+    data = []
+    for s in paginated:
+        data.append({
+            "id": s.idmaterifonemkalimat,
+            "sentence": s.kalimat,
+            "phoneme": s.fonem
+        })
+        
+    return ResponseBase(data={
+        "data": data,
+        "pagination": {
+            "currentPage": page,
+            "totalRecords": total,
+            "totalPages": (total + limit - 1) // limit
+        }
+    })
+
+# =======================
+# EXAMS
+# =======================
+@router.get("/exam-phoneme", response_model=ResponseBase)
+async def get_exam_materials(
+    search: str = Query(None),
+    page: int = Query(1, ge=1),
+    limit: int = Query(10, ge=1),
+    db: AsyncSession = Depends(get_db)
+):
+    service = MaterialService(MaterialRepository(db))
+    result = await service.get_exam_materials_list(page, limit, search)
+    return ResponseBase(data=result)
+
+@router.post("/exam-phoneme/bulk-sentences", response_model=ResponseBase)
+async def add_exam_bulk(request: ExamCreate, db: AsyncSession = Depends(get_db)):
+    repo = MaterialRepository(db)
+    service = MaterialService(repo)
+    items_dict = [{"sentence": item.sentence, "phoneme": item.phoneme} for item in request.items]
+    result = await service.create_exam(request.category, items_dict)
+    return ResponseBase(message="Exam created", data={"examId": result.idmateriujian})
+
+@router.put("/exam-phoneme/{phoneme_category}/tests/{test_id}", response_model=ResponseBase)
+async def update_exam(phoneme_category: str, test_id: str, request: ExamUpdate, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    try:
+        exam_id = int(test_id.replace("EXM", ""))
+    except ValueError:
+        exam_id = int(test_id)
+        
+    await service.update_exam_sentences(exam_id, request.sentences)
+    return ResponseBase(message="Exam updated")
+
+@router.delete("/exam-phoneme/{phoneme_category}/tests/{test_id}", response_model=ResponseBase)
+async def delete_exam(phoneme_category: str, test_id: str, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    try:
+        exam_id = int(test_id.replace("EXM", ""))
+    except ValueError:
+        exam_id = int(test_id)
+    await service.delete_exam(exam_id)
+    return ResponseBase(message="Exam deleted")
+
+@router.post("/exam-phoneme/import", response_model=ResponseBase)
+async def import_exams(file: UploadFile = File(...), db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    content = await file.read()
+    result = await service.import_exams_from_excel(content)
+    return ResponseBase(message="Import completed", data=result)
+
+@router.get("/exam-phoneme/{category}/detail", response_model=ResponseBase)
+async def get_exam_by_category_detail(
+    category: str,
+    page: int = 1,
+    limit: int = 10,
+    db: AsyncSession = Depends(get_db)
+):
+    from sqlalchemy import select, func
+    from app.models.models import Materiujian, Materiujiankalimat
+    
+    q = select(Materiujian).where(Materiujian.kategori == category)
+    result = await db.execute(q)
+    exams = result.scalars().all()
+    
+    total = len(exams)
+    start = (page - 1) * limit
+    end = start + limit
+    paginated = exams[start:end]
+    
+    data = []
+    for idx, ex in enumerate(paginated):
+        q_count = select(func.count(Materiujiankalimat.idmateriujiankalimat)).where(Materiujiankalimat.idmateriujian == ex.idmateriujian)
+        count = await db.scalar(q_count)
+        
+        data.append({
+            "exam_id": ex.idmateriujian,
+            "test_number": f"Test {start + idx + 1}",
+            "total_sentence": count,
+            "last_update": TimeUtils.format_to_wib(ex.updated_at)
+        })
+        
+    return ResponseBase(data={
+        "exams": data,
+        "pagination": {
+            "currentPage": page,
+            "totalRecords": total,
+            "totalPages": (total + limit - 1) // limit
+        }
+    })
+
+@router.get("/exam-phoneme/{category}/tests/{test_id}/sentences", response_model=ResponseBase)
+async def get_exam_sentences(
+    category: str,
+    test_id: int,
+    db: AsyncSession = Depends(get_db)
+):
+    from sqlalchemy import select
+    from app.models.models import Materiujiankalimat
+    
+    q = select(Materiujiankalimat).where(Materiujiankalimat.idmateriujian == test_id)
+    result = await db.execute(q)
+    sentences = result.scalars().all()
+    
+    data = []
+    for s in sentences:
+        data.append({
+            "id_sentence": s.idmateriujiankalimat,
+            "sentence": s.kalimat,
+            "phoneme": s.fonem
+        })
+        
+    return ResponseBase(data={
+        "testInfo": {"testId": test_id, "phonemeCategory": category},
+        "sentences": data
+    })
+
+# =======================
+# INTERVIEW QUESTIONS
+# =======================
+@router.get("/interview-questions", response_model=ResponseBase)
+async def get_interview_questions(page: int = 1, size: int = 10, db: AsyncSession = Depends(get_db)):
+    repo = MaterialRepository(db)
+    skip = (page - 1) * size
+    questions = await repo.get_interview_questions(skip, size)
+    
+    data = [
+        InterviewQuestionResponse(
+            questionId=f"QST{q.idmateriinterview:03d}",
+            interviewQuestion=q.question,
+            isActive=q.is_active,
+            createdAt=TimeUtils.format_to_wib(q.updated_at),
+            orderPosition=idx + 1 + skip
+        ) for idx, q in enumerate(questions)
+    ]
+    return ResponseBase(data={"interviewQuestions": data})
+
+@router.get("/interview-questions/mobile-order", response_model=ResponseBase)
+async def get_mobile_order(limit: int = None, db: AsyncSession = Depends(get_db)):
+    from sqlalchemy import select
+    from app.models.models import Materiinterview
+    
+    q = select(Materiinterview).where(Materiinterview.is_active == True).order_by(Materiinterview.idmateriinterview.asc())
+    if limit:
+        q = q.limit(limit)
+        
+    result = await db.execute(q)
+    questions = result.scalars().all()
+    
+    data = [{"id": q.idmateriinterview, "question": q.question} for q in questions]
+    return ResponseBase(data={"questions": data})
+
+@router.post("/interview-questions", response_model=ResponseBase)
+async def add_interview_question(request: InterviewQuestionCreate, db: AsyncSession = Depends(get_db)):
+    repo = MaterialRepository(db)
+    result = await repo.create_interview_question(request.interview_question)
+    return ResponseBase(status_code=status.HTTP_201_CREATED, message="Question added", data={"id": result.idmateriinterview})
+
+@router.put("/interview-questions/{question_id}", response_model=ResponseBase)
+async def update_interview_question(question_id: int, request: InterviewQuestionUpdate, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    await service.update_interview(question_id, request.interview_question)
+    return ResponseBase(message="Question updated")
+
+@router.delete("/interview-questions/{question_id}", response_model=ResponseBase)
+async def delete_interview_question(question_id: int, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    await service.delete_interview(question_id)
+    return ResponseBase(message="Question deleted")
+
+@router.post("/interview-questions/{question_id}/toggle", response_model=ResponseBase)
+async def toggle_interview_status(question_id: int, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    result = await service.toggle_interview(question_id)
+    return ResponseBase(message="Status toggled", data={"isActive": result.is_active})
+
+@router.post("/interview-questions/{question_id}/swap", response_model=ResponseBase)
+async def swap_interview_order(question_id: int, request: SwapOrderRequest, db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    await service.swap_interview(question_id, request.direction)
+    return ResponseBase(message=f"Swapped {request.direction}")
+
+@router.post("/interview-questions/import", response_model=ResponseBase)
+async def import_interview_questions(file: UploadFile = File(...), db: AsyncSession = Depends(get_db)):
+    service = MaterialService(MaterialRepository(db))
+    content = await file.read()
+    result = await service.import_interview_questions_from_excel(content)
+    return ResponseBase(message="Import completed", data=result)

app/api/v1/endpoints/mobile_profile.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.services.profile_service import ProfileService
+from app.schemas.response import ResponseBase
+from app.api.deps import get_current_user
+
+router = APIRouter()
+
+@router.get("/summary", response_model=ResponseBase)
+async def get_profile_summary(
+    current_user: dict = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    service = ProfileService(db)
+    data = await service.get_mobile_profile(current_user["idtalent"])
+    return ResponseBase(data=data)

app/api/v1/endpoints/phoneme.py

@@ -0,0 +1,104 @@
+from fastapi import APIRouter, Depends, UploadFile, File, Form, Path
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.services.phoneme_service import PhonemeService
+from app.repositories.material_repository import MaterialRepository
+from app.repositories.score_repository import ScoreRepository
+from app.schemas.response import ResponseBase
+from app.schemas.phoneme import PhonemeCheckResponse
+
+router = APIRouter()
+
+@router.post("/compare", response_model=ResponseBase[PhonemeCheckResponse])
+async def compare_phonemes(
+    idContent: int = Form(...),
+    type: str = Form("sentence"),
+    file: UploadFile = File(...),
+    db: AsyncSession = Depends(get_db)
+):
+    talent_id = 1 # TODO: Auth
+    mat_repo = MaterialRepository(db)
+    score_repo = ScoreRepository(db)
+    service = PhonemeService(mat_repo, score_repo)
+
+    audio_content = await file.read()
+    result = await service.process_pronunciation(talent_id, idContent, audio_content, type)
+    return ResponseBase(message="Analysis completed", data=PhonemeCheckResponse(**result))
+
+@router.post("/compare_word", response_model=ResponseBase[PhonemeCheckResponse])
+async def compare_phonemes_word(
+    idContent: int = Form(...),
+    file: UploadFile = File(...),
+    db: AsyncSession = Depends(get_db)
+):
+    """Alias khusus untuk compare word (mobile legacy)"""
+    return await compare_phonemes(idContent=idContent, type="word", file=file, db=db)
+
+# --- MISSING ENDPOINTS RESTORED ---
+
+@router.get("/word_by_id/{id}", response_model=ResponseBase)
+async def get_word_by_id(id: int, db: AsyncSession = Depends(get_db)):
+    mat_repo = MaterialRepository(db)
+    score_repo = ScoreRepository(db)
+    service = PhonemeService(mat_repo, score_repo)
+    data = await service.get_word_by_id(id)
+    return ResponseBase(data=data)
+
+@router.get("/sentence_by_id/{id}", response_model=ResponseBase)
+async def get_sentence_by_id(id: int, db: AsyncSession = Depends(get_db)):
+    mat_repo = MaterialRepository(db)
+    score_repo = ScoreRepository(db)
+    service = PhonemeService(mat_repo, score_repo)
+    data = await service.get_sentence_by_id(id)
+    return ResponseBase(data=data)
+
+@router.get("/random_word/{phoneme}", response_model=ResponseBase)
+async def get_random_word(phoneme: str, db: AsyncSession = Depends(get_db)):
+    mat_repo = MaterialRepository(db)
+    score_repo = ScoreRepository(db)
+    service = PhonemeService(mat_repo, score_repo)
+    data = await service.get_random_word(phoneme)
+    if not data: return ResponseBase(success=False, message="No data found")
+    return ResponseBase(data=data)
+
+@router.get("/random_sentence/{phoneme}", response_model=ResponseBase)
+async def get_random_sentence(phoneme: str, db: AsyncSession = Depends(get_db)):
+    mat_repo = MaterialRepository(db)
+    score_repo = ScoreRepository(db)
+    service = PhonemeService(mat_repo, score_repo)
+    data = await service.get_random_sentence(phoneme)
+    if not data: return ResponseBase(success=False, message="No data found")
+    return ResponseBase(data=data)
+
+# --- CATEGORY LISTS (Mobile) ---
+@router.get("/phoneme_words_categories", response_model=ResponseBase)
+async def get_word_categories(db: AsyncSession = Depends(get_db)):
+    repo = MaterialRepository(db)
+    categories = await repo.get_all_word_categories()
+    return ResponseBase(data={"categories": categories})
+
+@router.get("/phoneme_sentences_categories", response_model=ResponseBase)
+async def get_sentence_categories(db: AsyncSession = Depends(get_db)):
+    repo = MaterialRepository(db)
+    categories = await repo.get_all_sentence_categories()
+    return ResponseBase(data={"categories": categories})
+
+@router.get("/words_by_category/{category}", response_model=ResponseBase)
+async def get_words_by_category(category: str, db: AsyncSession = Depends(get_db)):
+    repo = MaterialRepository(db)
+    words = await repo.get_words_by_category(category)
+    data = [{
+        "idContent": w.idmaterifonemkata, "content": w.kata, 
+        "phoneme": w.fonem, "phoneme_category": w.kategori
+    } for w in words]
+    return ResponseBase(data={"category": category, "words": data})
+
+@router.get("/sentences_by_category/{category}", response_model=ResponseBase)
+async def get_sentences_by_category(category: str, db: AsyncSession = Depends(get_db)):
+    repo = MaterialRepository(db)
+    sentences = await repo.get_sentences_by_category(category)
+    data = [{
+        "idContent": s.idmaterifonemkalimat, "content": s.kalimat, 
+        "phoneme": s.fonem, "phoneme_category": s.kategori
+    } for s in sentences]
+    return ResponseBase(data={"category": category, "sentences": data})

app/api/v1/endpoints/pretest.py

@@ -0,0 +1,76 @@
+from fastapi import APIRouter, Depends, UploadFile, File, Form, Header
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.repositories.material_repository import MaterialRepository
+from app.repositories.talent_repository import TalentRepository
+from app.services.phoneme_service import PhonemeService
+from app.services.audio_service import AudioService
+from app.utils.phoneme_utils import PhonemeMatcher
+from app.schemas.response import ResponseBase
+from app.api.deps import get_current_user
+from app.models.models import Talent
+
+router = APIRouter()
+
+@router.get("/check", response_model=ResponseBase)
+async def check_onboarding(
+    current_user: dict = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Cek apakah user sudah pretest"""
+    talent_repo = TalentRepository(db)
+    talent = await talent_repo.get_by_id(current_user["idtalent"])
+    show_onboarding = talent.pretest_score is None if talent else False
+    return ResponseBase(data={"show_onboarding": show_onboarding})
+
+@router.get("/start", response_model=ResponseBase)
+async def start_pretest(db: AsyncSession = Depends(get_db)):
+    """Ambil 10 soal acak untuk pretest"""
+    repo = MaterialRepository(db)
+    questions = await repo.get_random_sentences(limit=10)
+    data = [
+        {
+            "id": q.idmaterifonemkalimat,
+            "kategori": q.kategori,
+            "kalimat": q.kalimat,
+            "fonem": q.fonem
+        } for q in questions
+    ]
+    return ResponseBase(data=data)
+
+@router.post("/compare", response_model=ResponseBase)
+async def compare_pretest(
+    idContent: int = Form(...),
+    file: UploadFile = File(...),
+    db: AsyncSession = Depends(get_db)
+):
+    """Analisis audio pretest (tanpa simpan ke DB history, hanya return score)"""
+    repo = MaterialRepository(db)
+    content = await repo.get_phoneme_content(idContent, "sentence")
+    if not content: return ResponseBase(success=False, message="Content not found")
+    
+    audio_bytes = await file.read()
+    user_phonemes = await AudioService.transcribe(audio_bytes)
+    alignment = PhonemeMatcher.align_phonemes(content.fonem, user_phonemes)
+    score = PhonemeMatcher.calculate_accuracy(alignment)
+    
+    return ResponseBase(data={
+        "similarity_percent": f"{score}%",
+        "phoneme_comparison": alignment,
+        "user_phonemes": user_phonemes,
+        "target_phonemes": content.fonem
+    })
+
+@router.post("/submit", response_model=ResponseBase)
+async def submit_pretest(
+    payload: dict, # {"score": float}
+    current_user: dict = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db)
+):
+    """Simpan nilai akhir pretest ke profil talent"""
+    talent_repo = TalentRepository(db)
+    talent = await talent_repo.get_by_id(current_user["idtalent"])
+    if talent:
+        await talent_repo.update(talent, {"pretest_score": payload.get("score", 0)})
+        return ResponseBase(message="Pretest score saved")
+    return ResponseBase(success=False, message="Talent not found")

app/api/v1/endpoints/talents.py

@@ -0,0 +1,130 @@
+from fastapi import APIRouter, Depends, Query, UploadFile, File, HTTPException, status
+from fastapi.responses import StreamingResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.core.database import get_db
+from app.services.talent_service import TalentService
+from app.schemas.talent import TalentUpdate, TalentPasswordUpdate
+from app.schemas.auth import TalentCreate
+from app.schemas.response import ResponseBase
+from app.utils.template_generator import TemplateGenerator
+from app.api.deps import get_current_admin_user
+
+router = APIRouter(dependencies=[Depends(get_current_admin_user)])
+
+@router.get("", response_model=ResponseBase)
+async def get_talent_list(
+    searchQuery: str = Query(None), 
+    page: int = Query(1, ge=1), 
+    limit: int = Query(10, ge=1), 
+    db: AsyncSession = Depends(get_db)
+):
+    service = TalentService(db)
+    result = await service.get_talents_list(page, limit, searchQuery)
+    pagination = {
+        "currentPage": result["page"], 
+        "totalRecords": result["total"], 
+        "totalPages": (result["total"] + limit - 1) // limit
+    }
+    return ResponseBase(data={"talents": result["data"], "pagination": pagination}, message="Data talent berhasil diambil")
+
+@router.post("", response_model=ResponseBase, status_code=status.HTTP_201_CREATED)
+async def create_talent(
+    request: TalentCreate, 
+    db: AsyncSession = Depends(get_db)
+):
+    service = TalentService(db)
+    result = await service.create_talent(request)
+    return ResponseBase(
+        message="Talent created successfully", 
+        data={"id": result.idtalent, "email": result.email}
+    )
+
+@router.get("/import-template")
+async def get_talent_template():
+    buffer = TemplateGenerator.get_talent_template()
+    return StreamingResponse(
+        buffer, 
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", 
+        headers={"Content-Disposition": "attachment; filename=talent_import_template.xlsx"}
+    )
+
+@router.post("/import", response_model=ResponseBase)
+async def import_talents(file: UploadFile = File(...), db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    content = await file.read()
+    result = await service.import_talents_from_excel(content)
+    return ResponseBase(message="Talent import completed", data=result)
+
+@router.get("/{talent_id}", response_model=ResponseBase)
+async def get_talent_detail(talent_id: int, db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    data = await service.get_talent_detail(talent_id)
+    return ResponseBase(data=data)
+
+@router.put("/{talent_id}", response_model=ResponseBase)
+async def update_talent(
+    talent_id: int, 
+    request: TalentUpdate, 
+    db: AsyncSession = Depends(get_db)
+):
+    service = TalentService(db)
+    await service.update_talent(talent_id, request)
+    return ResponseBase(message="Data talent berhasil diperbarui")
+
+@router.delete("/{talent_id}", response_model=ResponseBase)
+async def delete_talent(talent_id: int, db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    await service.delete_talent(talent_id)
+    return ResponseBase(message="Talent berhasil dihapus")
+
+@router.put("/{talent_id}/change-password", response_model=ResponseBase)
+async def change_talent_password(
+    talent_id: int, 
+    request: TalentPasswordUpdate, 
+    db: AsyncSession = Depends(get_db)
+):
+    service = TalentService(db)
+    await service.change_password(talent_id, request.new_password)
+    return ResponseBase(message="Password berhasil diubah")
+
+@router.get("/{talent_id}/phoneme-material-exercise", response_model=ResponseBase)
+async def get_phoneme_word_progress(talent_id: int, page: int = Query(1, ge=1), limit: int = Query(10, ge=1), db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    result = await service.get_phoneme_progress(talent_id, "Word", page, limit)
+    return ResponseBase(data={"phonemeCategories": result["data"], "pagination": {"currentPage": page, "totalRecords": result["total"], "totalPages": (result["total"] + limit - 1) // limit}})
+
+@router.get("/{talent_id}/phoneme-exercise", response_model=ResponseBase)
+async def get_phoneme_sentence_progress(talent_id: int, page: int = Query(1, ge=1), limit: int = Query(10, ge=1), db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    result = await service.get_phoneme_progress(talent_id, "Sentence", page, limit)
+    return ResponseBase(data={"phonemeExercises": result["data"], "pagination": {"currentPage": page, "totalRecords": result["total"], "totalPages": (result["total"] + limit - 1) // limit}})
+
+@router.get("/{talent_id}/phoneme-exam", response_model=ResponseBase)
+async def get_phoneme_exam_progress(talent_id: int, page: int = Query(1, ge=1), limit: int = Query(10, ge=1), db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    result = await service.get_exam_progress(talent_id, page, limit)
+    return ResponseBase(data={"phonemeExams": result["data"], "pagination": {"currentPage": page, "totalRecords": result["total"], "totalPages": (result["total"] + limit - 1) // limit}})
+
+@router.get("/{talent_id}/phoneme-exam/attempt/{attempt_id}/detail", response_model=ResponseBase)
+async def get_exam_attempt_detail(talent_id: int, attempt_id: int, db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    data = await service.get_exam_attempt_detail(talent_id, attempt_id)
+    return ResponseBase(data={"examAttemptDetail": data})
+
+@router.get("/{talent_id}/conversation", response_model=ResponseBase)
+async def get_conversation_progress(talent_id: int, page: int = Query(1, ge=1), limit: int = Query(10, ge=1), db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    result = await service.get_conversation_progress(talent_id, page, limit)
+    return ResponseBase(data={"conversations": result["data"], "pagination": {"currentPage": page, "totalRecords": result["total"], "totalPages": (result["total"] + limit - 1) // limit}})
+
+@router.get("/{talent_id}/interview", response_model=ResponseBase)
+async def get_interview_progress(talent_id: int, page: int = Query(1, ge=1), limit: int = Query(10, ge=1), db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    result = await service.get_interview_progress(talent_id, page, limit)
+    return ResponseBase(data={"interviews": result["data"], "pagination": {"currentPage": page, "totalRecords": result["total"], "totalPages": (result["total"] + limit - 1) // limit}})
+
+@router.get("/{talent_id}/interview/{attempt_id}/detail", response_model=ResponseBase)
+async def get_interview_detail(talent_id: int, attempt_id: int, db: AsyncSession = Depends(get_db)):
+    service = TalentService(db)
+    data = await service.get_interview_detail(talent_id, attempt_id)
+    return ResponseBase(data={"interviewDetail": data})

app/api/v1/endpoints/transcribe.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter, UploadFile, File
+from app.services.audio_service import AudioService
+from app.schemas.response import ResponseBase
+
+router = APIRouter()
+
+@router.post("/transcribe", response_model=ResponseBase)
+async def transcribe_audio(file: UploadFile = File(...)):
+    """General purpose speech-to-text using Whisper"""
+    content = await file.read()
+    text = await AudioService.transcribe_text(content)
+    return ResponseBase(data={"text": text})

app/core/config.py

@@ -0,0 +1,76 @@
+import os
+from typing import List, Dict, Any
+from pydantic import AnyHttpUrl, field_validator
+from pydantic_settings import BaseSettings
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "TalentaTalk API"
+    API_V1_STR: str = "/api/v1"
+    
+    SECRET_KEY: str = os.getenv("SECRET_KEY")
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 7
+    
+    # DATABASE
+    DB_USER: str = os.getenv("DB_USER", "postgres")
+    DB_PASSWORD: str = os.getenv("DB_PASSWORD")
+    DB_HOST: str = os.getenv("DB_HOST", "localhost")
+    DB_PORT: str = os.getenv("DB_PORT", "5432")
+    DB_NAME: str = os.getenv("DB_NAME", "appdb")
+    
+    # Konstruksi URL Database (Computed)
+    @property
+    def SQLALCHEMY_DATABASE_URI(self) -> str:
+        return f"postgresql+asyncpg://{self.DB_USER}:{self.DB_PASSWORD}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}"
+
+    # AI CONFIG (Dinamis)
+    GEMINI_API_KEY: str = os.getenv("GEMINI_API_KEY")
+    GEMINI_MODEL_ID: str = os.getenv("GEMINI_MODEL_ID", "gemini-2.0-flash")
+    
+    @property
+    def GEMINI_API_URL(self) -> str:
+        return f"https://generativelanguage.googleapis.com/v1beta/models/{self.GEMINI_MODEL_ID}:generateContent"
+
+    # CORS (Support Local & Production via Env)
+    BACKEND_CORS_ORIGINS: List[str] = [
+        "http://localhost:5173",
+        "http://localhost:3000",
+        "http://127.0.0.1:8000",
+        "http://127.0.0.1:3000",
+        "http://localhost:8000",
+        "https://talentatalk-admin.vercel.app", 
+        "https://talentatalk-admin-git-main-cozs-projects-51dd16eb.vercel.app"
+    ]
+
+    # PHONETIC CONSTANTS (Static Logic)
+    TIE_BAR_NORMALIZATION: Dict[str, str] = {
+        "d͡ʒ": "dʒ", "t͡ʃ": "tʃ", "t͡s": "ts", "d͡z": "dz"
+    }
+
+    SIMILAR_PHONEMES: Dict[str, List[str]] = {
+        "i": ["ɪ", "j"], "ɪ": ["ɛ"], "ɛ": ["æ"], "u": ["ʊ", "w"],
+        "p": ["b"], "t": ["d"], "k": ["g"], "f": ["v"],
+        "θ": ["ð"], "s": ["z"], "ʃ": ["ʒ"], "tʃ": ["dʒ"],
+        "n": ["m", "ŋ"], "l": ["r"], "ə": ["ʌ", "ɚ"],
+        "ɑ": ["ɔ", "ʌ"], "ɔ": ["oʊ"], "oʊ": ["ʊ"],
+        "eɪ": ["ɛ", "ɪ"], "aɪ": ["ɪ", "ɑ"], "ɔɪ": ["ɔ", "ɪ"],
+        "aʊ": ["ʊ", "ɑ"],
+    }
+    
+    VOWEL_PHONEMES: List[str] = ["i", "ɪ", "ɛ", "æ", "ə", "ɚ", "ʌ", "ɑ", "ɔ", "ʊ", "u"]
+    DIPHTHONG_PHONEMES: List[str] = ["eɪ", "aɪ", "ɔɪ", "aʊ", "oʊ"]
+    CONSONANT_PHONEMES: List[str] = ["p", "b", "t", "d", "k", "g", "f", "v", "θ", "ð", "s", "z", "ʃ", "ʒ", "tʃ", "dʒ", "h", "m", "n", "ŋ", "l", "r", "j", "w"]
+
+    @field_validator("SECRET_KEY", "GEMINI_API_KEY", "DB_PASSWORD")
+    def check_empty_secrets(cls, v, info):
+        if not v:
+            raise ValueError(f"CRITICAL: {info.field_name} must be set in .env")
+        return v
+
+    class Config:
+        case_sensitive = True
+
+settings = Settings()

app/core/database.py

@@ -0,0 +1,31 @@
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy.orm import DeclarativeBase
+from app.core.config import settings
+from typing import AsyncGenerator
+
+engine = create_async_engine(
+    settings.SQLALCHEMY_DATABASE_URI,
+    echo=False,
+    future=True,
+    pool_pre_ping=True,
+    pool_size=10,
+    max_overflow=20
+)
+
+AsyncSessionLocal = async_sessionmaker(
+    bind=engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autocommit=False,
+    autoflush=False,
+)
+
+class Base(DeclarativeBase):
+    pass
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+        finally:
+            await session.close()

app/core/exceptions.py

@@ -0,0 +1,33 @@
+from fastapi import HTTPException, status
+from typing import Any, Optional
+
+class AppError(HTTPException):
+    def __init__(
+        self,
+        status_code: int,
+        detail: Any = None,
+        headers: Optional[dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(status_code=status_code, detail=detail, headers=headers)
+
+class NotFoundError(AppError):
+    def __init__(self, resource: str = "Resource"):
+        super().__init__(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"{resource} not found"
+        )
+
+class AuthenticationError(AppError):
+    def __init__(self, detail: str = "Could not validate credentials"):
+        super().__init__(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=detail,
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+class DuplicateError(AppError):
+    def __init__(self, detail: str = "Data already exists"):
+        super().__init__(
+            status_code=status.HTTP_409_CONFLICT,
+            detail=detail
+        )

app/main.py

@@ -0,0 +1,56 @@
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+
+from app.core.config import settings
+from app.core.exceptions import AppError
+from app.core.database import engine, Base
+from app.api.v1.endpoints import (
+    auth, conversation, phoneme, dashboard, material, 
+    talents, history, exam, transcribe, interview_flow, mobile_profile, pretest
+)
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    yield
+
+app = FastAPI(title=settings.PROJECT_NAME, lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.BACKEND_CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.exception_handler(AppError)
+async def app_exception_handler(request: Request, exc: AppError):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"success": False, "message": str(exc.detail), "data": None},
+    )
+
+# --- WEB ADMIN ---
+app.include_router(auth.router, prefix="/web/admin", tags=["Auth Admin"])
+app.include_router(dashboard.router, prefix="/web/admin", tags=["Dashboard"])
+app.include_router(material.router, prefix="/web/admin", tags=["Material"])
+app.include_router(talents.router, prefix="/web/admin/talents", tags=["Talent Management"])
+
+# --- MOBILE APP ---
+app.include_router(auth.router, prefix="/api/v1/auth", tags=["Auth Mobile"])
+app.include_router(conversation.router, prefix="/api/v1/conversation", tags=["Conversation"])
+app.include_router(interview_flow.router, prefix="/api/v1/interview", tags=["Interview"])
+app.include_router(phoneme.router, prefix="/api/v1/phoneme", tags=["Phoneme"])
+app.include_router(history.router, prefix="/api/v1/history", tags=["History"])
+app.include_router(exam.router, prefix="/api/v1/exam", tags=["Exam"])
+app.include_router(transcribe.router, prefix="/api/v1", tags=["Transcribe"])
+app.include_router(mobile_profile.router, prefix="/api/v1/profile", tags=["Profile Mobile"])
+app.include_router(pretest.router, prefix="/api/v1/pretest", tags=["Pretest"])
+
+@app.get("/")
+def root():
+    return {"message": "TalentaTalk API v1.6 Running"}

app/models/models.py

@@ -0,0 +1,123 @@
+from sqlalchemy import Column, Integer, String, Float, DateTime, ForeignKey, Text, Boolean
+from sqlalchemy.dialects.postgresql import JSON
+from sqlalchemy.sql import func
+from app.core.database import Base
+
+class Ujianfonem(Base):
+    __tablename__ = 'ujianfonem'
+
+    idujian = Column(Integer, primary_key=True, autoincrement=True)
+    idmateriujian = Column(Integer, ForeignKey('materiujian.idmateriujian'))
+    idtalent = Column(Integer, ForeignKey('talent.idtalent'))
+    kategori = Column(String(255))
+    nilai = Column(Float)
+    waktuujian = Column(DateTime)
+    updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
+
+class Detailujianfonem(Base):
+    __tablename__ = 'detailujianfonem'
+
+    iddetail = Column(Integer, primary_key=True, autoincrement=True)
+    idujian = Column(Integer, ForeignKey('ujianfonem.idujian'))
+    idsoal = Column(Integer, ForeignKey('materiujiankalimat.idmateriujiankalimat'))
+    nilai = Column(Float)
+    updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
+
+class Materiujian(Base):
+    __tablename__ = 'materiujian'
+
+    idmateriujian = Column(Integer, primary_key=True, autoincrement=True)
+    kategori = Column(String(255))
+    updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
+
+class Materiujiankalimat(Base):
+    __tablename__ = 'materiujiankalimat'
+
+    idmateriujiankalimat = Column(Integer, primary_key=True, autoincrement=True)
+    idmateriujian = Column(Integer, ForeignKey('materiujian.idmateriujian'))
+    kalimat = Column(String(255))
+    fonem = Column(String(255))
+    updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
+
+class Hasillatihanfonem(Base):
+    __tablename__ = 'hasillatihanfonem'
+
+    idhasilfonem = Column(Integer, primary_key=True, autoincrement=True)
+    typelatihan = Column(String(255))
+    idtalent = Column(Integer, ForeignKey('talent.idtalent'))
+    idsoal = Column(Integer)
+    nilai = Column(Float)
+    waktulatihan = Column(DateTime)
+    phoneme_comparison = Column(JSON) 
+
+class Hasillatihanpercakapan(Base):
+    __tablename__ = 'hasillatihanpercakapan'
+
+    idhasilpercakapan = Column(Integer, primary_key=True, autoincrement=True)
+    idtalent = Column(Integer, ForeignKey('talent.idtalent'))
+    idmateripercakapan = Column(Integer, ForeignKey('materipercakapan.idmateripercakapan'))
+    wpm = Column(Float)
+    grammar = Column(String(255))
+    waktulatihan = Column(DateTime)
+
+class Hasillatihaninterview(Base):
+    __tablename__ = 'hasillatihaninterview'
+
+    idhasilinterview = Column(Integer, primary_key=True, autoincrement=True)
+    idtalent = Column(Integer, ForeignKey('talent.idtalent'))
+    waktulatihan = Column(DateTime)
+    feedback = Column(Text)
+    wpm = Column(Float)
+    grammar = Column(String(255))
+
+class Manajemen(Base):
+    __tablename__ = 'manajemen'
+
+    idmanajemen = Column(Integer, primary_key=True)
+    namamanajemen = Column(String(255))
+    email = Column(String(255))
+    password = Column(String(255))
+
+class Materifonemkalimat(Base):
+    __tablename__ = 'materifonemkalimat'
+
+    idmaterifonemkalimat = Column(Integer, primary_key=True, autoincrement=True)
+    kategori = Column(String(255))
+    kalimat = Column(String(255))
+    fonem = Column(String(255))
+    updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
+
+class Materifonemkata(Base):
+    __tablename__ = 'materifonemkata'
+
+    idmaterifonemkata = Column(Integer, primary_key=True, autoincrement=True)
+    kategori = Column(String(255))
+    kata = Column(String(255))
+    fonem = Column(String(255))
+    meaning = Column(String(255))
+    definition = Column(String(255))
+    updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
+
+class Materipercakapan(Base):
+    __tablename__ = 'materipercakapan'
+
+    idmateripercakapan = Column(Integer, primary_key=True, autoincrement=True)
+    topic = Column(String(255))
+
+class Materiinterview(Base):
+    __tablename__ = 'materiinterview'
+
+    idmateriinterview = Column(Integer, primary_key=True, autoincrement=True)
+    question = Column(String(255))
+    updated_at = Column(DateTime, server_default=func.now(), onupdate=func.now())
+    is_active = Column(Boolean, nullable=False, server_default='true')
+
+class Talent(Base):
+    __tablename__ = 'talent'
+
+    idtalent = Column(Integer, primary_key=True, autoincrement=True)
+    nama = Column(String(255))
+    email = Column(String(255), unique=True)
+    password = Column(String(255))
+    pretest_score = Column(Float)
+    role = Column(String(50), default='talent')

app/repositories/base.py

@@ -0,0 +1,39 @@
+from typing import Generic, TypeVar, Type, Optional, List, Any
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, delete
+from app.core.database import Base
+
+ModelType = TypeVar("ModelType", bound=Base)
+
+class BaseRepository(Generic[ModelType]):
+    def __init__(self, model: Type[ModelType], db: AsyncSession):
+        self.model = model
+        self.db = db
+
+    async def get_by_id(self, id: Any) -> Optional[ModelType]:
+        query = select(self.model).where(self.model.id == id) # Asumsi primary key bernama 'id', override jika beda
+        result = await self.db.execute(query)
+        return result.scalar_one_or_none()
+
+    async def get_all(self, skip: int = 0, limit: int = 100) -> List[ModelType]:
+        query = select(self.model).offset(skip).limit(limit)
+        result = await self.db.execute(query)
+        return result.scalars().all()
+
+    async def create(self, obj_in: dict) -> ModelType:
+        db_obj = self.model(**obj_in)
+        self.db.add(db_obj)
+        await self.db.commit()
+        await self.db.refresh(db_obj)
+        return db_obj
+
+    async def update(self, db_obj: ModelType, obj_in: dict) -> ModelType:
+        for field, value in obj_in.items():
+            setattr(db_obj, field, value)
+        await self.db.commit()
+        await self.db.refresh(db_obj)
+        return db_obj
+
+    async def delete(self, db_obj: ModelType) -> None:
+        await self.db.delete(db_obj)
+        await self.db.commit()

app/repositories/dashboard_repository.py

@@ -0,0 +1,167 @@
+from sqlalchemy import select, func, desc, union_all, literal_column
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.models.models import (
+    Talent, Materifonemkata, Materifonemkalimat, Materiujian, Materiinterview,
+    Hasillatihanfonem, Hasillatihanpercakapan, Hasillatihaninterview, Ujianfonem, Manajemen
+)
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timedelta
+
+class DashboardRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_total_counts(self) -> Dict[str, int]:
+        total_talent = await self.db.scalar(select(func.count(Talent.idtalent)))
+        count_word = await self.db.scalar(select(func.count(Materifonemkata.idmaterifonemkata)))
+        count_sent = await self.db.scalar(select(func.count(Materifonemkalimat.idmaterifonemkalimat)))
+        total_exam = await self.db.scalar(select(func.count(func.distinct(Materiujian.kategori))))
+        total_interview = await self.db.scalar(select(func.count(Materiinterview.idmateriinterview)))
+        
+        return {
+            "totalTalent": total_talent or 0,
+            "totalPronunciationMaterial": (count_word or 0) + (count_sent or 0),
+            "totalExamPhonemMaterial": total_exam or 0,
+            "totalInterviewQuestion": total_interview or 0
+        }
+
+    async def get_recent_activities(
+        self, 
+        limit: int = 10, 
+        days_back: int = 30,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None
+    ) -> List[Dict[str, Any]]:
+        
+        # Calculate Date Range
+        if start_date and end_date:
+            cutoff_start = start_date
+            cutoff_end = end_date
+        else:
+            cutoff_start = datetime.utcnow() - timedelta(days=days_back)
+            cutoff_end = datetime.utcnow() + timedelta(days=1) # Future buffer
+
+        # Helper to apply date filter
+        def date_filter(model_date_col):
+            return model_date_col.between(cutoff_start, cutoff_end)
+
+        q_phoneme = select(
+            Hasillatihanfonem.idtalent, Hasillatihanfonem.nilai.label("score_val"),
+            Hasillatihanfonem.waktulatihan, Hasillatihanfonem.typelatihan.label("category"),
+            literal_column("'Phoneme'").label("type")
+        ).where(date_filter(Hasillatihanfonem.waktulatihan))
+
+        q_exam = select(
+            Ujianfonem.idtalent, Ujianfonem.nilai.label("score_val"),
+            Ujianfonem.waktuujian.label("waktulatihan"), Ujianfonem.kategori.label("category"),
+            literal_column("'Exam'").label("type")
+        ).where(date_filter(Ujianfonem.waktuujian))
+
+        q_conv = select(
+            Hasillatihanpercakapan.idtalent, Hasillatihanpercakapan.wpm.label("score_val"),
+            Hasillatihanpercakapan.waktulatihan, literal_column("'Speaking'").label("category"),
+            literal_column("'Conversation'").label("type")
+        ).where(date_filter(Hasillatihanpercakapan.waktulatihan))
+
+        q_int = select(
+            Hasillatihaninterview.idtalent, Hasillatihaninterview.wpm.label("score_val"),
+            Hasillatihaninterview.waktulatihan, literal_column("'Speaking'").label("category"),
+            literal_column("'Interview'").label("type")
+        ).where(date_filter(Hasillatihaninterview.waktulatihan))
+
+        union_q = union_all(q_phoneme, q_exam, q_conv, q_int).alias("activities")
+        
+        final_query = (
+            select(union_q, Talent.nama)
+            .join(Talent, Talent.idtalent == union_q.c.idtalent)
+            .order_by(desc(union_q.c.waktulatihan))
+            .limit(limit)
+        )
+
+        result = await self.db.execute(final_query)
+        
+        formatted_results = []
+        for row in result:
+            score_val = row.score_val if row.score_val is not None else 0
+            score_display = f"{score_val:.0f} WPM" if row.type in ['Conversation', 'Interview'] else f"{score_val:.0f}%"
+            
+            formatted_results.append({
+                "talentId": row.idtalent,
+                "talentName": row.nama,
+                "activityType": f"{row.type} Practice" if row.type == "Phoneme" else row.type,
+                "category": row.category or "General",
+                "score": score_display,
+                "date": row.waktulatihan
+            })
+            
+        return formatted_results
+
+    # --- Other methods (Specific User & Leaderboard) remain same for brevity, ensure they are in file ---
+    async def get_user_activity_dates(self, talent_id: int):
+        q1 = select(Hasillatihanfonem.waktulatihan).where(Hasillatihanfonem.idtalent == talent_id)
+        q2 = select(Ujianfonem.waktuujian).where(Ujianfonem.idtalent == talent_id)
+        q3 = select(Hasillatihanpercakapan.waktulatihan).where(Hasillatihanpercakapan.idtalent == talent_id)
+        q4 = select(Hasillatihaninterview.waktulatihan).where(Hasillatihaninterview.idtalent == talent_id)
+        union_q = union_all(q1, q2, q3, q4)
+        result = await self.db.execute(union_q)
+        return [row[0] for row in result.all()]
+
+    async def get_user_avg_pronunciation(self, talent_id: int) -> float:
+        query = select(func.avg(Hasillatihanfonem.nilai)).where(Hasillatihanfonem.idtalent == talent_id)
+        return await self.db.scalar(query) or 0.0
+
+    async def get_user_conversation_stats(self, talent_id: int):
+        query = select(func.avg(Hasillatihanpercakapan.wpm), func.count(Hasillatihanpercakapan.idhasilpercakapan)).where(Hasillatihanpercakapan.idtalent == talent_id)
+        result = await self.db.execute(query)
+        row = result.first()
+        return {"avg_wpm": row[0] or 0.0, "count": row[1] or 0}
+
+    async def get_user_interview_stats(self, talent_id: int):
+        query = select(func.avg(Hasillatihaninterview.wpm), func.count(Hasillatihaninterview.idhasilinterview)).where(Hasillatihaninterview.idtalent == talent_id)
+        result = await self.db.execute(query)
+        row = result.first()
+        return {"avg_wpm": row[0] or 0.0, "count": row[1] or 0}
+
+    async def get_user_phoneme_counts(self, talent_id: int):
+        query = select(func.count(func.distinct(Hasillatihanfonem.idsoal))).where(Hasillatihanfonem.idtalent == talent_id)
+        return await self.db.scalar(query) or 0
+
+    async def get_all_talents(self, search: str = None):
+        query = select(Talent)
+        if search: query = query.filter(Talent.nama.ilike(f"%{search}%"))
+        result = await self.db.execute(query)
+        return result.scalars().all()
+
+    async def get_all_activities_dates(self):
+        q1 = select(Hasillatihanfonem.idtalent, Hasillatihanfonem.waktulatihan)
+        q2 = select(Ujianfonem.idtalent, Ujianfonem.waktuujian.label("waktulatihan"))
+        q3 = select(Hasillatihanpercakapan.idtalent, Hasillatihanpercakapan.waktulatihan)
+        q4 = select(Hasillatihaninterview.idtalent, Hasillatihaninterview.waktulatihan)
+        union_q = union_all(q1, q2, q3, q4).alias("act")
+        query = select(union_q.c.idtalent, union_q.c.waktulatihan)
+        result = await self.db.execute(query)
+        return result.all()
+
+    async def get_highest_scoring_phoneme(self, type_latihan: str):
+        query = (select(Talent.idtalent, Talent.nama, Talent.email, func.count(func.distinct(Hasillatihanfonem.idsoal)).label('attempted'), func.avg(Hasillatihanfonem.nilai).label('avg_score')).join(Hasillatihanfonem, Talent.idtalent == Hasillatihanfonem.idtalent).where(Hasillatihanfonem.typelatihan == type_latihan).group_by(Talent.idtalent))
+        result = await self.db.execute(query)
+        return result.all()
+
+    async def get_highest_scoring_exam(self):
+        query = (select(Talent.idtalent, Talent.nama, Talent.email, func.count(func.distinct(Ujianfonem.kategori)).label('categories_attempted'), func.avg(Ujianfonem.nilai).label('avg_score'), func.count(Ujianfonem.idujian).label('total_attempts')).join(Ujianfonem, Talent.idtalent == Ujianfonem.idtalent).where(Ujianfonem.nilai != None).group_by(Talent.idtalent))
+        result = await self.db.execute(query)
+        return result.all()
+
+    async def get_highest_scoring_conversation(self):
+        query = (select(Talent.idtalent, Talent.nama, Talent.email, func.avg(Hasillatihanpercakapan.wpm).label('avg_wpm'), func.count(Hasillatihanpercakapan.idhasilpercakapan).label('total_attempts'), func.max(Hasillatihanpercakapan.waktulatihan).label('last_date')).join(Hasillatihanpercakapan, Talent.idtalent == Hasillatihanpercakapan.idtalent).group_by(Talent.idtalent))
+        result = await self.db.execute(query)
+        return result.all()
+
+    async def get_highest_scoring_interview(self):
+        query = (select(Talent.idtalent, Talent.nama, Talent.email, func.avg(Hasillatihaninterview.wpm).label('avg_wpm'), func.count(Hasillatihaninterview.idhasilinterview).label('total_attempts'), func.max(Hasillatihaninterview.waktulatihan).label('last_date')).join(Hasillatihaninterview, Talent.idtalent == Hasillatihaninterview.idtalent).group_by(Talent.idtalent))
+        result = await self.db.execute(query)
+        return result.all()
+
+    async def get_admin_by_email(self, email: str):
+        result = await self.db.execute(select(Manajemen).where(Manajemen.email == email))
+        return result.scalar_one_or_none()

app/repositories/exam_repository.py

@@ -0,0 +1,84 @@
+from sqlalchemy import select, and_, func
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.models.models import Ujianfonem, Detailujianfonem, Materiujian, Materiujiankalimat
+from datetime import datetime
+
+class ExamRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_active_exam(self, talent_id: int, exam_id: int):
+        """Mencari ujian yang sedang berlangsung (nilai masih None)"""
+        query = select(Ujianfonem).where(
+            and_(
+                Ujianfonem.idtalent == talent_id,
+                Ujianfonem.idmateriujian == exam_id,
+                Ujianfonem.nilai == None
+            )
+        )
+        result = await self.db.execute(query)
+        return result.scalar_one_or_none()
+    
+    async def get_exam_by_id(self, ujian_id: int):
+        return await self.db.get(Ujianfonem, ujian_id)
+
+    async def create_exam_entry(self, talent_id: int, exam_id: int, category: str):
+        """Membuat sesi ujian baru"""
+        exam = Ujianfonem(
+            idmateriujian=exam_id,
+            idtalent=talent_id,
+            kategori=category,
+            nilai=None,
+            waktuujian=datetime.utcnow()
+        )
+        self.db.add(exam)
+        await self.db.commit()
+        await self.db.refresh(exam)
+        return exam
+
+    async def get_answered_question_ids(self, ujian_id: int):
+        """Mengambil ID soal yang sudah dijawab dalam sesi ini"""
+        query = select(Detailujianfonem.idsoal).where(Detailujianfonem.idujian == ujian_id)
+        result = await self.db.execute(query)
+        return result.scalars().all()
+
+    async def get_remaining_questions(self, exam_id: int, answered_ids: list):
+        """Mengambil soal yang belum dikerjakan"""
+        query = select(Materiujiankalimat).where(Materiujiankalimat.idmateriujian == exam_id)
+        if answered_ids:
+            query = query.where(Materiujiankalimat.idmateriujiankalimat.notin_(answered_ids))
+        
+        result = await self.db.execute(query)
+        return result.scalars().all()
+    
+    async def get_materi_header(self, exam_id: int):
+        return await self.db.get(Materiujian, exam_id)
+
+    async def get_materi_kalimat(self, soal_id: int):
+        return await self.db.get(Materiujiankalimat, soal_id)
+
+    async def save_detail_answer(self, ujian_id: int, soal_id: int, score: float):
+        """Menyimpan jawaban per soal"""
+        detail = Detailujianfonem(idujian=ujian_id, idsoal=soal_id, nilai=score)
+        self.db.add(detail)
+        await self.db.commit()
+        return detail
+
+    async def get_exam_details_with_questions(self, ujian_id: int):
+        """Mengambil detail jawaban beserta teks soalnya untuk result"""
+        query = (
+            select(Detailujianfonem, Materiujiankalimat.kalimat)
+            .join(Materiujiankalimat, Detailujianfonem.idsoal == Materiujiankalimat.idmateriujiankalimat)
+            .where(Detailujianfonem.idujian == ujian_id)
+        )
+        result = await self.db.execute(query)
+        return result.all()
+
+    async def update_final_score(self, ujian_id: int, score: float):
+        """Update nilai akhir ujian"""
+        ujian = await self.get_exam_by_id(ujian_id)
+        if ujian:
+            ujian.nilai = score
+            await self.db.commit()
+            await self.db.refresh(ujian)
+        return ujian

app/repositories/history_repository.py

@@ -0,0 +1,104 @@
+from sqlalchemy import select, desc
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.models.models import (
+    Hasillatihanfonem, Hasillatihanpercakapan, Hasillatihaninterview, 
+    Ujianfonem, Detailujianfonem, Materifonemkata, Materifonemkalimat, 
+    Materipercakapan, Materiujiankalimat
+)
+from datetime import datetime, timedelta
+
+class HistoryRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def get_phoneme_history(self, talent_id: int, days_back: int = 7, skip: int = 0, limit: int = 10):
+        cutoff = datetime.utcnow() - timedelta(days=days_back)
+        
+        query = (
+            select(Hasillatihanfonem)
+            .where(
+                Hasillatihanfonem.idtalent == talent_id,
+                Hasillatihanfonem.waktulatihan >= cutoff
+            )
+            .order_by(desc(Hasillatihanfonem.waktulatihan))
+            .offset(skip)
+            .limit(limit)
+        )
+        result = await self.db.execute(query)
+        items = result.scalars().all()
+        
+        # Perlu manual fetch nama soal karena polimorfik (Word/Sentence)
+        enriched_items = []
+        for item in items:
+            soal_text = "Unknown"
+            if item.typelatihan == "Word":
+                q = select(Materifonemkata.kata).where(Materifonemkata.idmaterifonemkata == item.idsoal)
+                soal_text = await self.db.scalar(q)
+            elif item.typelatihan == "Sentence":
+                q = select(Materifonemkalimat.kalimat).where(Materifonemkalimat.idmaterifonemkalimat == item.idsoal)
+                soal_text = await self.db.scalar(q)
+            
+            enriched_items.append({
+                "raw": item,
+                "soal_text": soal_text
+            })
+            
+        return enriched_items
+
+    async def get_conversation_history(self, talent_id: int, days_back: int = 7):
+        cutoff = datetime.utcnow() - timedelta(days=days_back)
+        query = (
+            select(Hasillatihanpercakapan, Materipercakapan.topic)
+            .join(Materipercakapan, Materipercakapan.idmateripercakapan == Hasillatihanpercakapan.idmateripercakapan)
+            .where(
+                Hasillatihanpercakapan.idtalent == talent_id,
+                Hasillatihanpercakapan.waktulatihan >= cutoff
+            )
+            .order_by(desc(Hasillatihanpercakapan.waktulatihan))
+        )
+        result = await self.db.execute(query)
+        return result.all() # Returns tuples (Model, topic_string)
+
+    async def get_interview_history(self, talent_id: int, days_back: int = 7):
+        cutoff = datetime.utcnow() - timedelta(days=days_back)
+        query = (
+            select(Hasillatihaninterview)
+            .where(
+                Hasillatihaninterview.idtalent == talent_id,
+                Hasillatihaninterview.waktulatihan >= cutoff
+            )
+            .order_by(desc(Hasillatihaninterview.waktulatihan))
+        )
+        result = await self.db.execute(query)
+        return result.scalars().all()
+
+    async def get_exam_history(self, talent_id: int, days_back: int = 7):
+        cutoff = datetime.utcnow() - timedelta(days=days_back)
+        query = (
+            select(Ujianfonem)
+            .where(
+                Ujianfonem.idtalent == talent_id,
+                Ujianfonem.waktuujian >= cutoff
+            )
+            .order_by(desc(Ujianfonem.waktuujian))
+        )
+        result = await self.db.execute(query)
+        exams = result.scalars().all()
+        
+        # Fetch details for each exam
+        history_data = []
+        for exam in exams:
+            q_detail = (
+                select(Detailujianfonem, Materiujiankalimat.kalimat)
+                .join(Materiujiankalimat, Detailujianfonem.idsoal == Materiujiankalimat.idmateriujiankalimat)
+                .where(Detailujianfonem.idujian == exam.idujian)
+            )
+            details_res = await self.db.execute(q_detail)
+            details = [{"score": r.Detailujianfonem.nilai, "kalimat": r.kalimat} for r in details_res]
+            
+            history_data.append({
+                "exam": exam,
+                "details": details
+            })
+            
+        return history_data

app/repositories/material_repository.py

@@ -0,0 +1,278 @@
+from sqlalchemy import select, func, distinct
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.exc import IntegrityError
+from app.models.models import Materipercakapan, Materifonemkata, Materifonemkalimat, Materiujian, Materiujiankalimat, Materiinterview
+from app.core.exceptions import DuplicateError
+
+class MaterialRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    # --- READ METHODS (General) ---
+    async def get_random_topic(self):
+        query = select(Materipercakapan).order_by(func.random()).limit(1)
+        result = await self.db.execute(query)
+        return result.scalar_one_or_none()
+
+    async def get_phoneme_content(self, id: int, type: str):
+        if type == "word":
+            query = select(Materifonemkata).where(Materifonemkata.idmaterifonemkata == id)
+        else:
+            query = select(Materifonemkalimat).where(Materifonemkalimat.idmaterifonemkalimat == id)
+        result = await self.db.execute(query)
+        return result.scalar_one_or_none()
+
+    # --- PRETEST & RANDOM FETCHING ---
+    async def get_random_sentences(self, limit: int = 10):
+        cat_query = select(Materifonemkalimat.kategori).distinct()
+        categories = (await self.db.execute(cat_query)).scalars().all()
+        
+        results = []
+        for cat in categories:
+            if len(results) >= limit: break
+            q = select(Materifonemkalimat).where(Materifonemkalimat.kategori == cat).order_by(func.random()).limit(1)
+            item = (await self.db.execute(q)).scalar_one_or_none()
+            if item: results.append(item)
+            
+        if len(results) < limit:
+            needed = limit - len(results)
+            exclude_ids = [r.idmaterifonemkalimat for r in results]
+            q_more = select(Materifonemkalimat).where(Materifonemkalimat.idmaterifonemkalimat.notin_(exclude_ids)).order_by(func.random()).limit(needed)
+            more_items = (await self.db.execute(q_more)).scalars().all()
+            results.extend(more_items)
+            
+        return results
+
+    async def get_random_word_by_phoneme(self, phoneme: str):
+        query = select(Materifonemkata).where(Materifonemkata.fonem.ilike(f"%{phoneme}%")).order_by(func.random()).limit(1)
+        result = await self.db.execute(query)
+        return result.scalar_one_or_none()
+
+    async def get_random_sentence_by_phoneme(self, phoneme: str):
+        query = select(Materifonemkalimat).where(Materifonemkalimat.kategori.ilike(f"%{phoneme}%")).order_by(func.random()).limit(1)
+        result = await self.db.execute(query)
+        return result.scalar_one_or_none()
+
+    async def get_word_by_id(self, id: int):
+        return await self.db.get(Materifonemkata, id)
+
+    async def get_sentence_by_id(self, id: int):
+        return await self.db.get(Materifonemkalimat, id)
+    
+    # 1. Phoneme Material (Words)
+    async def get_phoneme_materials_paginated(self, skip: int, limit: int, search: str = None):
+        # Group by category, count words, get max updated_at
+        stmt = select(
+            Materifonemkata.kategori,
+            func.count(Materifonemkata.idmaterifonemkata).label("total_words"),
+            func.max(Materifonemkata.updated_at).label("last_update")
+        ).group_by(Materifonemkata.kategori)
+        
+        count_stmt = select(func.count(distinct(Materifonemkata.kategori)))
+
+        if search:
+            stmt = stmt.where(Materifonemkata.kategori.ilike(f"%{search}%"))
+            count_stmt = count_stmt.where(Materifonemkata.kategori.ilike(f"%{search}%"))
+            
+        total = await self.db.scalar(count_stmt) or 0
+        
+        stmt = stmt.order_by(Materifonemkata.kategori).offset(skip).limit(limit)
+        result = await self.db.execute(stmt)
+        
+        return result.all(), total
+
+    # 2. Exercise Phoneme (Sentences)
+    async def get_exercise_materials_paginated(self, skip: int, limit: int, search: str = None):
+        stmt = select(
+            Materifonemkalimat.kategori,
+            func.count(Materifonemkalimat.idmaterifonemkalimat).label("total_sentences"),
+            func.max(Materifonemkalimat.updated_at).label("last_update")
+        ).group_by(Materifonemkalimat.kategori)
+        
+        count_stmt = select(func.count(distinct(Materifonemkalimat.kategori)))
+
+        if search:
+            stmt = stmt.where(Materifonemkalimat.kategori.ilike(f"%{search}%"))
+            count_stmt = count_stmt.where(Materifonemkalimat.kategori.ilike(f"%{search}%"))
+            
+        total = await self.db.scalar(count_stmt) or 0
+        
+        stmt = stmt.order_by(Materifonemkalimat.kategori).offset(skip).limit(limit)
+        result = await self.db.execute(stmt)
+        
+        return result.all(), total
+
+    # 3. Exam Phoneme
+    async def get_exam_materials_paginated(self, skip: int, limit: int, search: str = None):
+        stmt = select(
+            Materiujian.kategori,
+            func.count(Materiujian.idmateriujian).label("total_exams"),
+            func.max(Materiujian.updated_at).label("last_update")
+        ).group_by(Materiujian.kategori)
+        
+        count_stmt = select(func.count(distinct(Materiujian.kategori)))
+
+        if search:
+            stmt = stmt.where(Materiujian.kategori.ilike(f"%{search}%"))
+            count_stmt = count_stmt.where(Materiujian.kategori.ilike(f"%{search}%"))
+            
+        total = await self.db.scalar(count_stmt) or 0
+        
+        stmt = stmt.order_by(Materiujian.kategori).offset(skip).limit(limit)
+        result = await self.db.execute(stmt)
+        
+        return result.all(), total
+
+    # --- INTERVIEW ---
+    async def get_interview_questions(self, skip: int = 0, limit: int = 10):
+        query = select(Materiinterview).order_by(Materiinterview.idmateriinterview).offset(skip).limit(limit)
+        result = await self.db.execute(query)
+        return result.scalars().all()
+    
+    async def get_interview_question_by_id(self, id: int):
+        return await self.db.get(Materiinterview, id)
+
+    # --- ADMIN CRUD OPERATIONS ---
+    async def create_word(self, data: dict):
+        try:
+            obj = Materifonemkata(**data)
+            self.db.add(obj)
+            await self.db.commit()
+            await self.db.refresh(obj)
+            return obj
+        except IntegrityError:
+            await self.db.rollback()
+            raise DuplicateError("Kata tersebut sudah ada dalam kategori ini")
+            
+    async def update_word(self, id: int, data: dict):
+        from sqlalchemy import update
+        stmt = update(Materifonemkata).where(Materifonemkata.idmaterifonemkata == id).values(**data)
+        await self.db.execute(stmt)
+        await self.db.commit()
+
+    async def delete_word(self, id: int):
+        from sqlalchemy import delete
+        stmt = delete(Materifonemkata).where(Materifonemkata.idmaterifonemkata == id)
+        await self.db.execute(stmt)
+        await self.db.commit()
+
+    async def create_sentence(self, data: dict):
+        try:
+            obj = Materifonemkalimat(**data)
+            self.db.add(obj)
+            await self.db.commit()
+            await self.db.refresh(obj)
+            return obj
+        except IntegrityError:
+            await self.db.rollback()
+            raise DuplicateError("Kalimat sudah ada")
+
+    async def update_sentence(self, id: int, data: dict):
+        from sqlalchemy import update
+        stmt = update(Materifonemkalimat).where(Materifonemkalimat.idmaterifonemkalimat == id).values(**data)
+        await self.db.execute(stmt)
+        await self.db.commit()
+
+    async def delete_sentence(self, id: int):
+        from sqlalchemy import delete
+        stmt = delete(Materifonemkalimat).where(Materifonemkalimat.idmaterifonemkalimat == id)
+        await self.db.execute(stmt)
+        await self.db.commit()
+
+    async def create_exam_set(self, category: str, items: list):
+        try:
+            exam_header = Materiujian(kategori=category)
+            self.db.add(exam_header)
+            await self.db.flush()
+            for item in items:
+                detail = Materiujiankalimat(
+                    idmateriujian=exam_header.idmateriujian,
+                    kalimat=item["sentence"],
+                    fonem=item["phoneme"]
+                )
+                self.db.add(detail)
+            await self.db.commit()
+            return exam_header
+        except Exception as e:
+            await self.db.rollback()
+            raise e
+            
+    async def get_exam_header(self, id: int):
+        return await self.db.get(Materiujian, id)
+        
+    async def delete_exam(self, id: int):
+        from sqlalchemy import delete
+        await self.db.execute(delete(Materiujiankalimat).where(Materiujiankalimat.idmateriujian == id))
+        await self.db.execute(delete(Materiujian).where(Materiujian.idmateriujian == id))
+        await self.db.commit()
+
+    async def update_exam_sentences(self, exam_id: int, items: list):
+        from sqlalchemy import update
+        for item in items:
+            stmt = update(Materiujiankalimat).where(Materiujiankalimat.idmateriujiankalimat == item["id_sentence"]).values(kalimat=item["sentence"], fonem=item["phoneme"])
+            await self.db.execute(stmt)
+        await self.db.commit()
+
+    async def create_interview_question(self, question: str):
+        obj = Materiinterview(question=question, is_active=True)
+        self.db.add(obj)
+        await self.db.commit()
+        await self.db.refresh(obj)
+        return obj
+        
+    async def update_interview_question(self, id: int, question: str):
+        obj = await self.get_interview_question_by_id(id)
+        if obj:
+            obj.question = question
+            await self.db.commit()
+            await self.db.refresh(obj)
+        return obj
+
+    async def delete_interview_question(self, id: int):
+        from sqlalchemy import delete
+        await self.db.execute(delete(Materiinterview).where(Materiinterview.idmateriinterview == id))
+        await self.db.commit()
+        
+    async def toggle_interview_status(self, id: int):
+        obj = await self.get_interview_question_by_id(id)
+        if obj:
+            obj.is_active = not obj.is_active
+            await self.db.commit()
+            await self.db.refresh(obj)
+        return obj
+        
+    async def swap_interview_order(self, id: int, direction: str):
+        current = await self.get_interview_question_by_id(id)
+        if not current: return False
+        
+        target_q = None
+        if direction == "up":
+            q = select(Materiinterview).where(Materiinterview.idmateriinterview < id).order_by(Materiinterview.idmateriinterview.desc()).limit(1)
+        else:
+            q = select(Materiinterview).where(Materiinterview.idmateriinterview > id).order_by(Materiinterview.idmateriinterview.asc()).limit(1)
+            
+        target = (await self.db.execute(q)).scalar_one_or_none()
+        
+        if target:
+            temp_q, temp_s = current.question, current.is_active
+            current.question, current.is_active = target.question, target.is_active
+            target.question, target.is_active = temp_q, temp_s
+            await self.db.commit()
+            return True
+        return False
+        
+    async def get_all_word_categories(self):
+        result = await self.db.execute(select(Materifonemkata.kategori).distinct())
+        return result.scalars().all()
+        
+    async def get_all_sentence_categories(self):
+        result = await self.db.execute(select(Materifonemkalimat.kategori).distinct())
+        return result.scalars().all()
+        
+    async def get_words_by_category(self, category: str):
+        result = await self.db.execute(select(Materifonemkata).where(Materifonemkata.kategori == category))
+        return result.scalars().all()
+        
+    async def get_sentences_by_category(self, category: str):
+        result = await self.db.execute(select(Materifonemkalimat).where(Materifonemkalimat.kategori == category))
+        return result.scalars().all()

app/repositories/score_repository.py

@@ -0,0 +1,49 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.models.models import Hasillatihanfonem, Hasillatihanpercakapan, Hasillatihaninterview
+from datetime import datetime
+
+class ScoreRepository:
+    def __init__(self, db: AsyncSession):
+        self.db = db
+
+    async def save_phoneme_result(self, talent_id: int, soal_id: int, type: str, score: float, comparison: dict):
+        # Comparison adalah DICT/JSON, bukan list
+        result = Hasillatihanfonem(
+            idtalent=talent_id,
+            idsoal=soal_id,
+            typelatihan=type,
+            nilai=score,
+            phoneme_comparison=comparison,
+            waktulatihan=datetime.now()
+        )
+        self.db.add(result)
+        await self.db.commit()
+        await self.db.refresh(result)
+        return result
+
+    async def save_chat_result(self, talent_id: int, topic_id: int, wpm: float, grammar: str):
+        result = Hasillatihanpercakapan(
+            idtalent=talent_id,
+            idmateripercakapan=topic_id,
+            wpm=wpm,
+            grammar=grammar,
+            waktulatihan=datetime.now()
+        )
+        self.db.add(result)
+        await self.db.commit()
+        await self.db.refresh(result)
+        return result
+
+    # METHOD UNTUK INTERVIEW
+    async def save_interview_result(self, talent_id: int, wpm: float, grammar: str, feedback: str):
+        result = Hasillatihaninterview(
+            idtalent=talent_id,
+            wpm=wpm,
+            grammar=grammar,
+            feedback=feedback,
+            waktulatihan=datetime.now()
+        )
+        self.db.add(result)
+        await self.db.commit()
+        await self.db.refresh(result)
+        return result

app/repositories/talent_repository.py

@@ -0,0 +1,97 @@
+from sqlalchemy import select, func, or_, desc, and_
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.repositories.base import BaseRepository
+from app.models.models import (
+    Talent, Ujianfonem, Hasillatihanfonem, Materifonemkata, 
+    Materifonemkalimat, Hasillatihanpercakapan, Materipercakapan,
+    Hasillatihaninterview, Detailujianfonem, Materiujiankalimat
+)
+
+class TalentRepository(BaseRepository[Talent]):
+    def __init__(self, db: AsyncSession):
+        super().__init__(Talent, db)
+
+    async def get_by_email(self, email: str):
+        query = select(Talent).where(Talent.email == email)
+        result = await self.db.execute(query)
+        return result.scalar_one_or_none()
+
+    async def get_talents_paginated(self, skip: int = 0, limit: int = 10, search: str = None):
+        query = select(Talent)
+        if search:
+            search_filter = or_(Talent.nama.ilike(f"%{search}%"), Talent.email.ilike(f"%{search}%"))
+            query = query.filter(search_filter)
+        count_query = select(func.count()).select_from(query.subquery())
+        total = await self.db.scalar(count_query)
+        query = query.order_by(Talent.idtalent.asc()).offset(skip).limit(limit)
+        result = await self.db.execute(query)
+        return result.scalars().all(), total
+
+    async def get_talent_progress_stats(self, talent_id: int):
+        q_exam = select(Ujianfonem.nilai).where(Ujianfonem.idtalent == talent_id).order_by(desc(Ujianfonem.waktuujian)).limit(1)
+        latest_exam = await self.db.scalar(q_exam)
+        q_high = select(func.max(Ujianfonem.nilai)).where(Ujianfonem.idtalent == talent_id)
+        highest_exam = await self.db.scalar(q_high)
+        total_word = await self.db.scalar(select(func.count(Materifonemkata.idmaterifonemkata)))
+        total_sent = await self.db.scalar(select(func.count(Materifonemkalimat.idmaterifonemkalimat)))
+        total_materi = (total_word or 0) + (total_sent or 0)
+        q_done = select(func.count(func.distinct(Hasillatihanfonem.idsoal))).where(Hasillatihanfonem.idtalent == talent_id)
+        done = await self.db.scalar(q_done) or 0
+        progress_percent = (done / total_materi * 100) if total_materi > 0 else 0
+        return {"latest_exam": latest_exam, "highest_exam": highest_exam, "progress": progress_percent}
+
+    async def get_phoneme_history_paginated(self, talent_id: int, type_latihan: str, skip: int, limit: int):
+        base_query = select(Hasillatihanfonem).where(and_(Hasillatihanfonem.idtalent == talent_id, Hasillatihanfonem.typelatihan == type_latihan))
+        count_query = select(func.count()).select_from(base_query.subquery())
+        total = await self.db.scalar(count_query) or 0
+        query = base_query.order_by(desc(Hasillatihanfonem.waktulatihan)).offset(skip).limit(limit)
+        result = await self.db.execute(query)
+        items = result.scalars().all()
+        enriched = []
+        for item in items:
+            text_val = "Unknown"
+            category = "General"
+            if type_latihan == "Word":
+                text_val = await self.db.scalar(select(Materifonemkata.kata).where(Materifonemkata.idmaterifonemkata == item.idsoal))
+                category = await self.db.scalar(select(Materifonemkata.kategori).where(Materifonemkata.idmaterifonemkata == item.idsoal))
+            else:
+                text_val = await self.db.scalar(select(Materifonemkalimat.kalimat).where(Materifonemkalimat.idmaterifonemkalimat == item.idsoal))
+                category = await self.db.scalar(select(Materifonemkalimat.kategori).where(Materifonemkalimat.idmaterifonemkalimat == item.idsoal))
+            enriched.append({"category": category, "content": text_val, "score": item.nilai, "date": item.waktulatihan})
+        return enriched, total
+
+    async def get_exam_history_paginated(self, talent_id: int, skip: int, limit: int):
+        base_query = select(Ujianfonem).where(Ujianfonem.idtalent == talent_id)
+        count_query = select(func.count()).select_from(base_query.subquery())
+        total = await self.db.scalar(count_query) or 0
+        query = base_query.order_by(desc(Ujianfonem.waktuujian)).offset(skip).limit(limit)
+        result = await self.db.execute(query)
+        return result.scalars().all(), total
+
+    async def get_exam_attempt_detail(self, talent_id: int, attempt_id: int):
+        exam = await self.db.get(Ujianfonem, attempt_id)
+        if not exam or exam.idtalent != talent_id: return None, None
+        q_details = select(Detailujianfonem, Materiujiankalimat).join(Materiujiankalimat, Detailujianfonem.idsoal == Materiujiankalimat.idmateriujiankalimat).where(Detailujianfonem.idujian == attempt_id)
+        result = await self.db.execute(q_details)
+        return exam, result.all()
+
+    async def get_conversation_history_paginated(self, talent_id: int, skip: int, limit: int):
+        base_query = select(Hasillatihanpercakapan, Materipercakapan.topic).join(Materipercakapan, Hasillatihanpercakapan.idmateripercakapan == Materipercakapan.idmateripercakapan).where(Hasillatihanpercakapan.idtalent == talent_id)
+        count_query = select(func.count()).select_from(base_query.subquery())
+        total = await self.db.scalar(count_query) or 0
+        query = base_query.order_by(desc(Hasillatihanpercakapan.waktulatihan)).offset(skip).limit(limit)
+        result = await self.db.execute(query)
+        return result.all(), total
+
+    async def get_interview_history_paginated(self, talent_id: int, skip: int, limit: int):
+        base_query = select(Hasillatihaninterview).where(Hasillatihaninterview.idtalent == talent_id)
+        count_query = select(func.count()).select_from(base_query.subquery())
+        total = await self.db.scalar(count_query) or 0
+        query = base_query.order_by(desc(Hasillatihaninterview.waktulatihan)).offset(skip).limit(limit)
+        result = await self.db.execute(query)
+        return result.scalars().all(), total
+    
+    async def get_interview_detail(self, talent_id: int, attempt_id: int):
+        query = select(Hasillatihaninterview).where(and_(Hasillatihaninterview.idhasilinterview == attempt_id, Hasillatihaninterview.idtalent == talent_id))
+        result = await self.db.execute(query)
+        return result.scalar_one_or_none()

app/schemas/auth.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, EmailStr
+
+class LoginRequest(BaseModel):
+    email: EmailStr
+    password: str
+
+class TalentCreate(BaseModel):
+    nama: str
+    email: EmailStr
+    password: str
+    role: str = "talent"
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+    role: str
+    user_id: int

app/schemas/conversation.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+class Topic(BaseModel):
+    id: int
+    title: str
+    description: str
+
+class TopicListResponse(BaseModel):
+    topics: List[Topic]
+
+class ChatInput(BaseModel):
+    user_input: str
+    duration: str
+    topic_id: Optional[int] = 1 
+
+class ChatResponse(BaseModel):
+    response: str
+    confidence_score: int
+    grammar_check: str
+
+class ConversationStart(BaseModel):
+    topic: str
+    initial_question: str
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ConversationHistory(BaseModel):
+    session_id: str
+    topic: str
+    history: List[ChatMessage]

app/schemas/dashboard.py

@@ -0,0 +1,67 @@
+from pydantic import BaseModel, EmailStr
+from typing import List, Optional
+
+# --- Stats & Activity ---
+class DashboardStats(BaseModel):
+    totalTalent: int
+    totalPronunciationMaterial: int
+    totalExamPhonemMaterial: int
+    totalInterviewQuestion: int
+
+class RecentActivityItem(BaseModel):
+    talentId: int
+    talentName: str
+    activityType: str
+    category: Optional[str] = "General"
+    score: str
+    date: str
+
+# --- Leaderboards ---
+class LearnerItem(BaseModel):
+    no: int
+    id: int
+    talentName: str
+    email: str
+    # Untuk Top Active
+    highestStreak: Optional[str] = None
+    currentStreak: Optional[str] = None
+    # Untuk Highest Scoring
+    overallCompletion: Optional[str] = None
+    overallPercentage: Optional[str] = None
+    completionRate: Optional[str] = None
+    # Untuk Conversation/Interview
+    wpm: Optional[str] = None
+    grammer: Optional[str] = None
+    feedback: Optional[str] = None
+    date: Optional[str] = None
+    totalAttempts: Optional[int] = None
+
+class PaginationInfo(BaseModel):
+    currentPage: int
+    totalPages: int
+    totalRecords: int
+    showing: str
+
+class PaginatedListResponse(BaseModel):
+    learners: List[LearnerItem]
+    pagination: PaginationInfo
+
+# --- Admin Profile ---
+class AdminProfile(BaseModel):
+    idUser: str
+    name: str
+    email: str
+    role: str
+    createdAt: Optional[str] = None
+    lastLogin: Optional[str] = None
+
+class AdminUpdate(BaseModel):
+    nama: str
+    email: EmailStr
+
+class AdminPasswordUpdate(BaseModel):
+    new_password: str
+
+class DashboardResponse(BaseModel):
+    statistics: DashboardStats
+    recentActivities: List[RecentActivityItem]

app/schemas/exam.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel
+from typing import List, Optional, Any
+
+class ExamStartResponse(BaseModel):
+    id_ujianfonem: int
+    remaining: int
+    data: List[dict]
+
+class ExamResultDetail(BaseModel):
+    idsoal: int
+    kalimat: str
+    nilai: float
+
+class ExamResultResponse(BaseModel):
+    success: bool
+    id_ujian: int
+    kategori: str
+    jumlah_soal: int
+    nilai_rata_rata: float
+    detail: List[ExamResultDetail]

app/schemas/material.py

@@ -0,0 +1,57 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+# --- Shared ---
+class SwapOrderRequest(BaseModel):
+    direction: str = Field(..., pattern="^(up|down)$")
+
+# --- Word Material ---
+class PhonemeWordCreate(BaseModel):
+    phoneme_category: str
+    word: str
+    meaning: str
+    word_definition: Optional[str] = ""
+    phoneme: str
+
+class PhonemeWordUpdate(BaseModel):
+    word: Optional[str] = None
+    meaning: Optional[str] = None
+    word_definition: Optional[str] = None
+    phoneme: Optional[str] = None
+
+# --- Sentence Exercise ---
+class PhonemeSentenceCreate(BaseModel):
+    phoneme_category: str
+    sentence: str = Field(..., min_length=10)
+    phoneme: str
+
+class PhonemeSentenceUpdate(BaseModel):
+    sentence: Optional[str] = None
+    phoneme: Optional[str] = None
+
+# --- Exam ---
+class ExamSentenceItem(BaseModel):
+    id_sentence: int
+    sentence: str
+    phoneme: str
+
+class ExamCreate(BaseModel):
+    category: str
+    items: List[ExamSentenceItem]
+
+class ExamUpdate(BaseModel):
+    sentences: List[ExamSentenceItem]
+
+# --- Interview ---
+class InterviewQuestionCreate(BaseModel):
+    interview_question: str = Field(..., min_length=5)
+
+class InterviewQuestionUpdate(BaseModel):
+    interview_question: str = Field(..., min_length=5)
+
+class InterviewQuestionResponse(BaseModel):
+    questionId: str
+    interviewQuestion: str
+    isActive: bool
+    createdAt: str
+    orderPosition: int

app/schemas/phoneme.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+
+class PhonemeComparisonItem(BaseModel):
+    target: str
+    user: str
+    status: str
+    similarity: int
+
+class PhonemeCheckResponse(BaseModel):
+    similarity_percent: str
+    accuracy_score: float
+    target_phonemes: str
+    user_phonemes: str
+    phoneme_comparison: List[PhonemeComparisonItem]
+    gemini_analysis: Optional[Dict[str, Any]] = None

app/schemas/response.py

@@ -0,0 +1,9 @@
+from typing import Generic, TypeVar, Optional, Any
+from pydantic import BaseModel
+
+T = TypeVar("T")
+
+class ResponseBase(BaseModel, Generic[T]):
+    success: bool = True
+    message: str = "Success"
+    data: Optional[T] = None

app/schemas/talent.py

@@ -0,0 +1,51 @@
+from pydantic import BaseModel, EmailStr, Field, validator
+from typing import Optional, List
+
+# --- READ SCHEMAS (OUTPUT) ---
+
+class TalentDTO(BaseModel):
+    id: int
+    talentName: str = Field(alias="nama")
+    email: EmailStr
+    role: str
+    pretest: str
+    highestExam: str
+    progress: str
+
+    class Config:
+        from_attributes = True
+        populate_by_name = True
+
+class TalentDetailDTO(TalentDTO):
+    """
+    Schema lengkap untuk detail page talent.
+    """
+    total_phoneme_completed: int
+    total_conversation_completed: int
+    total_interview_completed: int
+    last_activity_date: Optional[str] = None
+    average_pronunciation_score: float = 0.0
+    average_speaking_wpm: float = 0.0
+
+# --- WRITE SCHEMAS (INPUT) ---
+
+class TalentUpdate(BaseModel):
+    """
+    Schema untuk update data profile talent (Nama, Email, Role).
+    Semua field optional agar bisa update parsial.
+    """
+    nama: Optional[str] = None
+    email: Optional[EmailStr] = None
+    role: Optional[str] = None
+
+    @validator('nama')
+    def validate_nama(cls, v):
+        if v is not None and not v.strip():
+            raise ValueError('Nama tidak boleh kosong')
+        return v.strip() if v else v
+
+class TalentPasswordUpdate(BaseModel):
+    """
+    Schema khusus untuk ganti password talent.
+    """
+    new_password: str = Field(..., min_length=6, description="Password minimal 6 karakter")

app/seeder.py

@@ -0,0 +1,63 @@
+import asyncio
+import logging
+from passlib.context import CryptContext
+from sqlalchemy import delete
+from app.core.database import AsyncSessionLocal, engine, Base
+from app.models.models import Manajemen
+
+# Logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Password hashing
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def get_password_hash(password: str) -> str:
+    return pwd_context.hash(password)
+
+# Data Admin
+ADMIN_DATA = [
+    {
+        "namamanajemen": "Admin",
+        "email": "admin@gmail.com",
+        "password": "admin123"
+    }
+]
+
+async def init_tables():
+    logger.info("🛠️  Memeriksa dan membuat tabel database...")
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    logger.info("✅ Tabel siap.")
+
+async def seed_admins():
+    await init_tables()
+    logger.info("🌱 Memulai clean seeding data Admin...")
+
+    async with AsyncSessionLocal() as session:
+        try:
+            # 1. HAPUS SEMUA DATA LAMA
+            logger.warning("🧹 Menghapus seluruh data Manajemen...")
+            await session.execute(delete(Manajemen))
+            await session.commit()
+
+            # 2. INSERT DATA BARU
+            for data in ADMIN_DATA:
+                admin = Manajemen(
+                    namamanajemen=data["namamanajemen"],
+                    email=data["email"],
+                    password=get_password_hash(data["password"])
+                )
+                session.add(admin)
+
+            await session.commit()
+            logger.info("🎉 Clean seeding Admin berhasil!")
+
+        except Exception as e:
+            await session.rollback()
+            logger.error(f"❌ Seeder gagal: {e}")
+        finally:
+            await session.close()
+
+if __name__ == "__main__":
+    asyncio.run(seed_admins())

app/services/audio_service.py

@@ -0,0 +1,100 @@
+import io
+import logging
+import numpy as np
+import librosa
+import torch
+import whisper
+import os
+import tempfile
+from transformers import AutoProcessor, AutoModelForCTC
+from starlette.concurrency import run_in_threadpool
+from app.core.exceptions import AppError
+
+logger = logging.getLogger(__name__)
+
+class AudioService:
+    # --- PHONEME MODELS (Wav2Vec2) ---
+    _phoneme_processor = None
+    _phoneme_model = None
+    _sampling_rate = 16000
+    
+    # --- TEXT MODEL (Whisper) ---
+    _whisper_model = None
+
+    @classmethod
+    def _load_phoneme_model(cls):
+        if cls._phoneme_processor is None or cls._phoneme_model is None:
+            try:
+                print("Loading Wav2Vec2 Model...")
+                cls._phoneme_processor = AutoProcessor.from_pretrained("bookbot/wav2vec2-ljspeech-gruut")
+                cls._phoneme_model = AutoModelForCTC.from_pretrained("bookbot/wav2vec2-ljspeech-gruut")
+            except Exception as e:
+                logger.error(f"Failed to load Phoneme model: {e}")
+                raise AppError(status_code=500, detail="Phoneme processing unavailable")
+
+    @classmethod
+    def _load_whisper_model(cls):
+        if cls._whisper_model is None:
+            try:
+                print("Loading Whisper Model...")
+                cls._whisper_model = whisper.load_model("small") # Bisa ganti 'base' atau 'tiny' agar lebih cepat
+            except Exception as e:
+                logger.error(f"Failed to load Whisper model: {e}")
+                raise AppError(status_code=500, detail="Text transcription unavailable")
+
+    @classmethod
+    def _process_phoneme_sync(cls, audio_bytes: bytes) -> str:
+        cls._load_phoneme_model()
+        try:
+            audio, _ = librosa.load(io.BytesIO(audio_bytes), sr=cls._sampling_rate)
+            audio = audio / np.max(np.abs(audio)) # Normalize
+
+            inputs = cls._phoneme_processor(
+                audio, 
+                return_tensors="pt", 
+                sampling_rate=cls._sampling_rate, 
+                padding=True
+            )
+            
+            with torch.no_grad():
+                logits = cls._phoneme_model(inputs.input_values).logits
+            
+            predicted_ids = torch.argmax(logits, dim=-1)
+            transcription = cls._phoneme_processor.batch_decode(predicted_ids)[0]
+            
+            return transcription.strip()
+            
+        except Exception as e:
+            logger.error(f"Phoneme processing error: {e}")
+            raise AppError(status_code=400, detail="Failed to process audio file")
+
+    @classmethod
+    def _process_whisper_sync(cls, audio_bytes: bytes) -> str:
+        cls._load_whisper_model()
+        try:
+            # Whisper butuh file path, jadi kita buat temp file
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_audio:
+                temp_audio.write(audio_bytes)
+                temp_path = temp_audio.name
+            
+            try:
+                result = cls._whisper_model.transcribe(temp_path, language="en")
+                return result["text"].strip()
+            finally:
+                # Cleanup temp file
+                if os.path.exists(temp_path):
+                    os.remove(temp_path)
+                    
+        except Exception as e:
+            logger.error(f"Whisper processing error: {e}")
+            raise AppError(status_code=400, detail="Failed to transcribe text")
+
+    @classmethod
+    async def transcribe(cls, audio_bytes: bytes) -> str:
+        """Transcribe to Phonemes (Async wrapper)"""
+        return await run_in_threadpool(cls._process_phoneme_sync, audio_bytes)
+
+    @classmethod
+    async def transcribe_text(cls, audio_bytes: bytes) -> str:
+        """Transcribe to English Text (Async wrapper for Whisper)"""
+        return await run_in_threadpool(cls._process_whisper_sync, audio_bytes)

app/services/auth_service.py

@@ -0,0 +1,94 @@
+from datetime import datetime, timedelta
+from typing import Any, Union
+from jose import jwt
+from passlib.context import CryptContext
+from app.core.config import settings
+from app.core.exceptions import AuthenticationError, DuplicateError
+from app.repositories.talent_repository import TalentRepository
+from app.schemas.auth import LoginRequest, TalentCreate
+from app.models.models import Manajemen
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+class AuthService:
+    def __init__(self, talent_repo: TalentRepository):
+        self.talent_repo = talent_repo
+
+    def verify_password(self, plain_password: str, hashed_password: str) -> bool:
+        return pwd_context.verify(plain_password, hashed_password)
+
+    def get_password_hash(self, password: str) -> str:
+        return pwd_context.hash(password)
+
+    def create_access_token(self, subject: Union[str, Any], role: str, extra_data: dict = None) -> str:
+        expire = datetime.utcnow() + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+        to_encode = {
+            "exp": expire, 
+            "sub": str(subject), 
+            "role": role, 
+            "id": subject
+        }
+        if extra_data:
+            to_encode.update(extra_data)
+            
+        encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+        return encoded_jwt
+
+    async def authenticate_talent(self, login_data: LoginRequest) -> dict:
+        talent = await self.talent_repo.get_by_email(login_data.email)
+        
+        if not talent:
+            raise AuthenticationError("Email tidak terdaftar")
+        
+        if not self.verify_password(login_data.password, talent.password):
+            raise AuthenticationError("Password salah")
+        
+        token = self.create_access_token(talent.idtalent, role="talent")
+        
+        return {
+            "access_token": token,
+            "token_type": "bearer",
+            "role": "talent",
+            "user_id": str(talent.idtalent)
+        }
+
+    async def register_talent(self, data: TalentCreate):
+        existing = await self.talent_repo.get_by_email(data.email)
+        if existing:
+            raise DuplicateError("Email sudah terdaftar")
+        
+        hashed_pw = self.get_password_hash(data.password)
+        
+        new_talent_data = {
+            "nama": data.nama,
+            "email": data.email,
+            "password": hashed_pw,
+            "role": data.role
+        }
+        
+        return await self.talent_repo.create(new_talent_data)
+    
+    async def authenticate_admin(self, login_data: LoginRequest, db_session: AsyncSession) -> dict:
+        """Autentikasi khusus untuk Manajemen/Admin"""
+        query = select(Manajemen).where(Manajemen.email == login_data.email)
+        result = await db_session.execute(query)
+        admin = result.scalar_one_or_none()
+        
+        if not admin:
+            raise AuthenticationError("Admin email tidak terdaftar")
+        
+        if not self.verify_password(login_data.password, admin.password):
+            raise AuthenticationError("Password admin salah")
+            
+        token = self.create_access_token(admin.idmanajemen, role="manajemen")
+        
+        return {
+            "access_token": token,
+            "token_type": "bearer",
+            "idUser": f"ADM{admin.idmanajemen:03d}",
+            "name": admin.namamanajemen,
+            "role": "admin",
+            "email": admin.email
+        }

app/services/conversation_service.py

@@ -0,0 +1,68 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.repositories.material_repository import MaterialRepository
+from app.repositories.score_repository import ScoreRepository
+from app.services.llm_service import LLMService
+from app.core.exceptions import AppError
+import json
+import re
+
+class ConversationService:
+    def __init__(self, db: AsyncSession):
+        self.material_repo = MaterialRepository(db)
+        self.score_repo = ScoreRepository(db)
+
+    # Hardcoded Topics
+    HARDCODED_TOPICS = [
+        {"id": 1, "title": "Technology Trends", "description": "Discussing AI, Blockchain, and future tech."},
+        {"id": 2, "title": "Job Interview", "description": "General job interview preparation."},
+        {"id": 3, "title": "Daily Routine", "description": "Talk about hobbies, work, and daily life."},
+        {"id": 4, "title": "Travel & Culture", "description": "Discussing vacation spots and cultural differences."},
+        {"id": 5, "title": "Business Meeting", "description": "Simulate a formal business meeting environment."},
+    ]
+
+    async def get_topics(self):
+        return self.HARDCODED_TOPICS
+
+    async def start_session(self):
+        return {"topic": "Select a topic", "message": "Please select a topic to begin."}
+
+    async def process_chat(self, user_input: str, duration: str, talent_id: int, topic_id: int = 1):
+        selected_topic = next((t for t in self.HARDCODED_TOPICS if t["id"] == topic_id), self.HARDCODED_TOPICS[0])
+        topic_name = selected_topic["title"]
+
+        from app.utils.calculation_utils import CalculationHelper
+        wpm = CalculationHelper.calculate_wpm(user_input, duration)
+        confidence = min(100, max(0, int(wpm)))
+        
+        prompt = f"""
+        Context: Professional Conversation about '{topic_name}'.
+        User said: "{user_input}"
+        Task: Check grammar & Respond naturally relevant to the topic.
+        Return JSON: {{ "grammar_check": "...", "response": "..." }}
+        """
+        ai_raw = await LLMService.generate(prompt)
+        
+        # Parse AI
+        response_text = ai_raw
+        grammar_text = "Analysis included"
+        try:
+            match = re.search(r'\{.*\}', ai_raw, re.DOTALL)
+            if match:
+                js = json.loads(match.group())
+                response_text = js.get("response", ai_raw)
+                grammar_text = js.get("grammar_check", "")
+        except:
+            pass
+
+        await self.score_repo.save_chat_result(
+            talent_id=talent_id,
+            topic_id=1, 
+            wpm=wpm,
+            grammar=grammar_text[:255]
+        )
+
+        return {
+            "response": response_text,
+            "confidence_score": confidence,
+            "grammar_check": grammar_text
+        }

app/services/dashboard_service.py

@@ -0,0 +1,151 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.repositories.dashboard_repository import DashboardRepository
+from app.repositories.base import BaseRepository
+from app.models.models import Manajemen
+from app.utils.time_utils import TimeUtils
+from app.core.exceptions import NotFoundError
+from passlib.context import CryptContext
+from typing import List, Dict, Optional
+from datetime import datetime
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+class DashboardService:
+    def __init__(self, db: AsyncSession):
+        self.repo = DashboardRepository(db)
+        self.db = db
+
+    async def get_admin_dashboard(
+        self, 
+        limit: int = 10, 
+        days_back: int = 30,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None
+    ):
+        stats = await self.repo.get_total_counts()
+        activities = await self.repo.get_recent_activities(
+            limit=limit, 
+            days_back=days_back,
+            start_date=start_date,
+            end_date=end_date
+        )
+        
+        formatted_activities = []
+        for act in activities:
+            new_act = dict(act)
+            new_act["date"] = TimeUtils.format_to_wib(act["date"])
+            formatted_activities.append(new_act)
+
+        return {
+            "statistics": stats,
+            "recentActivities": formatted_activities,
+            "filter": {
+                "limit": limit,
+                "daysBack": days_back,
+                "dateRange": "Custom" if start_date else f"Last {days_back} days"
+            }
+        }
+
+    async def get_leaderboard(self, category: str, page: int, limit: int, search: str):
+        data = []
+        total_records = 0
+        
+        if category == "topActive":
+            all_talents = await self.repo.get_all_talents(search)
+            all_activities = await self.repo.get_all_activities_dates()
+            talent_dates: Dict[int, List[datetime]] = {t.idtalent: [] for t in all_talents}
+            for row in all_activities:
+                if row.idtalent in talent_dates:
+                    talent_dates[row.idtalent].append(row.waktulatihan)
+            
+            processed_talents = []
+            for talent in all_talents:
+                dates = talent_dates[talent.idtalent]
+                highest, current = TimeUtils.calculate_streaks(dates)
+                processed_talents.append({
+                    "id": talent.idtalent,
+                    "talentName": talent.nama,
+                    "email": talent.email,
+                    "highestStreak": f"{highest} Days",
+                    "currentStreak": f"{current} Days",
+                    "_sort_current": current,
+                    "_sort_highest": highest
+                })
+            
+            processed_talents.sort(key=lambda x: (-x["_sort_current"], -x["_sort_highest"], x["talentName"]))
+            total_records = len(processed_talents)
+            start_idx = (page - 1) * limit
+            paged_data = processed_talents[start_idx:start_idx+limit]
+            
+            for i, item in enumerate(paged_data):
+                clean_item = {k: v for k, v in item.items() if not k.startswith('_')}
+                clean_item["no"] = start_idx + i + 1
+                data.append(clean_item)
+
+        elif category in ["phoneme_material_exercise", "phoneme_exercise"]:
+            type_latihan = "Word" if category == "phoneme_material_exercise" else "Sentence"
+            results = await self.repo.get_highest_scoring_phoneme(type_latihan)
+            if search: results = [r for r in results if search.lower() in r.nama.lower()]
+            total_records = len(results)
+            sorted_res = sorted(results, key=lambda x: (-x.avg_score, -x.attempted))
+            start_idx = (page - 1) * limit
+            paged = sorted_res[start_idx:start_idx+limit]
+            for i, row in enumerate(paged):
+                data.append({
+                    "no": start_idx + i + 1, "id": row.idtalent, "talentName": row.nama, "email": row.email,
+                    "overallCompletion": f"{row.attempted} attempted", "overallPercentage": f"{row.avg_score:.0f}%", "completionRate": "N/A"
+                })
+
+        elif category == "phoneme_exam":
+            results = await self.repo.get_highest_scoring_exam()
+            if search: results = [r for r in results if search.lower() in r.nama.lower()]
+            total_records = len(results)
+            sorted_res = sorted(results, key=lambda x: (-x.avg_score, -x.categories_attempted))
+            start_idx = (page - 1) * limit
+            paged = sorted_res[start_idx:start_idx+limit]
+            for i, row in enumerate(paged):
+                data.append({
+                    "no": start_idx + i + 1, "id": row.idtalent, "talentName": row.nama, "email": row.email,
+                    "overallCompletion": f"{row.categories_attempted} categories", "overallPercentage": f"{row.avg_score:.0f}%", "totalAttempts": row.total_attempts
+                })
+
+        elif category in ["conversation", "interview"]:
+            is_interview = category == "interview"
+            results = await (self.repo.get_highest_scoring_interview() if is_interview else self.repo.get_highest_scoring_conversation())
+            if search: results = [r for r in results if search.lower() in r.nama.lower()]
+            total_records = len(results)
+            sorted_res = sorted(results, key=lambda x: (-x.avg_wpm, -x.total_attempts))
+            start_idx = (page - 1) * limit
+            paged = sorted_res[start_idx:start_idx+limit]
+            for i, row in enumerate(paged):
+                data.append({
+                    "no": start_idx + i + 1, "id": row.idtalent, "talentName": row.nama, "email": row.email,
+                    "wpm": f"{row.avg_wpm:.0f} WPM", "totalAttempts": row.total_attempts, "date": TimeUtils.format_to_wib(row.last_date)
+                })
+
+        total_pages = (total_records + limit - 1) // limit if limit > 0 else 0
+        showing_start = ((page - 1) * limit) + 1 if total_records > 0 else 0
+        showing_end = min(page * limit, total_records)
+        
+        return {
+            "learners": data,
+            "pagination": {
+                "currentPage": page, "totalPages": total_pages, "totalRecords": total_records,
+                "showing": f"Showing {showing_start} to {showing_end} of {total_records} entries"
+            }
+        }
+
+    async def update_admin(self, admin_id: int, nama: str, email: str):
+        repo_base = BaseRepository(Manajemen, self.db)
+        admin = await repo_base.get_by_id(admin_id)
+        if not admin: raise NotFoundError("Admin")
+        existing = await self.repo.get_admin_by_email(email)
+        if existing and existing.idmanajemen != admin_id: raise ValueError("Email already used")
+        return await repo_base.update(admin, {"namamanajemen": nama, "email": email})
+
+    async def change_admin_password(self, admin_id: int, new_password: str):
+        repo_base = BaseRepository(Manajemen, self.db)
+        admin = await repo_base.get_by_id(admin_id)
+        if not admin: raise NotFoundError("Admin")
+        hashed = pwd_context.hash(new_password)
+        return await repo_base.update(admin, {"password": hashed})

app/services/exam_service.py

@@ -0,0 +1,106 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.repositories.exam_repository import ExamRepository
+from app.services.audio_service import AudioService
+from app.utils.phoneme_utils import PhonemeMatcher
+from app.core.exceptions import NotFoundError, AppError
+
+class ExamService:
+    def __init__(self, db: AsyncSession):
+        self.repo = ExamRepository(db)
+
+    async def start_exam_session(self, talent_id: int, material_exam_id: int):
+        # 1. Cek materi ada tidak
+        materi = await self.repo.get_materi_header(material_exam_id)
+        if not materi:
+            raise NotFoundError("Materi Ujian")
+
+        # 2. Cek apakah ada sesi ujian yang belum selesai (nilai is None)
+        ujian = await self.repo.get_active_exam(talent_id, material_exam_id)
+        
+        # Jika tidak ada sesi aktif, buat baru
+        if not ujian:
+            ujian = await self.repo.create_exam_entry(talent_id, material_exam_id, materi.kategori)
+
+        # 3. Cek soal mana saja yang sudah dikerjakan
+        answered_ids = await self.repo.get_answered_question_ids(ujian.idujian)
+        
+        # 4. Jika sudah 10 soal terjawab, berarti ujian selesai
+        # (Dalam kasus edge case dimana status belum terupdate)
+        if len(answered_ids) >= 10:
+            # Trigger finish calculation just in case
+            await self.finish_exam(ujian.idujian)
+            return {"message": "Ujian telah selesai", "id_ujianfonem": ujian.idujian, "data": []}
+
+        # 5. Ambil sisa soal yang belum dikerjakan
+        remaining_q = await self.repo.get_remaining_questions(material_exam_id, answered_ids)
+        
+        # Format data untuk mobile
+        data = [
+            {
+                "id": q.idmateriujiankalimat, 
+                "kalimat": q.kalimat, 
+                "fonem": q.fonem,
+                "kategori": materi.kategori # Tambahan info kategori
+            } 
+            for q in remaining_q
+        ]
+        
+        return {
+            "id_ujianfonem": ujian.idujian,
+            "remaining": len(remaining_q),
+            "data": data
+        }
+
+    async def process_answer(self, ujian_id: int, soal_id: int, audio_bytes: bytes):
+        # 1. Ambil kalimat target
+        soal = await self.repo.get_materi_kalimat(soal_id)
+        if not soal: raise NotFoundError("Soal")
+        
+        # 2. Transkripsi & Scoring (Heavy Task)
+        user_phonemes = await AudioService.transcribe(audio_bytes)
+        alignment = PhonemeMatcher.align_phonemes(soal.fonem, user_phonemes)
+        score = PhonemeMatcher.calculate_accuracy(alignment)
+        
+        # 3. Simpan Detail Jawaban
+        await self.repo.save_detail_answer(ujian_id, soal_id, score)
+        
+        return {
+            "similarity_percent": f"{score}%",
+            "phoneme_comparison": alignment,
+            "user_phonemes": user_phonemes,
+            "target_phonemes": soal.fonem
+        }
+
+    async def finish_exam(self, ujian_id: int):
+        """Menghitung nilai akhir dan menutup sesi ujian"""
+        details_with_q = await self.repo.get_exam_details_with_questions(ujian_id)
+        
+        if not details_with_q:
+            raise AppError(status_code=400, detail="Belum ada soal yang dikerjakan")
+            
+        # Hitung rata-rata
+        total_score = sum(row.Detailujianfonem.nilai for row in details_with_q)
+        count = len(details_with_q)
+        avg_score = round(total_score / count, 2) if count > 0 else 0
+        
+        # Update header ujian
+        ujian = await self.repo.update_final_score(ujian_id, avg_score)
+        
+        # Format detail untuk response result screen
+        detail_list = [
+            {
+                "idsoal": row.Detailujianfonem.idsoal,
+                "kalimat": row.kalimat,
+                "nilai": row.Detailujianfonem.nilai
+            }
+            for row in details_with_q
+        ]
+
+        return {
+            "success": True,
+            "id_ujian": ujian.idujian,
+            "kategori": ujian.kategori,
+            "jumlah_soal": count,
+            "nilai_rata_rata": avg_score,
+            "detail": detail_list
+        }

app/services/interview_service.py

@@ -0,0 +1,73 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.repositories.material_repository import MaterialRepository
+from app.repositories.score_repository import ScoreRepository
+from app.services.llm_service import LLMService
+from app.utils.calculation_utils import CalculationHelper
+from app.core.exceptions import AppError, NotFoundError
+import json
+import uuid
+from typing import Dict, Any
+
+class InterviewService:
+    _sessions: Dict[str, Any] = {}
+
+    def __init__(self, db: AsyncSession):
+        self.material_repo = MaterialRepository(db)
+        self.score_repo = ScoreRepository(db)
+
+    async def start_session(self, session_id: str):
+        if not session_id: session_id = str(uuid.uuid4())
+        questions = await self.material_repo.get_interview_questions(0, 100)
+        if not questions: raise NotFoundError("Interview Questions")
+        self._sessions[session_id] = {"questions": [q.question for q in questions], "current_index": 0, "step": "main", "history": [], "answers": [], "completed": False, "off_topic_count": 0}
+        return {"session_id": session_id, "question": questions[0].question, "step": "main"}
+
+    async def get_session_status(self, session_id: str):
+        session = self._sessions.get(session_id)
+        if not session: return {"status": "not_found", "session_exists": False}
+        return {"success": True, "status": {"session_id": session_id, "interview_started": True, "interview_completed": session["completed"], "current_question_index": session["current_index"], "total_questions": len(session["questions"]), "current_step": session["step"], "session_exists": True}}
+
+    async def process_answer(self, session_id: str, answer: str, duration: str):
+        session = self._sessions.get(session_id)
+        if not session: raise AppError(status_code=400, detail="Session expired. Please restart.")
+        if session["completed"]: return {"status": "completed", "message": "Interview already finished."}
+        current_q_text = session["questions"][session["current_index"]]
+        
+        if session["step"] == "main":
+            relevance = await LLMService.check_relevance(current_q_text, answer)
+            if not relevance.get("is_relevant", True):
+                session["off_topic_count"] += 1
+                return {"status": "off_topic", "message": f"Your answer seems unrelated. {relevance.get('reason', 'Please focus on the question.')} Let's try again: {current_q_text}", "interview_completed": False}
+
+        wpm = CalculationHelper.calculate_wpm(answer, duration)
+        session["answers"].append({"question": current_q_text, "answer": answer, "wpm": wpm})
+        session["history"].append({"role": "user", "content": answer})
+
+        if session["step"] == "main":
+            ai_resp = await LLMService.generate_interview_followup(current_q_text, answer)
+            session["step"] = "followup"
+            followup_q = ai_resp.get("followup_question", "Could you explain more?")
+            session["history"].append({"role": "interviewer", "content": followup_q})
+            return {"status": "continue", "feedback": ai_resp.get("feedback", "Good."), "message": followup_q, "interview_completed": False}
+            
+        elif session["step"] == "followup":
+            session["current_index"] += 1
+            session["step"] = "main"
+            if session["current_index"] >= len(session["questions"]):
+                session["completed"] = True
+                return {"status": "completed", "feedback": "Excellent. That concludes our interview.", "message": "Interview completed.", "interview_completed": True}
+            next_q = session["questions"][session["current_index"]]
+            session["history"].append({"role": "interviewer", "content": next_q})
+            return {"status": "continue", "feedback": "Thank you.", "message": next_q, "interview_completed": False}
+
+    async def generate_summary(self, session_id: str, talent_id: int):
+        session = self._sessions.get(session_id)
+        if not session: raise AppError(status_code=400, detail="Session not found")
+        ai_summary = await LLMService.generate_interview_feedback(session["history"])
+        answers = session["answers"]
+        total_wpm = sum(a["wpm"] for a in answers)
+        avg_wpm = total_wpm / len(answers) if answers else 0
+        grammar_score = ai_summary.get("summary", {}).get("overall_performance", {}).get("grammar_usage", "Fair")
+        saved_record = await self.score_repo.save_interview_result(talent_id=talent_id, wpm=avg_wpm, grammar=grammar_score, feedback=json.dumps(ai_summary))
+        if session_id in self._sessions: del self._sessions[session_id]
+        return {"success": True, "summary": ai_summary.get("summary"), "statistics": {"average_wpm": round(avg_wpm, 2), "total_answers": len(answers)}, "id": saved_record.idhasilinterview}

app/services/llm_service.py

@@ -0,0 +1,146 @@
+import aiohttp
+import logging
+import json
+import re
+from typing import Dict, Any, List
+from app.core.config import settings
+from app.core.exceptions import AppError
+
+logger = logging.getLogger(__name__)
+
+class LLMService:
+    HEADERS = {"Content-Type": "application/json"}
+
+    @staticmethod
+    def _clean_json_string(text: str) -> str:
+        text = re.sub(r'```json\s*', '', text)
+        text = re.sub(r'```\s*', '', text)
+        return text.strip()
+
+    @staticmethod
+    async def _send_request(payload: dict) -> str:
+        url = f"{settings.GEMINI_API_URL}?key={settings.GEMINI_API_KEY}"
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    url, 
+                    json=payload, 
+                    headers=LLMService.HEADERS, 
+                    timeout=30
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        logger.error(f"Gemini API Error ({response.status}): {error_text}")
+                        if response.status == 429:
+                            raise AppError(status_code=429, detail="AI Traffic Limit Exceeded")
+                        raise AppError(status_code=502, detail="AI Service Provider Error")
+                    
+                    data = await response.json()
+                    try:
+                        return data["candidates"][0]["content"]["parts"][0]["text"]
+                    except (KeyError, IndexError):
+                        logger.error(f"Unexpected API Response format: {data}")
+                        return "{}"
+        except Exception as e:
+            logger.error(f"LLM Network Error: {e}")
+            if isinstance(e, AppError):
+                raise e
+            return "{}"
+    
+    @staticmethod
+    async def generate(prompt_text: str) -> str:
+        return await LLMService._send_request({
+            "contents": [{"parts": [{"text": prompt_text}]}]
+        })
+
+    @staticmethod
+    async def generate_with_history(history: List[Dict[str, str]], system_prompt: str) -> str:
+        contents = []
+        for msg in history:
+            role = "user" if msg["role"] == "user" else "model"
+            contents.append({"role": role, "parts": [{"text": msg["content"]}]})
+        
+        if contents and contents[-1]["role"] == "user":
+            contents[-1]["parts"][0]["text"] += f"\n\nSYSTEM INSTRUCTION: {system_prompt}"
+        else:
+            contents.append({"role": "user", "parts": [{"text": f"SYSTEM INSTRUCTION: {system_prompt}"}]})
+
+        return await LLMService._send_request({"contents": contents})
+
+    @staticmethod
+    async def generate_interview_followup(prev_question: str, answer: str) -> Dict[str, Any]:
+        prompt = f"""
+        SYSTEM ROLE: Technical Recruiter.
+        Context: Q: "{prev_question}" A: "{answer}"
+        Task: 1 sentence feedback, 1 probing follow-up question.
+        Return JSON: {{ "feedback": "...", "followup_question": "..." }}
+        """
+        raw = await LLMService.generate(prompt)
+        try:
+            return json.loads(LLMService._clean_json_string(raw))
+        except:
+            return {"feedback": "Thank you.", "followup_question": "Can you elaborate?"}
+
+    @staticmethod
+    async def generate_interview_feedback(history: List[Dict[str, str]]) -> Dict[str, Any]:
+        history_text = "\n".join([f"{h['role'].upper()}: {h['content']}" for h in history])
+        prompt = f"""
+        Analyze this interview transcript:
+        {history_text}
+        
+        Return JSON:
+        {{
+            "summary": {{
+                "strengths": ["pt1", "pt2"],
+                "weaknesses": ["pt1", "pt2"],
+                "overall_performance": {{
+                    "technical_knowledge": "Good/Fair/Poor",
+                    "communication_speed": "Fast/Avg/Slow",
+                    "grammar_usage": "Good/Bad",
+                    "recommendation": "Hire/No Hire"
+                }}
+            }}
+        }}
+        """
+        raw = await LLMService.generate(prompt)
+        try:
+            return json.loads(LLMService._clean_json_string(raw))
+        except:
+            return {"summary": {}}
+
+    @staticmethod
+    async def check_relevance(question: str, answer: str) -> Dict[str, Any]:
+        prompt = f"""
+        Question: "{question}" Answer: "{answer}"
+        Is the answer logically relevant?
+        Return JSON: {{ "is_relevant": true/false, "reason": "..." }}
+        """
+        raw = await LLMService.generate(prompt)
+        try:
+            return json.loads(LLMService._clean_json_string(raw))
+        except:
+            return {"is_relevant": True}
+
+    @staticmethod
+    async def analyze_phoneme_quality(target: str, user: str, text: str) -> Dict[str, Any]:
+        prompt = f"""
+        Phonetic Analysis.
+        Text: "{text}"
+        Target IPA: {target}
+        User IPA: {user}
+        
+        Return JSON:
+        {{
+            "native_understandable": true/false,
+            "overall_feedback": "string",
+            "specific_issues": [{{"phoneme": "p", "issue": "desc", "suggestion": "tip"}}],
+            "strengths": ["list"],
+            "improvement_tips": ["list"]
+        }}
+        """
+        raw = await LLMService.generate(prompt)
+        try:
+            return json.loads(LLMService._clean_json_string(raw))
+        except:
+            return {}

app/services/material_service.py

@@ -0,0 +1,235 @@
+import pandas as pd
+import io
+from app.repositories.material_repository import MaterialRepository
+from app.core.exceptions import AppError, NotFoundError
+from app.utils.time_utils import TimeUtils
+
+class MaterialService:
+    def __init__(self, repo: MaterialRepository):
+        self.repo = repo
+
+    def _validate_columns(self, df: pd.DataFrame, required: list):
+        df.columns = df.columns.str.lower().str.strip()
+        missing = [col for col in required if col not in df.columns]
+        if missing:
+            raise AppError(status_code=400, detail=f"Missing columns: {', '.join(missing)}")
+
+    def _validate_phoneme_content(self, phoneme: str, category: str, text: str):
+        """Strict validation ensuring phonemes match category"""
+        if "-" in category:
+            target_phonemes = category.split("-")
+            for p in target_phonemes:
+                if p not in phoneme:
+                    raise AppError(status_code=400, detail=f"Phoneme transcription must contain all targets from category '{category}'. Missing: {p}")
+        else:
+            if category not in phoneme:
+                raise AppError(status_code=400, detail=f"Phoneme transcription must contain target '{category}'")
+
+    async def get_phoneme_materials_list(self, page: int, limit: int, search: str):
+        skip = (page - 1) * limit
+        items, total = await self.repo.get_phoneme_materials_paginated(skip, limit, search)
+        
+        data = []
+        for item in items:
+            data.append({
+                "phoneme": item[0],
+                "phonemeCategory": item[0],
+                "totalWords": item[1],
+                "lastUpdate": TimeUtils.format_to_wib(item[2])
+            })
+            
+        return {
+            "phonemeMaterials": data,
+            "pagination": {
+                "currentPage": page,
+                "totalRecords": total,
+                "totalPages": (total + limit - 1) // limit
+            }
+        }
+
+    async def get_exercise_materials_list(self, page: int, limit: int, search: str):
+        skip = (page - 1) * limit
+        items, total = await self.repo.get_exercise_materials_paginated(skip, limit, search)
+        
+        data = []
+        for item in items:
+            data.append({
+                "phonemeCategory": item[0],
+                "totalSentence": item[1],
+                "lastUpdate": TimeUtils.format_to_wib(item[2])
+            })
+            
+        return {
+            "exercisePhonemes": data,
+            "pagination": {
+                "currentPage": page,
+                "totalRecords": total,
+                "totalPages": (total + limit - 1) // limit
+            }
+        }
+
+    async def get_exam_materials_list(self, page: int, limit: int, search: str):
+        skip = (page - 1) * limit
+        items, total = await self.repo.get_exam_materials_paginated(skip, limit, search)
+        
+        data = []
+        for item in items:
+            data.append({
+                "phonemeCategory": item[0],
+                "totalExam": item[1],
+                "lastUpdate": TimeUtils.format_to_wib(item[2])
+            })
+            
+        return {
+            "examPhonemes": data,
+            "pagination": {
+                "currentPage": page,
+                "totalRecords": total,
+                "totalPages": (total + limit - 1) // limit
+            }
+        }
+
+    async def import_words_from_excel(self, file_content: bytes):
+        try:
+            df = pd.read_excel(io.BytesIO(file_content))
+            self._validate_columns(df, ['kategori', 'kata', 'fonem', 'arti', 'definisi'])
+            
+            success, errors = 0, []
+            for idx, row in df.iterrows():
+                try:
+                    cat = str(row['kategori']).strip()
+                    word = str(row['kata']).strip()
+                    phon = str(row['fonem']).strip()
+                    
+                    self._validate_phoneme_content(phon, cat, word)
+                    
+                    data = {
+                        "kategori": cat, "kata": word, "fonem": phon,
+                        "meaning": str(row['arti']).strip(), 
+                        "definition": str(row['definisi']).strip()
+                    }
+                    await self.repo.create_word(data)
+                    success += 1
+                except Exception as e:
+                    errors.append({"row": idx + 2, "error": str(e)})
+            
+            return {"successCount": success, "errorCount": len(errors), "errors": errors}
+        except Exception as e:
+            raise AppError(status_code=400, detail=f"Import failed: {str(e)}")
+
+    async def import_sentences_from_excel(self, file_content: bytes):
+        try:
+            df = pd.read_excel(io.BytesIO(file_content))
+            self._validate_columns(df, ['kategori', 'kalimat', 'fonem'])
+            
+            success, errors = 0, []
+            for idx, row in df.iterrows():
+                try:
+                    cat = str(row['kategori']).strip()
+                    sent = str(row['kalimat']).strip()
+                    phon = str(row['fonem']).strip()
+                    
+                    if len(sent.split()) < 4:
+                        raise ValueError("Sentence must have at least 4 words")
+                    
+                    self._validate_phoneme_content(phon, cat, sent)
+                    
+                    await self.repo.create_sentence({
+                        "kategori": cat, "kalimat": sent, "fonem": phon
+                    })
+                    success += 1
+                except Exception as e:
+                    errors.append({"row": idx + 2, "error": str(e)})
+            
+            return {"successCount": success, "errorCount": len(errors), "errors": errors}
+        except Exception as e:
+            raise AppError(status_code=400, detail=f"Import failed: {str(e)}")
+
+    async def import_exams_from_excel(self, file_content: bytes):
+        try:
+            df = pd.read_excel(io.BytesIO(file_content))
+            req_cols = ['kategori'] + [f'kalimat_{i}' for i in range(1, 11)] + [f'fonem_{i}' for i in range(1, 11)]
+            self._validate_columns(df, req_cols)
+            
+            success, errors = 0, []
+            for idx, row in df.iterrows():
+                try:
+                    category = str(row['kategori']).strip()
+                    if "-" not in category:
+                         raise ValueError("Exam category must be a pair (e.g. i-I)")
+                         
+                    items = []
+                    for i in range(1, 11):
+                        sent = str(row[f'kalimat_{i}']).strip()
+                        phon = str(row[f'fonem_{i}']).strip()
+                        if not sent or not phon:
+                            raise ValueError(f"Missing data at index {i}")
+                        
+                        self._validate_phoneme_content(phon, category, sent)
+                        items.append({"sentence": sent, "phoneme": phon})
+                    
+                    await self.repo.create_exam_set(category, items)
+                    success += 1
+                except Exception as e:
+                    errors.append({"row": idx + 2, "error": str(e)})
+            
+            return {"successCount": success, "errorCount": len(errors), "errors": errors}
+        except Exception as e:
+            raise AppError(status_code=400, detail=f"Import failed: {str(e)}")
+
+    async def update_word(self, id: int, data: dict):
+        word = await self.repo.get_word_by_id(id)
+        if not word: raise NotFoundError("Word")
+        await self.repo.update_word(id, data)
+
+    async def delete_word(self, id: int):
+        word = await self.repo.get_word_by_id(id)
+        if not word: raise NotFoundError("Word")
+        await self.repo.delete_word(id)
+
+    async def create_sentence(self, data: dict):
+        if len(data['sentence'].split()) < 4:
+             raise AppError(status_code=400, detail="Sentence too short")
+        return await self.repo.create_sentence(data)
+
+    async def update_sentence(self, id: int, data: dict):
+        sent = await self.repo.get_sentence_by_id(id)
+        if not sent: raise NotFoundError("Sentence")
+        await self.repo.update_sentence(id, data)
+
+    async def delete_sentence(self, id: int):
+        sent = await self.repo.get_sentence_by_id(id)
+        if not sent: raise NotFoundError("Sentence")
+        await self.repo.delete_sentence(id)
+
+    async def delete_exam(self, id: int):
+        exam = await self.repo.get_exam_header(id)
+        if not exam: raise NotFoundError("Exam")
+        await self.repo.delete_exam(id)
+
+    async def update_exam_sentences(self, exam_id: int, items: list):
+        for item in items:
+            if len(item.sentence.split()) < 4:
+                raise AppError(status_code=400, detail="Exam sentence must be >= 4 words")
+        items_dict = [item.model_dump() for item in items]
+        await self.repo.update_exam_sentences(exam_id, items_dict)
+
+    async def update_interview(self, id: int, question: str):
+        q = await self.repo.get_interview_question_by_id(id)
+        if not q: raise NotFoundError("Question")
+        await self.repo.update_interview_question(id, question)
+
+    async def delete_interview(self, id: int):
+        q = await self.repo.get_interview_question_by_id(id)
+        if not q: raise NotFoundError("Question")
+        await self.repo.delete_interview_question(id)
+
+    async def toggle_interview(self, id: int):
+        q = await self.repo.get_interview_question_by_id(id)
+        if not q: raise NotFoundError("Question")
+        return await self.repo.toggle_interview_status(id)
+
+    async def swap_interview(self, id: int, direction: str):
+        success = await self.repo.swap_interview_order(id, direction)
+        if not success:
+            raise AppError(status_code=400, detail="Cannot move in that direction")

app/services/phoneme_service.py

@@ -0,0 +1,122 @@
+from datetime import datetime
+from app.repositories.material_repository import MaterialRepository
+from app.repositories.score_repository import ScoreRepository
+from app.services.audio_service import AudioService
+from app.services.llm_service import LLMService
+from app.utils.phoneme_utils import PhonemeMatcher
+from app.core.exceptions import NotFoundError
+from gruut import sentences as gruut_sentences
+
+class PhonemeService:
+    def __init__(self, material_repo: MaterialRepository, score_repo: ScoreRepository):
+        self.material_repo = material_repo
+        self.score_repo = score_repo
+
+    def _generate_phonemes_fallback(self, text: str) -> str:
+        """Fallback to generate phonemes if DB is empty"""
+        try:
+            phonemes = []
+            for sentence in gruut_sentences(text, lang="en-us"):
+                for word in sentence.words:
+                    if word.phonemes:
+                        phonemes.extend(word.phonemes)
+            return " ".join(phonemes)
+        except:
+            return ""
+
+    async def process_pronunciation(self, talent_id: int, content_id: int, audio_bytes: bytes, type: str):
+        # 1. Ambil Target
+        content = await self.material_repo.get_phoneme_content(content_id, type)
+        if not content:
+            raise NotFoundError(f"Material {type}")
+            
+        target_text = content.kata if type == "word" else content.kalimat
+        target_phonemes = content.fonem
+        
+        # Robustness: Jika DB kosong, generate on-the-fly
+        if not target_phonemes:
+            target_phonemes = self._generate_phonemes_fallback(target_text)
+        
+        # 2. Transkripsi Audio
+        try:
+            user_phonemes = await AudioService.transcribe(audio_bytes)
+        except Exception as e:
+            # Fallback jika Audio Service error
+            print(f"Audio Service Error: {e}")
+            user_phonemes = ""
+        
+        # 3. Scoring
+        alignment = PhonemeMatcher.align_phonemes(target_phonemes, user_phonemes)
+        accuracy = PhonemeMatcher.calculate_accuracy(alignment)
+        
+        # 4. AI Analysis (dengan Try-Except agar tidak memblokir flow utama)
+        try:
+            ai_analysis = await LLMService.analyze_phoneme_quality(
+                target_phonemes, user_phonemes, target_text
+            )
+        except Exception:
+            ai_analysis = {"error": "AI Analysis unavailable"}
+        
+        # 5. Result Object
+        result_full = {
+            "similarity_percent": f"{accuracy}%",
+            "accuracy_score": accuracy,
+            "target_phonemes": target_phonemes,
+            "user_phonemes": user_phonemes,
+            "phoneme_comparison": alignment,
+            "gemini_analysis": ai_analysis
+        }
+
+        # 6. Save DB
+        db_type = "Word" if type.lower() == "word" else "Sentence"
+        await self.score_repo.save_phoneme_result(
+            talent_id=talent_id,
+            soal_id=content_id,
+            type=db_type,
+            score=accuracy,
+            comparison=result_full
+        )
+        
+        return result_full
+
+    async def get_word_by_id(self, id: int):
+        word = await self.material_repo.get_word_by_id(id)
+        if not word: raise NotFoundError("Word")
+        return {
+            "idContent": word.idmaterifonemkata,
+            "content": word.kata,
+            "meaning": word.meaning,
+            "definition": word.definition,
+            "phoneme": word.fonem,
+            "phoneme_category": word.kategori
+        }
+
+    async def get_sentence_by_id(self, id: int):
+        sent = await self.material_repo.get_sentence_by_id(id)
+        if not sent: raise NotFoundError("Sentence")
+        return {
+            "idContent": sent.idmaterifonemkalimat,
+            "content": sent.kalimat,
+            "phoneme": sent.fonem,
+            "phoneme_category": sent.kategori
+        }
+
+    async def get_random_word(self, phoneme: str):
+        word = await self.material_repo.get_random_word_by_phoneme(phoneme)
+        if not word: return None
+        return {
+            "idContent": word.idmaterifonemkata,
+            "content": word.kata,
+            "phoneme": word.fonem,
+            "phoneme_category": word.kategori
+        }
+
+    async def get_random_sentence(self, phoneme: str):
+        sent = await self.material_repo.get_random_sentence_by_phoneme(phoneme)
+        if not sent: return None
+        return {
+            "idContent": sent.idmaterifonemkalimat,
+            "content": sent.kalimat,
+            "phoneme": sent.fonem,
+            "phoneme_category": sent.kategori
+        }

app/services/profile_service.py

@@ -0,0 +1,69 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.repositories.talent_repository import TalentRepository
+from app.repositories.dashboard_repository import DashboardRepository
+from app.core.exceptions import NotFoundError
+from app.utils.time_utils import TimeUtils
+from sqlalchemy import select, func
+from app.models.models import Materifonemkata, Materifonemkalimat
+
+class ProfileService:
+    def __init__(self, db: AsyncSession):
+        self.talent_repo = TalentRepository(db)
+        self.dash_repo = DashboardRepository(db)
+        self.db = db
+
+    async def get_mobile_profile(self, talent_id: int):
+        # 1. Validasi Talent
+        talent = await self.talent_repo.get_by_id(talent_id)
+        if not talent:
+            raise NotFoundError("Talent")
+            
+        # 2. Ambil Statistik Dasar (Exam)
+        progress_stats = await self.talent_repo.get_talent_progress_stats(talent_id)
+        
+        # 3. Ambil Statistik Pronunciation (Avg Score & Count)
+        avg_pronunciation = await self.dash_repo.get_user_avg_pronunciation(talent_id)
+        pron_completed_count = await self.dash_repo.get_user_phoneme_counts(talent_id)
+        
+        # Hitung total materi phoneme yang tersedia (untuk progress bar)
+        count_word = await self.db.scalar(select(func.count(Materifonemkata.idmaterifonemkata)))
+        count_sent = await self.db.scalar(select(func.count(Materifonemkalimat.idmaterifonemkalimat)))
+        total_phoneme_material = (count_word or 0) + (count_sent or 0)
+
+        # 4. Ambil Statistik Conversation (WPM & Count)
+        conv_stats = await self.dash_repo.get_user_conversation_stats(talent_id)
+        
+        # 5. Ambil Statistik Interview (WPM & Count)
+        int_stats = await self.dash_repo.get_user_interview_stats(talent_id)
+        
+        # 6. Hitung Streak (Logic Penuh)
+        activity_dates = await self.dash_repo.get_user_activity_dates(talent_id)
+        highest_streak, current_streak = TimeUtils.calculate_streaks(activity_dates)
+        
+        return {
+            "name": talent.nama,
+            "jobTitle": talent.role,
+            "email": talent.email,
+            "pretestScore": talent.pretest_score or 0,
+            
+            # Exam Stats
+            "highestExam": progress_stats['highest_exam'] or 0,
+            "lastTest": progress_stats['latest_exam'] or 0,
+            
+            # Average Scores
+            "averagePronunciation": round(avg_pronunciation, 2),
+            "averageWPMConversation": round(conv_stats["avg_wpm"], 2),
+            "averageWPMInterview": round(int_stats["avg_wpm"], 2),
+            
+            # Streaks
+            "highestStreak": highest_streak,
+            "currentStreak": current_streak,
+            
+            # Activity Counts
+            "activity": {
+                "phonemeCompleted": pron_completed_count,
+                "phonemeTotal": total_phoneme_material,
+                "conversationCompleted": conv_stats["count"],
+                "interviewCompleted": int_stats["count"]
+            }
+        }

app/services/talent_service.py

@@ -0,0 +1,165 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.repositories.talent_repository import TalentRepository
+from app.schemas.talent import TalentUpdate
+from app.schemas.auth import TalentCreate
+from app.core.exceptions import NotFoundError, AppError, DuplicateError
+from app.utils.time_utils import TimeUtils
+from passlib.context import CryptContext
+import pandas as pd
+import io
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+class TalentService:
+    def __init__(self, db: AsyncSession):
+        self.repo = TalentRepository(db)
+
+    async def get_talents_list(self, page: int, limit: int, search: str):
+        skip = (page - 1) * limit
+        talents, total = await self.repo.get_talents_paginated(skip, limit, search)
+        results = []
+        for t in talents:
+            stats = await self.repo.get_talent_progress_stats(t.idtalent)
+            latest = stats['latest_exam'] if stats['latest_exam'] is not None else 0
+            highest = stats['highest_exam'] if stats['highest_exam'] is not None else 0
+            results.append({
+                "id": t.idtalent, "talentName": t.nama, "email": t.email, "role": t.role,
+                "pretest": f"{t.pretest_score:.0f}%" if t.pretest_score is not None else "N/A",
+                "highestExam": f"{highest:.0f}%", "progress": f"{stats['progress']:.0f}%"
+            })
+        return {"data": results, "total": total, "page": page, "size": limit}
+
+    async def get_talent_detail(self, talent_id: int):
+        talent = await self.repo.get_by_id(talent_id)
+        if not talent: raise NotFoundError("Talent")
+        stats = await self.repo.get_talent_progress_stats(talent_id)
+        latest = stats['latest_exam'] if stats['latest_exam'] is not None else 0
+        highest = stats['highest_exam'] if stats['highest_exam'] is not None else 0
+        return {
+            "talentId": f"TLT{talent.idtalent:03d}", "nama": talent.nama, "role": talent.role, "email": talent.email,
+            "lastExam": f"{latest:.0f}%" if stats['latest_exam'] is not None else "N/A",
+            "highestExam": f"{highest:.0f}%" if stats['highest_exam'] is not None else "N/A",
+            "progress": f"{stats['progress']:.0f}%"
+        }
+        
+    async def create_talent(self, data: TalentCreate):
+        # 1. Cek Email Duplikat
+        existing = await self.repo.get_by_email(data.email)
+        if existing:
+            raise DuplicateError(f"Email {data.email} sudah terdaftar")
+        
+        # 2. Hash Password
+        hashed_pw = pwd_context.hash(data.password)
+        
+        # 3. Simpan ke DB
+        new_talent_data = {
+            "nama": data.nama,
+            "email": data.email,
+            "password": hashed_pw,
+            "role": data.role
+        }
+        return await self.repo.create(new_talent_data)
+
+    async def delete_talent(self, talent_id: int):
+        talent = await self.repo.get_by_id(talent_id)
+        if not talent: raise NotFoundError("Talent")
+        await self.repo.delete(talent)
+        return True
+
+    async def update_talent(self, talent_id: int, data: TalentUpdate):
+        talent = await self.repo.get_by_id(talent_id)
+        if not talent: raise NotFoundError("Talent")
+        update_data = data.model_dump(exclude_unset=True)
+        return await self.repo.update(talent, update_data)
+
+    async def change_password(self, talent_id: int, new_password: str):
+        talent = await self.repo.get_by_id(talent_id)
+        if not talent: raise NotFoundError("Talent")
+        hashed = pwd_context.hash(new_password)
+        await self.repo.update(talent, {"password": hashed})
+        return True
+
+    async def import_talents_from_excel(self, file_content: bytes):
+        try:
+            df = pd.read_excel(io.BytesIO(file_content))
+            required = ['nama', 'email', 'role', 'password']
+            df.columns = df.columns.str.lower().str.strip()
+            missing = [col for col in required if col not in df.columns]
+            if missing: raise AppError(status_code=400, detail=f"Missing columns: {', '.join(missing)}")
+            success, errors = 0, []
+            for idx, row in df.iterrows():
+                try:
+                    email = str(row['email']).strip()
+                    if await self.repo.get_by_email(email): raise ValueError(f"Email {email} already exists")
+                    data = {"nama": str(row['nama']).strip(), "email": email, "role": str(row['role']).strip(), "password": pwd_context.hash(str(row['password']).strip())}
+                    await self.repo.create(data)
+                    success += 1
+                except Exception as e:
+                    errors.append({"row": idx + 2, "error": str(e)})
+            return {"successCount": success, "errorCount": len(errors), "errors": errors}
+        except Exception as e:
+            raise AppError(status_code=400, detail=f"Import failed: {str(e)}")
+
+    async def get_phoneme_progress(self, talent_id: int, type_latihan: str, page: int, limit: int):
+        skip = (page - 1) * limit
+        items, total = await self.repo.get_phoneme_history_paginated(talent_id, type_latihan, skip, limit)
+        data = []
+        for item in items:
+            data.append({
+                "phonemeCategory": item["category"], "content": item["content"],
+                "score": f"{item['score']:.0f}%", "date": TimeUtils.format_to_wib(item["date"])
+            })
+        return {"data": data, "total": total, "page": page}
+
+    async def get_exam_progress(self, talent_id: int, page: int, limit: int):
+        skip = (page - 1) * limit
+        exams, total = await self.repo.get_exam_history_paginated(talent_id, skip, limit)
+        data = []
+        for ex in exams:
+            data.append({
+                "examId": ex.idujian, "phonemeCategory": ex.kategori,
+                "score": f"{ex.nilai or 0:.0f}%", "date": TimeUtils.format_to_wib(ex.waktuujian)
+            })
+        return {"data": data, "total": total, "page": page}
+
+    async def get_exam_attempt_detail(self, talent_id: int, attempt_id: int):
+        exam, details = await self.repo.get_exam_attempt_detail(talent_id, attempt_id)
+        if not exam: raise NotFoundError("Exam Attempt")
+        sentences_data = []
+        for row in details:
+            detail, kalimat = row
+            sentences_data.append({"sentence": kalimat.kalimat, "phonemeTranscription": kalimat.fonem, "score": f"{detail.nilai or 0:.0f}%"})
+        return {
+            "attemptId": f"ATT{exam.idujian:03d}", "phonemeCategory": exam.kategori,
+            "totalScore": f"{exam.nilai or 0:.0f}%", "date": TimeUtils.format_to_wib(exam.waktuujian),
+            "sentences": sentences_data
+        }
+
+    async def get_conversation_progress(self, talent_id: int, page: int, limit: int):
+        skip = (page - 1) * limit
+        items, total = await self.repo.get_conversation_history_paginated(talent_id, skip, limit)
+        data = []
+        for row in items:
+            res, topic = row
+            data.append({
+                "topic": topic or "General", "wpm": f"{res.wpm or 0:.0f}",
+                "grammarIssue": res.grammar or "No issues", "date": TimeUtils.format_to_wib(res.waktulatihan)
+            })
+        return {"data": data, "total": total, "page": page}
+
+    async def get_interview_progress(self, talent_id: int, page: int, limit: int):
+        skip = (page - 1) * limit
+        items, total = await self.repo.get_interview_history_paginated(talent_id, skip, limit)
+        data = []
+        for idx, item in enumerate(items):
+            attempt_no = total - skip - idx
+            data.append({
+                "attempt": attempt_no, "attemptId": item.idhasilinterview, "wordProducePerMinute": f"{item.wpm or 0:.0f}",
+                "feedback": item.feedback[:50] + "..." if item.feedback else "No feedback", "date": TimeUtils.format_to_wib(item.waktulatihan)
+            })
+        return {"data": data, "total": total, "page": page}
+
+    async def get_interview_detail(self, talent_id: int, attempt_id: int):
+        interview = await self.repo.get_interview_detail(talent_id, attempt_id)
+        if not interview: raise NotFoundError("Interview")
+        return {"attemptId": attempt_id, "date": TimeUtils.format_to_wib(interview.waktulatihan), "feedback": interview.feedback, "wpm": f"{interview.wpm:.0f}", "grammar": interview.grammar}

app/utils/calculation_utils.py

@@ -0,0 +1,25 @@
+class CalculationHelper:
+    @staticmethod
+    def calculate_wpm(text: str, duration: str) -> float:
+        """Kalkulasi Words Per Minute"""
+        try:
+            words = len(text.split())
+            duration = duration.strip()
+            
+            if ':' in duration:
+                time_parts = duration.split(':')
+                if len(time_parts) == 2:
+                    minutes, seconds = map(int, time_parts)
+                    total_seconds = minutes * 60 + seconds
+                else:
+                    return 0.0
+            else:
+                total_seconds = int(duration)
+            
+            if total_seconds <= 0:
+                return 0.0
+                
+            wpm = (words / total_seconds) * 60
+            return round(wpm, 2)
+        except Exception:
+            return 0.0

app/utils/phoneme_utils.py

@@ -0,0 +1,101 @@
+from difflib import SequenceMatcher
+from typing import List, Dict, Tuple
+from app.core.config import settings
+
+class PhonemeMatcher:
+    SIMILAR_PHONEMES = settings.SIMILAR_PHONEMES
+    ALL_PHONEMES = settings.VOWEL_PHONEMES + settings.DIPHTHONG_PHONEMES + settings.CONSONANT_PHONEMES
+    
+    @classmethod
+    def normalize_phonemes(cls, phoneme_str: str) -> List[str]:
+        if not phoneme_str:
+            return []
+            
+        normalized_str = phoneme_str
+        for key, value in settings.TIE_BAR_NORMALIZATION.items():
+            normalized_str = normalized_str.replace(key, value)
+            
+        return normalized_str.split()
+
+    @classmethod
+    def get_similar_phonemes(cls, phoneme: str) -> List[str]:
+        if phoneme not in cls.ALL_PHONEMES:
+            return []
+
+        direct_similars = set(cls.SIMILAR_PHONEMES.get(phoneme, []))
+        inverse_similars = set()
+        for key, values in cls.SIMILAR_PHONEMES.items():
+            if phoneme in values:
+                inverse_similars.add(key)
+                inverse_similars.update(cls.SIMILAR_PHONEMES.get(key, []))
+
+        all_similars = direct_similars.union(inverse_similars)
+        all_similars.discard(phoneme)
+        return sorted(list(all_similars))
+
+    @classmethod
+    def is_similar(cls, target: str, user: str) -> bool:
+        if target == user:
+            return True
+        similars = cls.get_similar_phonemes(target)
+        return user in similars
+
+    @classmethod
+    def get_status_score(cls, target: str, user: str) -> Tuple[str, int]:
+        if not target and not user: return "correct", 100
+        if not target and user: return "extra", 0
+        if target and not user: return "missing", 0
+        
+        if target == user: return "correct", 100
+        if cls.is_similar(target, user): return "similar", 75
+        
+        return "incorrect", 0
+
+    @classmethod
+    def align_phonemes(cls, target_str: str, user_str: str) -> List[Dict]:
+        target_list = cls.normalize_phonemes(target_str)
+        user_list = cls.normalize_phonemes(user_str)
+        
+        matcher = SequenceMatcher(None, target_list, user_list)
+        alignment = []
+
+        for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+            if tag == 'equal':
+                for k in range(i2 - i1):
+                    t = target_list[i1+k]
+                    u = user_list[j1+k]
+                    status, score = cls.get_status_score(t, u)
+                    alignment.append({"target": t, "user": u, "status": status, "similarity": score})
+            elif tag == 'replace':
+                len_target = i2 - i1
+                len_user = j2 - j1
+                max_len = max(len_target, len_user)
+                for k in range(max_len):
+                    t = target_list[i1+k] if k < len_target else ""
+                    u = user_list[j1+k] if k < len_user else ""
+                    status, score = cls.get_status_score(t, u)
+                    alignment.append({"target": t, "user": u, "status": status, "similarity": score})
+            elif tag == 'delete':
+                for k in range(i2 - i1):
+                    t = target_list[i1+k]
+                    status, score = cls.get_status_score(t, "")
+                    alignment.append({"target": t, "user": "", "status": status, "similarity": score})
+            elif tag == 'insert':
+                for k in range(j2 - j1):
+                    u = user_list[j1+k]
+                    status, score = cls.get_status_score("", u)
+                    alignment.append({"target": "", "user": u, "status": status, "similarity": score})
+        
+        return alignment
+
+    @staticmethod
+    def calculate_accuracy(alignment: List[Dict]) -> float:
+        if not alignment: return 0.0
+        total_score = 0
+        valid_items = 0
+        for item in alignment:
+            status = item.get("status")
+            if status == "correct": total_score += 100
+            elif status == "similar": total_score += 75
+            valid_items += 1
+        return round(total_score / valid_items, 1) if valid_items > 0 else 0.0

app/utils/template_generator.py

@@ -0,0 +1,87 @@
+import pandas as pd
+import io
+from typing import List
+from app.core.exceptions import AppError
+
+class TemplateGenerator:
+    
+    @staticmethod
+    def _create_excel_buffer(data: List[List[str]], columns: List[str], instructions: List[str]) -> io.BytesIO:
+        try:
+            buffer = io.BytesIO()
+            with pd.ExcelWriter(buffer, engine='xlsxwriter') as writer:
+                # Sheet 1: Template Data
+                df = pd.DataFrame(data, columns=columns)
+                df.to_excel(writer, sheet_name='Data Template', index=False)
+                
+                # Sheet 2: Instructions
+                df_inst = pd.DataFrame({'Instructions': instructions})
+                df_inst.to_excel(writer, sheet_name='Instructions', index=False)
+                
+                # Auto-adjust column width
+                worksheet = writer.sheets['Data Template']
+                for i, col in enumerate(columns):
+                    worksheet.set_column(i, i, 20)
+                    
+            buffer.seek(0)
+            return buffer
+        except Exception as e:
+            raise AppError(status_code=500, detail=f"Failed to generate template: {str(e)}")
+
+    @staticmethod
+    def get_phoneme_word_template() -> io.BytesIO:
+        columns = ["kategori", "kata", "fonem", "arti", "definisi"]
+        data = [
+            ['i', 'believe', 'bɪliv', 'percaya', 'Menerima kebenaran.'],
+            ['p', 'push', 'pʊʃ', 'mendorong', 'Memberi tekanan.']
+        ]
+        instructions = [
+            "1. Kategori: Fonem tunggal (contoh: i, p, b)",
+            "2. Fonem: Transkripsi IPA",
+            "3. Semua kolom wajib diisi"
+        ]
+        return TemplateGenerator._create_excel_buffer(data, columns, instructions)
+
+    @staticmethod
+    def get_phoneme_sentence_template() -> io.BytesIO:
+        columns = ["kategori", "kalimat", "fonem"]
+        data = [
+            ['i-ɪ', 'He did see if this big team is really in it.', 'hi dɪd si ɪf ðɪs bɪg tim ɪz rɪəli ɪn ɪt']
+        ]
+        instructions = [
+            "1. Kategori: Minimal pairs (contoh: i-ɪ, p-b)",
+            "2. Kalimat minimal 10 kata"
+        ]
+        return TemplateGenerator._create_excel_buffer(data, columns, instructions)
+
+    @staticmethod
+    def get_phoneme_exam_template() -> io.BytesIO:
+        # Generate dynamic columns for 10 sentences
+        columns = ["kategori"]
+        for i in range(1, 11):
+            columns.extend([f"kalimat_{i}", f"fonem_{i}"])
+            
+        data_row = ["i-ɪ"]
+        for _ in range(10):
+            data_row.extend(["Example Sentence", "fonem"])
+            
+        data = [data_row]
+        instructions = [
+            "1. Kategori: Minimal pairs (contoh: i-ɪ)",
+            "2. Wajib mengisi 10 kalimat dan 10 fonem lengkap",
+            "3. Satu baris = Satu paket ujian"
+        ]
+        return TemplateGenerator._create_excel_buffer(data, columns, instructions)
+
+    @staticmethod
+    def get_talent_template() -> io.BytesIO:
+        columns = ["nama", "email", "role", "password"]
+        data = [
+            ['John Doe', 'john@example.com', 'Software Engineer', 'Password123']
+        ]
+        instructions = [
+            "1. Email harus unik",
+            "2. Password minimal 6 karakter",
+            "3. Role opsional (default: talent)"
+        ]
+        return TemplateGenerator._create_excel_buffer(data, columns, instructions)