fix: disable redirect_slashes to prevent mixed content errors behind HF proxy

app/database.py

@@ -339,6 +339,95 @@ class AsyncCollection:
             _json_dumps(payload),
         )
 
+    @staticmethod
+    def _build_sql_conditions(
+        query: dict[str, Any] | None,
+    ) -> tuple[list[str], list[Any], bool]:
+        """Try to convert MongoDB-style query to SQL WHERE clauses.
+
+        Returns (conditions, params, needs_python_filter).
+        If needs_python_filter is True, the SQL result must still be
+        filtered in Python with _matches_query for correctness.
+        """
+        if not query:
+            return [], [], False
+
+        conditions: list[str] = []
+        params: list[Any] = []
+        needs_python = False
+        idx = 1  # $1, $2, ... param counter
+
+        for key, expected in query.items():
+            if key in ("$or", "$and"):
+                needs_python = True
+                continue
+
+            if key == "_id":
+                if isinstance(expected, (str, ObjectId)):
+                    conditions.append(f"_id = ${idx}")
+                    params.append(str(_normalize_scalar(expected)))
+                    idx += 1
+                else:
+                    needs_python = True
+                continue
+
+            if not _is_operator_dict(expected):
+                # Simple equality: data->>'field' = $N
+                # Booleans need special handling: Python str(True)='True', JSONB text='true'
+                if expected is True:
+                    conditions.append(f"data->>'{key}' = 'true'")
+                elif expected is False:
+                    conditions.append(f"data->>'{key}' = 'false'")
+                elif expected is None:
+                    conditions.append(f"data->>'{key}' IS NULL")
+                else:
+                    conditions.append(f"data->>'{key}' = ${idx}")
+                    params.append(str(_normalize_scalar(expected)))
+                    idx += 1
+                continue
+
+            # Operator dict
+            for op, op_value in expected.items():
+                if op == "$ne":
+                    if op_value is True:
+                        conditions.append(
+                            f"(data->>'{key}' IS NULL OR data->>'{key}' != 'true')"
+                        )
+                    elif op_value is False:
+                        conditions.append(
+                            f"(data->>'{key}' IS NULL OR data->>'{key}' != 'false')"
+                        )
+                    else:
+                        conditions.append(
+                            f"(data->>'{key}' IS NULL OR data->>'{key}' != ${idx})"
+                        )
+                        params.append(str(_normalize_scalar(op_value)))
+                        idx += 1
+                elif op == "$in":
+                    if isinstance(op_value, list) and op_value:
+                        placeholders = ", ".join(
+                            f"${idx + i}" for i in range(len(op_value))
+                        )
+                        conditions.append(
+                            f"data->>'{key}' IN ({placeholders})"
+                        )
+                        for v in op_value:
+                            params.append(str(_normalize_scalar(v)))
+                            idx += 1
+                    else:
+                        needs_python = True
+                elif op in ("$gt", "$gte", "$lt", "$lte"):
+                    sql_op = {"$gt": ">", "$gte": ">=", "$lt": "<", "$lte": "<="}[op]
+                    conditions.append(f"data->>'{key}' {sql_op} ${idx}")
+                    params.append(str(_normalize_scalar(op_value)))
+                    idx += 1
+                elif op in ("$regex", "$options"):
+                    needs_python = True
+                else:
+                    needs_python = True
+
+        return conditions, params, needs_python
+
     async def _find_docs(
         self,
         query: dict[str, Any] | None,
@@ -347,18 +436,57 @@ class AsyncCollection:
         skip: int = 0,
         limit: int | None = None,
     ) -> list[dict[str, Any]]:
-        documents = await self._fetch_all_documents()
-        matched = [doc for doc in documents if _matches_query(doc, query or {})]
-
-        for field, direction in reversed(list(sort_fields or [])):
-            matched.sort(key=lambda item: _sort_key(item.get(field)), reverse=int(direction) == -1)
+        conditions, params, needs_python = self._build_sql_conditions(query)
+
+        sql = f'SELECT _id, data FROM "{self._name}"'
+        if conditions:
+            sql += " WHERE " + " AND ".join(conditions)
+
+        # Push sort to SQL when possible (single sort field)
+        sort_list = list(sort_fields or [])
+        sql_sorted = False
+        if sort_list and not needs_python:
+            order_clauses = []
+            for field, direction in sort_list:
+                dir_str = "DESC" if int(direction) == -1 else "ASC"
+                order_clauses.append(f"data->>'{field}' {dir_str}")
+            sql += " ORDER BY " + ", ".join(order_clauses)
+            sql_sorted = True
+
+        # Push limit/skip to SQL when no Python filtering needed
+        if not needs_python and sql_sorted:
+            if skip:
+                sql += f" OFFSET {max(0, int(skip))}"
+            if limit is not None:
+                sql += f" LIMIT {max(0, int(limit))}"
+
+        rows = await self._database.pool.fetch(sql, *params)
+        documents: list[dict[str, Any]] = []
+        for row in rows:
+            data = _json_loads(row["data"]) or {}
+            data["_id"] = row["_id"]
+            documents.append(data)
+
+        # If we needed Python filtering, apply it now on the narrowed set
+        if needs_python:
+            documents = [doc for doc in documents if _matches_query(doc, query or {})]
+
+        # If sorting wasn't done in SQL, do it in Python
+        if not sql_sorted and sort_list:
+            for field, direction in reversed(sort_list):
+                documents.sort(
+                    key=lambda item: _sort_key(item.get(field)),
+                    reverse=int(direction) == -1,
+                )
 
-        if skip:
-            matched = matched[max(0, int(skip)) :]
-        if limit is not None:
-            matched = matched[: max(0, int(limit))]
+        # If skip/limit weren't pushed to SQL, apply in Python
+        if needs_python or not sql_sorted:
+            if skip:
+                documents = documents[max(0, int(skip)):]
+            if limit is not None:
+                documents = documents[:max(0, int(limit))]
 
-        return [_apply_projection(doc, projection) for doc in matched]
+        return [_apply_projection(doc, projection) for doc in documents]
 
     def find(self, query: dict[str, Any] | None = None, projection: dict[str, Any] | None = None) -> AsyncCursor:
         return AsyncCursor(self, query, projection)

app/main.py

@@ -16,6 +16,7 @@ app = FastAPI(
     title=settings.APP_NAME,
     description="Legal Document OCR + Translation + Expert Verification Platform",
     version="1.0.0",
+    redirect_slashes=False,
 )
 
 

app/routers/document_router.py

@@ -142,9 +142,13 @@ async def _assign_review_team(document_id: str, document_name: str) -> None:
     ).to_list(length=5000)
 
     selected_linguist = random.choice(linguists) if linguists else None
-    selected_translator = random.choice(translators) if translators else None
-
     linguist_id = str(selected_linguist["_id"]) if selected_linguist else None
+
+    # Ensure translator is a different person than the linguist
+    available_translators = [t for t in translators if str(t["_id"]) != linguist_id] if linguist_id else translators
+    if not available_translators and translators:
+        available_translators = translators  # fallback if no other translator exists
+    selected_translator = random.choice(available_translators) if available_translators else None
     translator_id = str(selected_translator["_id"]) if selected_translator else None
 
     await db.documents.update_one(

app/routers/gig_router.py

@@ -86,14 +86,24 @@ async def _assign_missing_team_members() -> None:
     )
     async for doc in cursor:
         updates = {}
-        if not doc.get("assigned_linguist_id") and linguists:
+        current_linguist_id = doc.get("assigned_linguist_id")
+        current_translator_id = doc.get("assigned_translator_id")
+
+        if not current_linguist_id and linguists:
             selected = random.choice(linguists)
-            updates["assigned_linguist_id"] = str(selected["_id"])
+            current_linguist_id = str(selected["_id"])
+            updates["assigned_linguist_id"] = current_linguist_id
             updates["assigned_linguist_name"] = selected.get("name", "Linguist")
-        if not doc.get("assigned_translator_id") and translators:
-            selected = random.choice(translators)
+
+        if not current_translator_id and translators:
+            # Ensure translator is different from linguist
+            available = [t for t in translators if str(t["_id"]) != current_linguist_id] if current_linguist_id else translators
+            if not available:
+                available = translators  # fallback
+            selected = random.choice(available)
             updates["assigned_translator_id"] = str(selected["_id"])
             updates["assigned_translator_name"] = selected.get("name", "Translator")
+
         if updates:
             await db.documents.update_one({"_id": doc["_id"]}, {"$set": updates})
 
@@ -230,9 +240,6 @@ async def submit_verification(
     role = _normalized_reviewer_role(reviewer.get("role", ""))
     if not role:
         raise HTTPException(status_code=403, detail="Reviewer role required")
-        
-    if role == "linguist" and (not req.notes or not req.notes.strip()):
-        raise HTTPException(status_code=400, detail="Linguistic experts must provide notes for the end user before submitting")
 
     db = get_db()
     try: