phase 2 validation

app.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from utils.logger import Logger
 from components.login_page import LoginPage
 from components.dashboard_page import DashboardPage
+from components.review_dashboard_page import ReviewDashboardPage
 from utils.database import initialize_database
 from config import conf
 
@@ -27,12 +28,14 @@ def build_app() -> gr.Blocks:
         gr.Markdown(f"### {conf.APP_TITLE}")
 
         # صفحات
-        login_page     = LoginPage()
-        dashboard_page = DashboardPage()
+        login_page = LoginPage()
+        dashboard_page = DashboardPage()  # Phase 1 interface
+        review_dashboard_page = ReviewDashboardPage()  # Phase 2 interface
 
         # اتصال رویدادها
-        login_page.register_callbacks(dashboard_page, session_state)
-        dashboard_page.register_callbacks(login_page, session_state, demo)
+        login_page.register_callbacks(dashboard_page, session_state, review_dashboard_page)
+        dashboard_page.register_callbacks(login_page, session_state, demo, review_dashboard_page)
+        review_dashboard_page.register_callbacks(login_page, session_state, demo)
 
     # صف پردازش گرادیو
     demo.queue(default_concurrency_limit=50)

components/dashboard_page.py

@@ -126,9 +126,9 @@ class DashboardPage:
 
     # ---------------- wiring ---------------- #
     def register_callbacks(
-        self, login_page, session_state: gr.State, root_blocks: gr.Blocks
+        self, login_page, session_state: gr.State, root_blocks: gr.Blocks, review_dashboard_page=None
     ):
-        self.header.register_callbacks(login_page, self, session_state)
+        self.header.register_callbacks(login_page, self, session_state, review_dashboard_page)
 
         def update_ui_interactive_state(is_interactive: bool):
             updates = []

components/header.py

@@ -12,21 +12,29 @@ class Header:
             self.logout_btn = gr.Button("Log out", scale=0, min_width=90)
 
     # ---------------- wiring ----------------
-    def register_callbacks(self, login_page, dashboard_page, session_state):
+    def register_callbacks(self, login_page, dashboard_page, session_state, review_dashboard_page=None):
         def logout_and_clear_progress_fn(current_session_state):
-            # AuthService.logout is expected to return 4 values for the original outputs
+            # AuthService.logout returns 5 values for both dashboards
             logout_outputs = AuthService.logout(current_session_state)
             # Add an empty string to clear the progress_display
             return list(logout_outputs) + [""]
 
+        outputs_for_logout = [
+            login_page.container,
+            dashboard_page.container,
+        ]
+        
+        if review_dashboard_page:
+            outputs_for_logout.append(review_dashboard_page.container)
+            
+        outputs_for_logout.extend([
+            self.welcome,
+            login_page.message,
+            self.progress_display,  # Cleared on logout
+        ])
+
         self.logout_btn.click(
             fn=logout_and_clear_progress_fn,
             inputs=[session_state],
-            outputs=[
-                login_page.container,
-                dashboard_page.container,
-                self.welcome,
-                login_page.message,
-                self.progress_display,  # Cleared on logout
-            ],
+            outputs=outputs_for_logout,
         )

components/login_page.py

@@ -25,10 +25,35 @@ class LoginPage:
             gr.Column(scale=1)  # right spacer
 
     # event wiring unchanged …
-    def register_callbacks(self, dashboard_page, session_state):
+    def register_callbacks(self, dashboard_page, session_state, review_dashboard_page=None):
         header = dashboard_page.header
         btn = self.login_btn
 
+        # Prepare outputs based on whether we have a review dashboard
+        login_outputs = [
+            self.message,
+            self.container,
+            dashboard_page.container, # Phase 1 dashboard
+        ]
+        if review_dashboard_page:
+            login_outputs.append(review_dashboard_page.container) # Phase 2 dashboard
+            login_outputs.append(review_dashboard_page.load_trigger) # Trigger for loading review data
+        else:
+            login_outputs.append(gr.update()) # Placeholder for review_dashboard_page.container
+            login_outputs.append(gr.update()) # Placeholder for review_dashboard_page.load_trigger
+        
+        login_outputs.extend([
+            header.welcome,
+            # These are for the main dashboard_page, 
+            # review_dashboard_page will load its own data via the trigger
+            dashboard_page.items_state, 
+            dashboard_page.idx_state,
+            dashboard_page.tts_id,
+            dashboard_page.filename,
+            dashboard_page.sentence,
+            dashboard_page.ann_sentence,
+        ])
+
         (
             btn.click(
                 fn=lambda: gr.update(value="🔒 Logging in…", interactive=False),
@@ -37,18 +62,7 @@ class LoginPage:
             .then(
                 fn=AuthService.login,
                 inputs=[self.username, self.password, session_state],
-                outputs=[
-                    self.message,
-                    self.container,
-                    dashboard_page.container,
-                    header.welcome,
-                    dashboard_page.items_state,
-                    dashboard_page.idx_state,
-                    dashboard_page.tts_id,
-                    dashboard_page.filename,
-                    dashboard_page.sentence,
-                    dashboard_page.ann_sentence,
-                ],
+                outputs=login_outputs,
             )
             .then(
                 fn=lambda: gr.update(value="Login", interactive=True),

components/review_dashboard_page.py

@@ -0,0 +1,418 @@
+# components/review_dashboard_page.py
+
+import gradio as gr
+import datetime
+from sqlalchemy import orm
+
+from components.header import Header
+from utils.logger import Logger
+from utils.cloud_server_audio_loader import CloudServerAudioLoader
+from config import conf
+from utils.database import get_db
+from data.models import Annotation, TTSData, Annotator, Validation
+from data.repository.annotator_workload_repo import AnnotatorWorkloadRepo
+
+log = Logger()
+LOADER = CloudServerAudioLoader(conf.FTP_URL)
+
+
+class ReviewDashboardPage:
+    def __init__(self) -> None:
+        with gr.Column(visible=False) as self.container:
+            self.header = Header()
+            self.load_trigger = gr.Number(value=0, visible=False) # Add this hidden trigger
+
+            # Review info banner
+            with gr.Row():
+                self.review_info = gr.Markdown("", elem_classes="review-banner")
+
+            with gr.Row():
+                # Left Column - Review Content
+                with gr.Column(scale=3):
+                    with gr.Row():
+                        self.tts_id = gr.Textbox(label="ID", interactive=False, scale=1)
+                        self.filename = gr.Textbox(label="Filename", interactive=False, scale=3)
+                    
+                    self.sentence = gr.Textbox(
+                        label="Original Sentence", interactive=False, max_lines=5, rtl=True
+                    )
+                    
+                    self.ann_sentence = gr.Textbox(
+                        label="Annotated Sentence (by Original Annotator)", 
+                        interactive=False, max_lines=5, rtl=True
+                    )
+                    
+                    with gr.Row():
+                        # self.annotator_name = gr.Textbox(label="Original Annotator", interactive=False, scale=1) # Removed for anonymization
+                        self.annotated_at = gr.Textbox(label="Annotated At", interactive=False, scale=2)
+                    
+                    # Review Actions
+                    with gr.Row():
+                        self.btn_approve = gr.Button("✅ Approve", variant="primary", min_width=120)
+                        self.btn_reject = gr.Button("❌ Reject", variant="stop", min_width=120)
+                        self.btn_skip = gr.Button("⏭️ Skip (No Decision)", min_width=150)
+
+                    # Navigation
+                    with gr.Row():
+                        self.btn_prev = gr.Button("⬅️ Previous", min_width=120)
+                        self.btn_next = gr.Button("Next ➡️", min_width=120)
+
+                    # Jump controls
+                    with gr.Row():
+                        self.jump_data_id_input = gr.Number(
+                            label="Jump to ID", 
+                            value=None, 
+                            precision=0,
+                            interactive=True,
+                            min_width=120
+                        )
+                        self.btn_jump = gr.Button("Go to ID", min_width=70)
+
+                # Right Column - Audio
+                with gr.Column(scale=2):
+                    self.btn_load_voice = gr.Button("Load Audio & Play", min_width=150)
+                    self.audio = gr.Audio(
+                        label="🔊 Audio", interactive=False, autoplay=True
+                    )
+                    
+                    # Review status display
+                    with gr.Group():
+                        gr.Markdown("### Review Status")
+                        self.current_validation_status = gr.Textbox(
+                            label="Current Status", interactive=False
+                        )
+
+            # State variables
+            self.items_state = gr.State([])
+            self.idx_state = gr.State(0)
+            self.original_audio_state = gr.State(None)
+
+            # List of interactive UI elements for enabling/disabling
+            self.interactive_ui_elements = [
+                self.btn_prev, self.btn_next, self.btn_approve, self.btn_reject, 
+                self.btn_skip, self.btn_jump, self.jump_data_id_input, self.btn_load_voice
+            ]
+
+    def register_callbacks(self, login_page, session_state: gr.State, root_blocks: gr.Blocks):
+        self.header.register_callbacks(login_page, self, session_state)
+
+        def update_ui_interactive_state(is_interactive: bool):
+            updates = []
+            for elem in self.interactive_ui_elements:
+                if elem == self.btn_load_voice and not is_interactive:
+                    updates.append(gr.update(value="⏳ Loading Audio...", interactive=False))
+                elif elem == self.btn_load_voice and is_interactive:
+                    updates.append(gr.update(value="Load Audio & Play", interactive=True))
+                else:
+                    updates.append(gr.update(interactive=is_interactive))
+            return updates
+
+        def download_voice_fn(filename_to_load):
+            if not filename_to_load:
+                return None, None, gr.update(value=None, autoplay=False)
+            try:
+                log.info(f"Downloading voice for review: {filename_to_load}")
+                sr, wav = LOADER.load_audio(filename_to_load)
+                return (sr, wav), (sr, wav.copy()), gr.update(value=(sr, wav), autoplay=True)
+            except Exception as e:
+                log.error(f"Audio download failed for {filename_to_load}: {e}")
+                gr.Error(f"Failed to load audio: {filename_to_load}. Error: {e}")
+                return None, None, gr.update(value=None, autoplay=False)
+
+        def load_review_items_fn(session):
+            user_id = session.get("user_id")
+            username = session.get("username")
+            
+            if not user_id or not username:
+                log.warning("load_review_items_fn: user not found in session")
+                return [], 0, "", "", "", "", "", "", "", gr.update(value=None, autoplay=False) # Adjusted output count
+
+            # Check if user is in Phase 2 (should be a reviewer)
+            if username not in conf.REVIEW_MAPPING.values():
+                log.warning(f"User {username} is not assigned as a reviewer")
+                return [], 0, "", "", "", "", "", "", "", gr.update(value=None, autoplay=False) # Adjusted output count
+
+            # Find which annotator this user should review
+            target_annotator = None
+            for annotator_name, reviewer_name in conf.REVIEW_MAPPING.items():
+                if reviewer_name == username:
+                    target_annotator = annotator_name
+                    break
+
+            if not target_annotator:
+                log.warning(f"No target annotator found for reviewer {username}")
+                return [], 0, "", "", "", "", "", "", "", gr.update(value=None, autoplay=False) # Adjusted output count
+
+            # Load annotations from target annotator
+            with get_db() as db:
+                try:
+                    # Get target annotator's ID
+                    target_annotator_obj = db.query(Annotator).filter_by(name=target_annotator).first()
+                    if not target_annotator_obj:
+                        log.error(f"Target annotator {target_annotator} not found in database")
+                        return [], 0, f"Review Target Error: Annotator '{target_annotator}' not found.", "", "", "", "", "", "", gr.update(value=None, autoplay=False) # Adjusted output count
+                    
+                    log.info(f"Found target annotator '{target_annotator}' with ID: {target_annotator_obj.id}")
+
+                    # Get all annotations by target annotator
+                    annotations = db.query(Annotation).join(TTSData).filter(
+                        Annotation.annotator_id == target_annotator_obj.id,
+                        Annotation.annotated_sentence.isnot(None),
+                        Annotation.annotated_sentence != ""
+                    ).options(
+                        orm.joinedload(Annotation.tts_data),
+                        orm.joinedload(Annotation.annotator)
+                    ).all()
+
+                    log.info(f"Fetched {len(annotations)} annotations for target annotator ID {target_annotator_obj.id} ({target_annotator})")
+
+                    items = []
+                    for annotation in annotations:
+                        # Check if this annotation has been reviewed by current user
+                        existing_validation = db.query(Validation).filter_by(
+                            annotation_id=annotation.id,
+                            validator_id=user_id
+                        ).first()
+
+                        validation_status = "Not Reviewed"
+                        if existing_validation:
+                            validation_status = "Approved" if existing_validation.validated else "Rejected"
+
+                        items.append({
+                            "annotation_id": annotation.id,
+                            "tts_id": annotation.tts_data.id,
+                            "filename": annotation.tts_data.filename,
+                            "sentence": annotation.tts_data.sentence,
+                            "annotated_sentence": annotation.annotated_sentence,
+                            # "annotator_name": annotation.annotator.name, # Removed for anonymization
+                            "annotated_at": annotation.annotated_at.isoformat() if annotation.annotated_at else "",
+                            "validation_status": validation_status
+                        })
+
+                    log.info(f"Loaded {len(items)} review items for {username} reviewing {target_annotator}")
+
+                    # Set initial display
+                    if items:
+                        initial_item = items[0]
+                        review_info_text = f"🔍 **Phase 2 Review Mode** - Reviewing assigned annotations." # Anonymized
+                        return (
+                            items, 0, review_info_text,
+                            str(initial_item["tts_id"]), initial_item["filename"], 
+                            initial_item["sentence"], initial_item["annotated_sentence"],
+                            # initial_item["annotator_name"], # Removed for anonymization
+                            initial_item["annotated_at"],
+                            initial_item["validation_status"],
+                            gr.update(value=None, autoplay=False)
+                        )
+                    else:
+                        return [], 0, f"🔍 **Phase 2 Review Mode** - No annotations found for review.", "", "", "", "", "", "", gr.update(value=None, autoplay=False) # Adjusted output count
+
+                except Exception as e:
+                    log.error(f"Error loading review items: {e}")
+                    gr.Error(f"Failed to load review data: {e}")
+                    return [], 0, "", "", "", "", "", "", "", gr.update(value=None, autoplay=False) # Adjusted output count
+
+        def show_current_review_item_fn(items, idx, session):
+            if not items or idx >= len(items) or idx < 0:
+                return "", "", "", "", "", "", gr.update(value=None, autoplay=False) # Adjusted output count
+            
+            current_item = items[idx]
+            return (
+                str(current_item["tts_id"]), current_item["filename"],
+                current_item["sentence"], current_item["annotated_sentence"],
+                # current_item["annotator_name"], # Removed for anonymization
+                current_item["annotated_at"],
+                current_item["validation_status"],
+                gr.update(value=None, autoplay=False)
+            )
+
+        def navigate_review_fn(items, current_idx, direction):
+            if not items:
+                return 0
+            if direction == "next":
+                return min(current_idx + 1, len(items) - 1)
+            else:  # prev
+                return max(current_idx - 1, 0)
+
+        def save_validation_fn(items, idx, session, approved: bool, rejection_reason: str = ""):
+            if not items or idx >= len(items):
+                gr.Error("Invalid item index")
+                return items, "Error: Invalid item index"
+
+            user_id = session.get("user_id")
+            if not user_id:
+                gr.Error("User not logged in")
+                return items, "Error: User not logged in"
+
+            current_item = items[idx]
+            annotation_id = current_item["annotation_id"]
+            log.info(f"Saving validation for annotation_id: {annotation_id}, validator_id: {user_id}, approved: {approved}, reason: {rejection_reason}")
+
+            with get_db() as db:
+                try:
+                    existing_validation = db.query(Validation).filter_by(
+                        annotation_id=annotation_id,
+                        validator_id=user_id
+                    ).first()
+
+                    if existing_validation:
+                        log.info(f"Updating existing validation for annotation_id: {annotation_id}")
+                        existing_validation.validated = approved
+                        existing_validation.description = rejection_reason if not approved else None
+                        existing_validation.validated_at = datetime.datetime.utcnow()
+                    else:
+                        log.info(f"Creating new validation for annotation_id: {annotation_id}")
+                        new_validation = Validation(
+                            annotation_id=annotation_id,
+                            validator_id=user_id,
+                            validated=approved,
+                            description=rejection_reason if not approved else None,
+                            validated_at=datetime.datetime.utcnow(),
+                        )
+                        db.add(new_validation)
+                    
+                    db.commit()
+                    log.info(f"Validation saved successfully for annotation_id: {annotation_id}")
+                    
+                    # Update the item in memory for immediate UI feedback
+                    items[idx]["validation_status"] = "Approved" if approved else f"Rejected ({rejection_reason})" if rejection_reason else "Rejected"
+                    return items, items[idx]["validation_status"]
+
+                except Exception as e:
+                    db.rollback()
+                    log.error(f"Error saving validation: {e}")
+                    gr.Error(f"Failed to save validation: {e}")
+                    return items, current_item["validation_status"] # Return original status on error
+
+        def jump_by_data_id_fn(items, target_data_id, current_idx):
+            if not target_data_id:
+                return current_idx
+            try:
+                target_id = int(target_data_id)
+                for i, item in enumerate(items):
+                    if item["tts_id"] == target_id:
+                        return i
+                gr.Warning(f"Data ID {target_id} not found in review items")
+            except ValueError:
+                gr.Warning(f"Invalid Data ID format: {target_data_id}")
+            return current_idx
+
+        # Output definitions
+        review_display_outputs = [
+            self.tts_id, self.filename, self.sentence, self.ann_sentence,
+            # self.annotator_name, # Removed for anonymization
+            self.annotated_at, self.current_validation_status, self.audio
+        ]
+
+        # Trigger data loading when load_trigger changes (after successful login for a reviewer)
+        self.load_trigger.change(
+            fn=lambda: update_ui_interactive_state(False),
+            outputs=self.interactive_ui_elements
+        ).then(
+            fn=load_review_items_fn,
+            inputs=[session_state],
+            outputs=[self.items_state, self.idx_state, self.review_info] + review_display_outputs
+        ).then(
+            fn=lambda: (None, gr.update(value=None)), # Clear audio state
+            outputs=[self.original_audio_state, self.audio]
+        ).then(
+            fn=lambda: update_ui_interactive_state(True),
+            outputs=self.interactive_ui_elements
+        )
+
+        # Load audio when filename changes
+        self.filename.change(
+            fn=download_voice_fn,
+            inputs=[self.filename],
+            outputs=[self.audio, self.original_audio_state, self.audio]
+        )
+
+        # Navigation buttons
+        for btn, direction in [(self.btn_prev, "prev"), (self.btn_next, "next")]:
+            btn.click(
+                fn=lambda: update_ui_interactive_state(False),
+                outputs=self.interactive_ui_elements
+            ).then(
+                fn=navigate_review_fn,
+                inputs=[self.items_state, self.idx_state, gr.State(direction)],
+                outputs=self.idx_state
+            ).then(
+                fn=show_current_review_item_fn,
+                inputs=[self.items_state, self.idx_state, session_state],
+                outputs=review_display_outputs
+            ).then(
+                lambda: gr.update(value=None),
+                outputs=self.jump_data_id_input
+            ).then(
+                fn=lambda: update_ui_interactive_state(True),
+                outputs=self.interactive_ui_elements
+            )
+
+        # Approve/Reject buttons
+        self.btn_approve.click(
+            fn=lambda items, idx, session: save_validation_fn(items, idx, session, approved=True),
+            inputs=[self.items_state, self.idx_state, session_state],
+            outputs=[self.items_state, self.current_validation_status] # Update items_state and current_validation_status
+        ).then(
+            fn=lambda items, idx: navigate_review_fn(items, idx, "next"),
+            inputs=[self.items_state, self.idx_state],
+            outputs=[self.idx_state]
+        ).then(
+            fn=show_current_review_item_fn,
+            inputs=[self.items_state, self.idx_state, session_state],
+            outputs=review_display_outputs
+        )
+
+        self.btn_reject.click(
+            fn=lambda items, idx, session: save_validation_fn(items, idx, session, approved=False, rejection_reason="Rejected by reviewer"), # Basic reason for now
+            inputs=[self.items_state, self.idx_state, session_state],
+            outputs=[self.items_state, self.current_validation_status]
+        ).then(
+            fn=lambda items, idx: navigate_review_fn(items, idx, "next"),
+            inputs=[self.items_state, self.idx_state],
+            outputs=[self.idx_state]
+        ).then(
+            fn=show_current_review_item_fn,
+            inputs=[self.items_state, self.idx_state, session_state],
+            outputs=review_display_outputs
+        )
+
+        # Skip button (just navigate to next)
+        self.btn_skip.click(
+            fn=navigate_review_fn,
+            inputs=[self.items_state, self.idx_state, gr.State("next")],
+            outputs=self.idx_state
+        ).then(
+            fn=show_current_review_item_fn,
+            inputs=[self.items_state, self.idx_state, session_state],
+            outputs=review_display_outputs
+        )
+
+        # Jump button
+        self.btn_jump.click(
+            fn=jump_by_data_id_fn,
+            inputs=[self.items_state, self.jump_data_id_input, self.idx_state],
+            outputs=self.idx_state
+        ).then(
+            fn=show_current_review_item_fn,
+            inputs=[self.items_state, self.idx_state, session_state],
+            outputs=review_display_outputs
+        ).then(
+            lambda: gr.update(value=None),
+            outputs=self.jump_data_id_input
+        )
+
+        # Load audio button
+        self.btn_load_voice.click(
+            fn=lambda: update_ui_interactive_state(False),
+            outputs=self.interactive_ui_elements
+        ).then(
+            fn=download_voice_fn,
+            inputs=[self.filename],
+            outputs=[self.audio, self.original_audio_state, self.audio]
+        ).then(
+            fn=lambda: update_ui_interactive_state(True),
+            outputs=self.interactive_ui_elements
+        )
+
+        return self.container

config.py

@@ -16,6 +16,13 @@ class Config(BaseSettings):
 
     APP_TITLE: str = "Gooya TTS Annotation Tools"
 
+    # Phase 2 Review Mapping: Defines who reviews whose work.
+    # Key: Original annotator's username, Value: Reviewer's username
+    REVIEW_MAPPING: dict[str, str] = {
+        "zahra": "amin",
+        "amin": "zahra"
+    }
+
     class Config:
         env_file = ".env"
         case_sensitive = True

data/models.py

@@ -152,10 +152,10 @@ class Validation(Base):
 
     id = Column(Integer, primary_key=True)
     annotation_id = Column(Integer, ForeignKey("annotations.id"))
-    validator_id = Column(Integer, ForeignKey("validators.id"))
+    validator_id = Column(Integer, ForeignKey("annotators.id"))  # Fixed: should reference annotators.id
     validated = Column(Boolean, nullable=False)
     description = Column(Text, nullable=True)
     validated_at = Column(DateTime, nullable=False)
 
     annotation = relationship("Annotation")
-    validator = relationship("Validator")
+    validator = relationship("Annotator", foreign_keys=[validator_id])  # Fixed: should reference Annotator

utils/auth.py

@@ -4,6 +4,8 @@ from utils.database import get_db
 from data.repository.annotator_repo import AnnotatorRepo
 from data.repository.annotator_workload_repo import AnnotatorWorkloadRepo
 from utils.security import verify_password
+from config import conf
+import time # Add this import
 
 log = Logger()
 
@@ -17,14 +19,13 @@ class AuthService:
     @staticmethod
     def login(username: str, password: str, session: dict):
         """
-        خروجی‌ها (به همین ترتیب در LoginPage ثبت شده است):
-        0) message              (Markdown داخل فرم لاگین)
-        1) login_container      (پنهان/نمایان شدن فرم لاگین)
-        2) dashboard_container  (نمایش داشبورد)
-        3) header_welcome       (پیام خوش‌آمد در هدر)
-        4) items_state          (لیست رکوردها)
-        5) idx_state            (اندیس فعلی)
-        6-11) شش فیلد نمایشی    (id, filename, sentence, ann_sentence, ann_at, validated)
+        Returns different UI states based on user role:
+        - Phase 1 users: Normal annotation interface
+        - Phase 2 users: Review interface
+        
+        Outputs depend on which interface is being used:
+        For Phase 1: (message, login_container, dashboard_container, header_welcome, items_state, idx_state, tts_id, filename, sentence, ann_sentence)
+        For Phase 2: (message, login_container, dashboard_container, review_dashboard_container, header_welcome, items_state, idx_state, tts_id, filename, sentence, ann_sentence)
         """
 
         # ---------- اعتبارسنجی ---------- #
@@ -51,9 +52,11 @@ class AuthService:
                 return (
                     "❌ Wrong username or password!",  # message
                     gr.update(),  # login_container (no change)
-                    gr.update(visible=False),  # dashboard_container
+                    gr.update(visible=False),  # dashboard_container (Phase 1)
+                    gr.update(visible=False),  # review_dashboard_container (Phase 2)
+                    gr.update(), # review_dashboard_page.load_trigger
                     gr.update(value=""),  # header_welcome
-                    *empty_dashboard_outputs_for_ui(),  # items_state, idx_state, and 4 UI textboxes
+                    *empty_dashboard_outputs_for_ui(),
                 )
 
             # --- رمز عبور اشتباه
@@ -62,88 +65,115 @@ class AuthService:
                 return (
                     "❌ Wrong username or password!",  # message
                     gr.update(),  # login_container (no change)
-                    gr.update(visible=False),  # dashboard_container
+                    gr.update(visible=False),  # dashboard_container (Phase 1)
+                    gr.update(visible=False),  # review_dashboard_container (Phase 2)
+                    gr.update(), # review_dashboard_page.load_trigger
                     gr.update(value=""),  # header_welcome
-                    *empty_dashboard_outputs_for_ui(),  # items_state, idx_state, and 4 UI textboxes
+                    *empty_dashboard_outputs_for_ui(),
                 )
 
             # ---------- ورود موفق ---------- #
             session["user_id"] = annotator.id
             session["username"] = annotator.name
+            session["is_reviewer"] = annotator.name in conf.REVIEW_MAPPING.values()
 
-            # بارگذاری داده‌های داشبورد
-            workload_repo = AnnotatorWorkloadRepo(db)
-            raw_items = workload_repo.get_tts_data_with_annotations(username)
-
-            dashboard_items = [
-                {
-                    "id": row["tts_data"].id,
-                    "filename": row["tts_data"].filename,
-                    "sentence": row["tts_data"].sentence,
-                    "annotated_sentence": (
-                        row["annotation"].annotated_sentence
-                        if row["annotation"] and row["annotation"].annotated_sentence is not None
-                        else ""
-                    ),
-                    "annotated_at": (
-                        row["annotation"].annotated_at.isoformat()
-                        if row["annotation"] and row["annotation"].annotated_at
-                        else ""
-                    ),
-                    "validated": (
-                        row["annotation"].validated
-                        if row["annotation"] is not None
-                        else False
-                    ),
-                }
-                for row in raw_items
-            ]
-
-            session["dashboard_items"] = dashboard_items
-
-            # --- Resume Logic: Find first unannotated or default to first/last item ---
-            initial_idx = 0
-            if dashboard_items:
-                first_unannotated_idx = -1
-                for i, item_data in enumerate(dashboard_items):
-                    if not item_data["annotated_sentence"]:  # Check if annotated_sentence is empty
-                        first_unannotated_idx = i
-                        break
-                
-                if first_unannotated_idx != -1:
-                    initial_idx = first_unannotated_idx
-                    log.info(f"User '{username}' resuming at first unannotated item, index: {initial_idx} (ID: {dashboard_items[initial_idx]['id']})")
-                else:  # All items are annotated or list is empty
-                    initial_idx = len(dashboard_items) - 1 if dashboard_items else 0 # Go to the last item if all annotated, else 0
-                    if dashboard_items:
-                        log.info(f"User '{username}' has all items annotated or list is empty, starting at item index: {initial_idx} (ID: {dashboard_items[initial_idx]['id']})")
-            else: # No items assigned
-                log.info(f"User '{username}' has no items assigned, starting at index 0.")
-
-            # مقداردهی فیلدهای رکورد بر اساس initial_idx
-            if dashboard_items: # Check if list is not empty and initial_idx is valid
-                current_item_for_ui = dashboard_items[initial_idx]
-                first_vals_for_ui = (
-                    current_item_for_ui["id"],
-                    current_item_for_ui["filename"],
-                    current_item_for_ui["sentence"],
-                    current_item_for_ui["annotated_sentence"],
+
+            if session["is_reviewer"]:
+                log.info(f"User '{username}' is a Phase 2 reviewer")
+                return (
+                    None,  # 0: message
+                    gr.update(visible=False),  # 1: login_container
+                    gr.update(visible=False),  # 2: dashboard_container (Phase 1)
+                    gr.update(visible=True),   # 3: review_dashboard_container (Phase 2)
+                    gr.update(value=time.time()), # 4: review_dashboard_page.load_trigger
+                    gr.update(value=f"👋 Welcome, {annotator.name}! (Phase 2 Review Mode)"),  # 5: header_welcome
+                    # Dummy updates for dashboard_page components
+                    gr.update(value=[]),  # 6: dashboard_page.items_state
+                    gr.update(value=0),   # 7: dashboard_page.idx_state
+                    gr.update(value=""),  # 8: dashboard_page.tts_id
+                    gr.update(value=""),  # 9: dashboard_page.filename
+                    gr.update(value=""),  # 10: dashboard_page.sentence
+                    gr.update(value=""),  # 11: dashboard_page.ann_sentence
                 )
             else:
-                first_vals_for_ui = ("", "", "", "") # id, filename, sentence, ann_sentence
-
-            log.info(f"User '{username}' logged in successfully. Initial index set to: {initial_idx}")
-
-            # ---------- خروجی نهایی برای Gradio ---------- #
-            return (
-                None,  # 0: پیام خطا وجود ندارد
-                gr.update(visible=False),  # 1: فرم لاگین را مخفی کن
-                gr.update(visible=True),  # 2: داشبورد را نشان بده
-                gr.update(value=f"👋 Welcome, {annotator.name}!"),  # 3
-                dashboard_items,  # 4: items_state
-                initial_idx,  # 5: idx_state (Updated to determined initial_idx)
-                *first_vals_for_ui,  # 6-9: چهار فیلد نخست برای UI (from item at initial_idx)
-            )
+                # Phase 1 users - existing logic
+                log.info(f"User '{username}' is a Phase 1 annotator")
+
+                # بارگذاری داده‌های داشبورد
+                workload_repo = AnnotatorWorkloadRepo(db)
+                raw_items = workload_repo.get_tts_data_with_annotations(username)
+
+                dashboard_items = [
+                    {
+                        "id": row["tts_data"].id,
+                        "filename": row["tts_data"].filename,
+                        "sentence": row["tts_data"].sentence,
+                        "annotated_sentence": (
+                            row["annotation"].annotated_sentence
+                            if row["annotation"] and row["annotation"].annotated_sentence is not None
+                            else ""
+                        ),
+                        "annotated_at": (
+                            row["annotation"].annotated_at.isoformat()
+                            if row["annotation"] and row["annotation"].annotated_at
+                            else ""
+                        ),
+                        "validated": (
+                            row["annotation"].validated
+                            if row["annotation"] is not None
+                            else False
+                        ),
+                    }
+                    for row in raw_items
+                ]
+
+                session["dashboard_items"] = dashboard_items
+
+                # --- Resume Logic: Find first unannotated or default to first/last item ---
+                initial_idx = 0
+                if dashboard_items:
+                    first_unannotated_idx = -1
+                    for i, item_data in enumerate(dashboard_items):
+                        if not item_data["annotated_sentence"]:  # Check if annotated_sentence is empty
+                            first_unannotated_idx = i
+                            break
+                    
+                    if first_unannotated_idx != -1:
+                        initial_idx = first_unannotated_idx
+                        log.info(f"User '{username}' resuming at first unannotated item, index: {initial_idx} (ID: {dashboard_items[initial_idx]['id']})")
+                    else:  # All items are annotated or list is empty
+                        initial_idx = len(dashboard_items) - 1 if dashboard_items else 0 # Go to the last item if all annotated, else 0
+                        if dashboard_items:
+                            log.info(f"User '{username}' has all items annotated or list is empty, starting at item index: {initial_idx} (ID: {dashboard_items[initial_idx]['id']})")
+                else: # No items assigned
+                    log.info(f"User '{username}' has no items assigned, starting at index 0.")
+
+                # مقداردهی فیلدهای رکورد بر اساس initial_idx
+                if dashboard_items: # Check if list is not empty and initial_idx is valid
+                    current_item_for_ui = dashboard_items[initial_idx]
+                    first_vals_for_ui = (
+                        current_item_for_ui["id"],
+                        current_item_for_ui["filename"],
+                        current_item_for_ui["sentence"],
+                        current_item_for_ui["annotated_sentence"],
+                    )
+                else:
+                    first_vals_for_ui = ("", "", "", "") # id, filename, sentence, ann_sentence
+
+                log.info(f"User '{username}' logged in successfully. Initial index set to: {initial_idx}")
+
+                # ---------- خروجی نهایی برای Gradio ---------- #
+                return (
+                    None,  # 0: پیام خطا وجود ندارد
+                    gr.update(visible=False),  # 1: فرم لاگین را مخفی کن
+                    gr.update(visible=True),  # 2: داشبورد را نشان بده (Phase 1)
+                    gr.update(visible=False), # 3: review dashboard را مخفی کن (Phase 2)
+                    gr.update(), # 4: review_dashboard_page.load_trigger (no change)
+                    gr.update(value=f"👋 Welcome, {annotator.name}!"),  # 5
+                    dashboard_items,  # 6: items_state
+                    initial_idx,  # 7: idx_state
+                    *first_vals_for_ui,  # 8-11: چهار فیلد نخست برای UI
+                )
 
     # ───────────── LOGOUT ───────────── #
     @staticmethod
@@ -153,7 +183,8 @@ class AuthService:
         log.info(f"User '{username}' logged out.")
         return (
             gr.update(visible=True),   # 1  → login_page.container
-            gr.update(visible=False),  # 2  → dashboard_page.container
-            gr.update(value=""),       # 3  → self.welcome
-            gr.update(value=""),       # 4  → login_page.message
+            gr.update(visible=False),  # 2  → dashboard_page.container (Phase 1)
+            gr.update(visible=False),  # 3  → review_dashboard_page.container (Phase 2)
+            gr.update(value=""),       # 4  → self.welcome
+            gr.update(value=""),       # 5  → login_page.message
         )