הראה קוד מקור ל webapp.sticky_notes_api

"""
Sticky Notes API for Markdown preview
- Stores user-specific notes per file in MongoDB
- Endpoints: list, create, update, delete
"""
from __future__ import annotations

from flask import Blueprint, jsonify, request, session
from functools import wraps
from typing import Any, Dict, List, Optional, Tuple, Union, cast
from datetime import datetime, timezone, timedelta
import time
import re
import base64
import hashlib
import threading
import asyncio
import logging

# תקרת אורך התוכן — מקור אמת אחד, בלי fallback שקט.
# תלוי בכך ש-``app.py`` כבר הכין את ``sys.path``; ראו את ההסבר המלא ב-
# tests/test_webapp_import_paths.py.
from sticky_notes_target import (
    MAX_NOTE_CHARS, MAX_NOTE_TITLE, MAX_NOTES_PER_BOARD, MAX_NOTES_PER_USER,
    MAX_NOTES_PER_REPO_FILE, MAX_ARCHIVED_NOTES_PER_USER,
    MAX_FILES_PAGE_PINNED_NOTES,
    ARCHIVE_LIST_SORT,
    FILES_PAGE_PIN_FIELD,
    FILES_PAGE_PINNED_SORT,
    active_notes_filter,
    any_board_note_filter,
    files_page_pin_limit,
    files_page_pinned_filter,
    archived_notes_filter,
    archive_note_update,
    drop_unchanged_edits,
    resolve_archive_title,
    normalize_note_title,
    normalize_repo_path,
    ensure_title_index,
    ensure_repo_title_index,
    repo_notes_filter,
    title_is_taken,
    repo_title_is_taken,
    mirrored_repo_names,
    repo_file_exists,
    resolve_note_color,
    note_color_hex,
    note_color_id,
    note_search_needle_error,
    note_label,
    NOTE_LABEL_FIELDS,
    TARGET_FIELDS,
)
# מצב התזכורת — אותה שכבה טהורה, ומאותה סיבה: שלושה מודולים שואלים "האם
# התזכורת פעילה", והתשובה חייבת להיות אחת.
from note_reminder_state import (
    acknowledge_fields,
    active_reminder_filter,
    armed_fields,
    parse_remind_at,
    seconds_until as _seconds_until,
    snoozed_fields,
)
# שרשורי התגובות — הכללים, המסמך וכל כתיבה לאוסף, משותפים עם שירות ה-MCP.
import note_threads as nt
from file_dates import as_utc
# ``DuplicateKeyError`` נדרש לאכיפת שם ייחודי לפתק, ו-``PyMongoError`` לכשלי
# מסד שמסלולי השרשורים מטפלים בהם במפורש. ייבוא עמיד, באותה תבנית של
# ObjectId — בסביבות stub אין pymongo, ומחלקה מקומית שלא תיזרק לעולם עדיפה על
# ייבוא שמפיל את המודול כולו.
try:  # type: ignore
    from pymongo.errors import DuplicateKeyError, PyMongoError  # type: ignore
except Exception:  # pragma: no cover
    class DuplicateKeyError(Exception):  # type: ignore
        pass

    class PyMongoError(Exception):  # type: ignore
        pass


# Robust ObjectId/InvalidId import with fallbacks for stub environments
try:  # type: ignore
    from bson import ObjectId  # type: ignore
    from bson.errors import InvalidId  # type: ignore
except Exception:  # pragma: no cover
    class InvalidId(Exception):
        pass
    def ObjectId(x):  # type: ignore
        # Minimal fallback that accepts hex-like strings; raises on others
        s = str(x or "")
        if len(s) != 24:
            raise InvalidId("malformed ObjectId")
        return s

# Fail-open observability and tracing
try:  # type: ignore
    from observability import emit_event  # type: ignore
except Exception:  # pragma: no cover
[תיעוד] def emit_event(event: str, severity: str = "info", **fields): # type: ignore return None
try: # type: ignore from observability_instrumentation import traced # type: ignore except Exception: # pragma: no cover def traced(*_a, **_k): # type: ignore def _inner(f): return f return _inner # Access to Mongo client via app helper
[תיעוד] def get_db(): from webapp.app import get_db as _get_db # local import to avoid circulars return _get_db()
# Blueprint sticky_notes_bp = Blueprint("sticky_notes", __name__, url_prefix="/api/sticky-notes") logger = logging.getLogger(__name__) try: from cache_manager import cache # type: ignore except Exception: cache = None # type: ignore # Module-level guard to ensure indexes only once per process _INDEX_READY = False _INDEX_READY_LOCK = threading.Lock() #: **גרסת המפתח הועלתה ל-v3 בכוונה.** הדגל הזה נכתב היום רק אחרי ששני #: אינדקסי השם אומתו — של הלוח ושל הריפו — ולכן קריאתו מותר שתדליק גם את #: ``_TITLE_INDEX_OK`` וגם את ``_REPO_TITLE_INDEX_OK``. דגל ``v2`` שנכתב #: בגרסה הקודמת של הקוד העיד על אינדקס הלוח בלבד, ותחת אותו מפתח הוא היה #: מתפרש כאימות של אינדקס הריפו שלא היה — למשך יממה, ובכל התהליכים. #: #: **ו-v4 מאותה סיבה בדיוק.** הדגל אינו אומר "בדקנו פעם" אלא "כל האינדקסים #: שברשימה קיימים", ולכן הוא חייב לעלות בכל פעם שהרשימה משתנה. ``v4`` #: מלווה את הוספת ``user_updated_idx``: בלי ההעלאה, כל תהליך שקורא דגל #: ``v3`` חי היה מדלג על ``_ensure_indexes`` ליממה שלמה, והאינדקס החדש לא #: היה נבנה באף אחד מהם — כשל שקט שבדיוק כמוהו כבר קרה כאן. #: #: ``v5`` מלווה את ``user_archived_idx`` של הארכיון, מאותה סיבה, ``v6`` את #: ``user_archived_updated_idx`` של החיפוש בלי הארכיון, ו-``v7`` את #: ``files_page_pinned_idx`` של הפתקים הנעוצים לעמוד הקבצים. _INDEX_READY_CACHE_KEY = "sticky_notes_indexes_ready_v7" _INDEX_READY_CACHE_TTL_SECONDS = 24 * 3600 _INDEX_CACHE_LAST_CHECK = 0.0 _WARMUP_TRIGGERED = threading.Event() #: האם ``one_title_per_board_v2`` **אומת** במסד בהרצה האחרונה. #: #: זה לא אותו דבר כמו ``_INDEX_READY``, שאומר "ניסינו". הדגל הזה אומר #: "האילוץ חי", וזה מה שאכיפת ``duplicate_title`` נשענת עליו. כל עוד הוא #: כבוי, מסלולי הכתיבה עוברים לבדיקת קוד — ראו :func:`title_is_taken`. _TITLE_INDEX_OK = False #: האם ``one_title_per_repo_file_v1`` **אומת** במסד בהרצה האחרונה. #: #: נפרד מ-``_TITLE_INDEX_OK`` בכוונה: שני האינדקסים נבנים בנפרד, וכשל של #: אחד אינו עדות לגבי השני. דגל משותף היה מדליק אכיפה שלא אומתה. _REPO_TITLE_INDEX_OK = False #: מתי מותר לנסות לבנות שוב אחרי כשל, כ-``time.monotonic``. #: #: בלי החסם הזה כשל מתמשך באינדקס אחד היה גורם ל**כל בקשה** להיכנס #: ל-``_ensure_indexes``, לתפוס את הנעילה ולבנות מחדש את כל שש קבוצות #: האינדקסים — לולאה חמה שמסריאלת את השירות כולו סביב מנעול אחד. _INDEX_RETRY_AFTER = 0.0 #: כמה להמתין בין ניסיונות בנייה כושלים, בשניות. _INDEX_RETRY_SECONDS = 60.0 #: הדור של מצב "האינדקסים מוכנים". רק ``reset_index_state_for_tests`` מקדם אותו, #: ולכן בפרודקשן הוא נשאר על ערך הטעינה שלו לכל חיי התהליך. #: #: כל קריאה ל-``_ensure_indexes`` שייכת לדור שבו התחילה — בקשה לוכדת אותו #: בכניסה, וחימום העלייה ברגע ש-``kickoff_index_warmup`` נקרא — ובודקת אותו #: **תחת** ``_INDEX_READY_LOCK`` לפני שהיא בונה או כותבת. כך עבודה שהתחילה לפני #: איפוס ומגיעה לנעילה אחריו יוצאת בלי לגעת במצב של הבדיקה הבאה. _INDEX_STATE_GENERATION = 0
[תיעוד] def reset_index_state_for_tests() -> None: """מחזיר את מצב "האינדקסים מוכנים" למצב של תהליך שזה עתה עלה. **לטסטים בלבד.** ``_ensure_indexes`` זוכר את מה שגילה בגלובלים של המודול, והם חיים כל עוד התהליך חי: ``_INDEX_READY``, ``_TITLE_INDEX_OK`` ו-``_REPO_TITLE_INDEX_OK``, מועד הניסיון הבא ``_INDEX_RETRY_AFTER``, החלון ``_INDEX_CACHE_LAST_CHECK`` של קריאת הדגל המשותף, ו-``_WARMUP_TRIGGERED`` של חימום העלייה. בפרודקשן זו כל הכוונה. בטסטים תהליך אחד מריץ בדיקות רבות ברצף, ובדיקה שהריצה את הבנייה מול stub שאינו מאמת את אינדקס השם משאירה את ``_INDEX_RETRY_AFTER`` פתוח למשך ``_INDEX_RETRY_SECONDS`` — ובדיקה שבאה אחריה באותו תהליך מקבלת מ- ``_ensure_indexes`` יציאה מוקדמת, בלי שאף אינדקס נבנה. **רשימה אחת, ליד המצב.** עד כאן כל קובץ טסט החזיק רשימה משלו של מה לאפס, והרשימות נסחפו: ``indexed_db`` ב-``tests/test_note_boards_mongo.py`` איפס את השומרים שהכיר, ולא את ``_INDEX_RETRY_AFTER``. מי שמוסיף כאן מצב מוסיף אותו גם לפונקציה הזו, ו-``tests/test_sticky_notes_index_state.py`` נופל אם לא. בקוד הייצור אין לה קורא; בין בדיקות קורא לה הפיקסצ'ר האוטומטי ב- ``conftest.py`` שבשורש הריפו, לפני כל בדיקה ואחריה. **הדגל המשותף נמחק, ונקרא בחזרה — מהלקוח עצמו.** ``_cache_flag_ready`` קורא אותו מהקאש של המודול (``_shared_cache``) — Redis, או קאש מדומה של בדיקה — ולכן איפוס של הזיכרון לבדו אינו מספיק. המחיקה והקריאה החוזרת אינן עוברות דרך ``CacheManager``: ``get`` שלו מחזיר ``None`` גם כשאין מפתח וגם כש-Redis לא ענה, ו-``delete`` מחזיר ``False`` גם כשהמפתח לא היה וגם כשהמחיקה נכשלה, ולכן אף אחד מהם אינו עדות. הלקוח שמאחוריו (``redis_client``) מחזיר ``None`` רק על מפתח שאינו קיים, וזורק כשהוא אינו עונה — לפי קוד המקור של redis-py 7.0.0: ה-docstring של ``get`` ב-``redis/commands/core.py``, ו-``raise error`` בסוף ``Retry.call_with_retry`` ב-``redis/retry.py``. **ערוץ הכשל הוא חריגה.** דגל ששרד את המחיקה זורק ``RuntimeError``, ושגיאה של הלקוח עולה כמו שהיא: איפוס שנכשל וממשיך בשקט היה מחזיר בדיוק את מה שהוא בא לתקן — בנייה שיוצאת מוקדם, ובדיקות שנופלות על מסד ריק מסיבה שאין לה קשר לקוד שהן בודקות. **עבודה שהתחילה לפני האיפוס אינה כותבת אחריו.** האיפוס מקדם את ``_INDEX_STATE_GENERATION`` תחת ``_INDEX_READY_LOCK``. בנייה שכבר בתוך הנעילה מסתיימת קודם — כולל הקביעה של ``_INDEX_RETRY_AFTER`` כשהיא נכשלת — והאיפוס מנקה את מה שהיא פרסמה. קריאה שהתחילה לפני האיפוס ומגיעה לנעילה אחריו — בקשה שהמתינה לה, או חימום של ``kickoff_index_warmup`` שתוזמן ועוד ישן — יוצאת בלי לבנות ובלי לכתוב. **ומה שאינו מכוסה, בכוונה:** בדיקת המוכנוּת של ``_ensure_indexes`` — הדגל בזיכרון והדגל המשותף — רצה לפני הנעילה, כדי שבקשה רגילה תצא בלי לגעת בה (``docs/performance-sticky-notes.rst``). ``_cache_flag_ready`` שרץ באותו רגע עצמו בחוט אחר יכול עדיין לכתוב אחרי האיפוס: לאמץ דגל משותף שקרא לפני המחיקה ולהדליק את מה שכובה, או לקדם את ``_INDEX_CACHE_LAST_CHECK``; וכך גם הבדיקה וההדלקה של ``_WARMUP_TRIGGERED`` ב-``kickoff_index_warmup``. בין בדיקות, זה דורש חוט שעדיין רץ אחרי שהבדיקה שלו הסתיימה, ושנמצא בתוך הקטע הזה בדיוק ברגע האיפוס. """ global _INDEX_READY, _TITLE_INDEX_OK, _REPO_TITLE_INDEX_OK, _INDEX_RETRY_AFTER, _INDEX_CACHE_LAST_CHECK global _INDEX_STATE_GENERATION with _INDEX_READY_LOCK: # הדור לפני הכול: מרגע זה קריאה שהתחילה קודם — גם כזו שעוד לא הגיעה # לנעילה — כבר אינה הדור הנוכחי, ותצא כשתבדוק. _INDEX_STATE_GENERATION += 1 # הדגל המשותף לפני הזיכרון: בסדר ההפוך, קורא שנכנס בין שני השלבים היה # מוצא את הדגל הישן ומדליק מחדש את מה שזה עתה כובה. cache_obj = _shared_cache() if cache_obj is not None: # ``CacheManager`` מחזיק את הלקוח ב-``redis_client``; קאש מדומה בלי # לקוח הוא המאגר עצמו. store = getattr(cache_obj, "redis_client", cache_obj) # מאגר בלי ``get`` — ובהם ``CacheManager`` שאין לו לקוח — אינו יכול # להחזיק דגל ש-``_cache_flag_ready`` יאמץ: הקריאה שלו נכשלת שם תמיד, # והכשל נבלע לתוך "אין דגל". אז גם אין מה למחוק. הבדיקה היא על # יכולת קבועה של האובייקט, לא על כשל בזמן ריצה. read = getattr(store, "get", None) if read is not None and read(_INDEX_READY_CACHE_KEY) is not None: store.delete(_INDEX_READY_CACHE_KEY) if read(_INDEX_READY_CACHE_KEY) is not None: raise RuntimeError( f"{_INDEX_READY_CACHE_KEY} survived the reset: " f"{type(store).__name__}.get still returns it after delete(), so " "_ensure_indexes would skip the index build in the next test" ) _INDEX_READY = False _TITLE_INDEX_OK = False _REPO_TITLE_INDEX_OK = False _INDEX_RETRY_AFTER = 0.0 _INDEX_CACHE_LAST_CHECK = 0.0 _WARMUP_TRIGGERED.clear()
#: **מפרט אינדקסי השאילתה של** ``sticky_notes`` **— מקור אמת אחד.** #: #: שלושת הצרכנים — המסלול המהיר (``create_indexes``), מסלול הגיבוי #: (``create_index`` אחד-אחד), והאימות בקריאה חוזרת — נגזרים כולם מכאן. #: כשכל אחד החזיק עותק משלו, אינדקס שנוסף לרשימה אחת ולא לשתיים האחרות #: פשוט לא נבנה במסלול הגיבוי **ולא סומן כחסר באימות** — כלומר בדיוק #: ההשמטה השקטה שהאימות נועד לתפוס. _QUERY_INDEX_SPECS: Tuple[Tuple[str, List[Tuple[str, int]]], ...] = ( ("user_file_idx", [("user_id", 1), ("file_id", 1)]), ("user_file_created", [("user_id", 1), ("file_id", 1), ("created_at", 1)]), ("updated_desc", [("updated_at", -1)]), # שאילתת ה-list הראשית היא ``$or`` על scope_id/file_id ("user_scope_idx", [("user_id", 1), ("scope_id", 1)]), # פתקי לוח: שאילתה ישירה, בלי ``$or`` ובלי code_snippets ("user_board_idx", [("user_id", 1), ("board_id", 1)]), # פתקי ריפו: המפתח הוא הזוג ``(repo_name, repo_path)``, ולכן האינדקס # מורכב משניהם. בלי ``ref``/ענף — בכוונה: פתק שנרשם על ``main`` חייב # להופיע גם בענף PR. ("user_repo_idx", [("user_id", 1), ("repo_name", 1), ("repo_path", 1)]), # חיפוש פתק לפי שם חוצה את שלושת היעדים, ולכן אינו יכול להישען על אף # אחד משני האינדקסים הייחודיים: ה-``partialFilterExpression`` שלהם # דורש ``board_id``, או ``repo_name`` **וגם** ``repo_path`` — פרדיקטים # שהחיפוש אינו נושא, ולכן הוא אינו תת-קבוצה של אף אחד מהם. ("user_title_idx", [("user_id", 1), ("title", 1)]), # **התחילית והמיון יחד.** ``explain`` על חיפוש הפתקים — הפילטר של # ``note_search_filter`` עם ``.sort("updated_at", -1)``, כפי # ש-``mcp_server.backend.search_notes`` מריץ אותו — הראה שמונגו בוחרת # דווקא ב-``updated_desc``, כלומר סורקת את הפתקים של **כל** המשתמשים # לפי סדר עדכון ומסננת ``user_id`` כשארית. התוכניות שנשענות על תחילית # ``user_id`` נדחות כולן, כי כל אחת מהן דורשת ``SORT`` חוסם (32MB). # האינדקס הזה הוא היחיד שנותן את שניהם: איתור ישיר של המשתמש, ובתוכו # סדר מוכן. ("user_updated_idx", [("user_id", 1), ("updated_at", -1)]), # **הארכיון, ושתי שאלות על אותו אינדקס.** הרשימה — ``archived_notes_filter`` # ממוין ב-``ARCHIVE_LIST_SORT`` — סורקת אותו בגבולות הדוקים ובלי ``SORT``, # כי המפתחות שאחרי ``user_id`` הם בדיוק סדר המיון; והספירה של תקרת המשתמש # (``active_notes_filter``, ``archived_at: None``) היא ``COUNT_SCAN`` עליו, # בלי לקרוא מסמכים. נעול מול מונגו אמיתי ב-``tests/test_note_archive_mongo.py``. ("user_archived_idx", [("user_id", 1), ("archived_at", -1), ("_id", -1)]), # **החיפוש בלי הארכיון — שוויון, שוויון, מיון.** ``note_search_filter`` מוסיף # ``archived_at: None`` (``active_notes_filter``), ובלי האינדקס הזה המתכנן # בחר בין ``user_updated_idx`` (מיון מוכן, ``archived_at`` כשארית) לבין # ``user_archived_idx`` (גבולות הדוקים, ו-``SORT`` חוסם). לשאילתת מילה נדירה # ניצח השני, והתוכנית נשמרה במטמון — ושאילתת מילה נפוצה שרצה אחריה השתמשה # בה: נמדד בהרצה אמיתית עם הפרופיילר, 1000 מסמכים שנקראו במקום 22, בכל # הרצה. כאן ``user_id`` ו-``archived_at`` הם שוויון ו-``updated_at`` הוא סדר # המיון, ולכן התוכנית קוראת לפי הסדר ונעצרת בתקרה גם מתוך המטמון. נעול מול # מונגו אמיתי ב-``tests/test_note_archive_mongo.py``. ("user_archived_updated_idx", [("user_id", 1), ("archived_at", 1), ("updated_at", -1)]), # **הפתקים הנעוצים לעמוד הקבצים — הרשימה והספירה של התקרה.** ``files_page_pinned_filter`` # הוא ``$type: "date"`` על השדה, ולכן הגבולות על האינדקס הזה מדלגים על כל פתק שאינו נעוץ # (הוא נשמר בו כ-``null``), והמפתחות שאחרי ``user_id`` הם בדיוק ``FILES_PAGE_PINNED_SORT`` — # כלומר בלי ``SORT`` בזיכרון. ``archived_at`` נשאר שארית על המסמכים הנעוצים בלבד. נעול מול # מונגו אמיתי ב-``tests/test_files_page_pins_mongo.py``. ("files_page_pinned_idx", [("user_id", 1), (FILES_PAGE_PIN_FIELD, 1), ("_id", 1)]), ) def _emit_index_event(stage: str, duration_ms: Optional[int] = None, error: Optional[str] = None) -> None: """Emit lightweight observability events without failing the request.""" try: severity = "info" if not error else "error" emit_event( "sticky_indexes_warmup", severity=severity, stage=stage, duration_ms=duration_ms, error=error, ) except Exception: pass def _shared_cache() -> Any: """הקאש שהדגל המשותף נקרא ממנו ונכתב אליו, או ``None`` כשהוא כבוי. מקור אחד לשלושה צרכנים — הקורא (``_cache_flag_ready``), הכותב (``_mark_cache_flag``) והאיפוס (``reset_index_state_for_tests``) — כי איפוס שמוחק מערוץ אחר מזה שהקורא קורא ממנו משאיר את הדגל במקום. """ cache_obj = cache if 'cache' in globals() else None if cache_obj is None or not getattr(cache_obj, "is_enabled", False): return None return cache_obj def _cache_flag_ready() -> bool: """Check shared cache flag (best-effort) to avoid duplicate index builds. **הדגל המשותף גורר את שני דגלי אינדקס-השם.** הוא נכתב רק דרך ``_mark_indexes_ready``, שרץ רק כששני אינדקסי השם אומתו — כלומר קיומו הוא עדות לכך ששני האילוצים חיים. בלי הגרירה הזו, worker חדש שיורש את הדגל היה מדלג על הבנייה, נשאר עם דגל כבוי לתמיד, ומריץ שאילתת גיבוי מיותרת בכל כתיבה עם שם. גרסת המפתח הועלתה ל-``v3`` בדיוק בשביל זה: דגל ``v2`` ישן העיד רק על אינדקס הלוח, ואסור שיסמן את אינדקס הריפו כמאומת בלי שאומת. """ global _INDEX_READY, _INDEX_CACHE_LAST_CHECK, _TITLE_INDEX_OK, _REPO_TITLE_INDEX_OK if _INDEX_READY: return True cache_obj = _shared_cache() if cache_obj is None: return False now = time.time() if now - _INDEX_CACHE_LAST_CHECK < 30.0: return False _INDEX_CACHE_LAST_CHECK = now try: flag = cache_obj.get(_INDEX_READY_CACHE_KEY) except Exception: flag = None if flag: _INDEX_READY = True _TITLE_INDEX_OK = True _REPO_TITLE_INDEX_OK = True return True return False def _mark_cache_flag() -> None: cache_obj = _shared_cache() if cache_obj is None: return try: cache_obj.set( _INDEX_READY_CACHE_KEY, {"ready": True, "ts": int(time.time())}, _INDEX_READY_CACHE_TTL_SECONDS, ) except Exception: pass def _mark_indexes_ready(duration_ms: Optional[int] = None) -> None: global _INDEX_READY _INDEX_READY = True _mark_cache_flag() _emit_index_event("done", duration_ms=duration_ms)
[תיעוד] def kickoff_index_warmup(*, background: bool = True, delay_seconds: float = 0.0) -> None: """Run index warmup once during startup so requests won't block on it.""" # הדור נלכד לפני התנאים שלמטה: חימום שהתחיל לפני איפוס שייך לדור הישן גם # אם תוזמן אחריו, ולכן ``_ensure_indexes`` לא יבנה בשבילו. generation = _INDEX_STATE_GENERATION if _INDEX_READY or _cache_flag_ready() or _WARMUP_TRIGGERED.is_set(): return _WARMUP_TRIGGERED.set() def _job(): if delay_seconds > 0: try: time.sleep(delay_seconds) except Exception: pass _ensure_indexes(generation=generation) if background: try: # אם אנחנו בתוך event loop (למשל שירות aiohttp) – עדיף להעיף ל-executor כדי לא לחסום. # ב-Flask/Wsgi (ללא לולאה רצה) ניפול חזרה ל-thread דמון. try: loop = asyncio.get_running_loop() except RuntimeError: loop = None if loop is not None: loop.run_in_executor(None, _job) else: threading.Thread(target=_job, name="sticky-index-warmup", daemon=True).start() except Exception: _job() else: _job()
def _ensure_indexes(generation: Optional[int] = None) -> None: global _TITLE_INDEX_OK, _REPO_TITLE_INDEX_OK, _INDEX_RETRY_AFTER # **הדור שהקריאה שייכת אליו** (``_INDEX_STATE_GENERATION``): בקשה נלכדת כאן, # בכניסה; חימום העלייה מעביר את הדור שבו ``kickoff_index_warmup`` נקרא. if generation is None: generation = _INDEX_STATE_GENERATION elif generation != _INDEX_STATE_GENERATION: # עבודה מדור קודם יוצאת עוד לפני המסלול המהיר, כדי שלא תקרא את הקאש # המשותף של הבדיקה הבאה ולא תזיז לה את ``_INDEX_CACHE_LAST_CHECK``. # זו יציאה מוקדמת בלבד; ההכרעה היא הבדיקה שתחת הנעילה. return if _INDEX_READY or _cache_flag_ready(): return # החסם נבדק **לפני** הנעילה: בקשה שנקלעה לחלון ההמתנה לא צריכה # להמתין גם לנעילה כדי לגלות שאין לה מה לעשות. if time.monotonic() < _INDEX_RETRY_AFTER: return failure: Optional[str] = None with _INDEX_READY_LOCK: # הדור ראשון: קריאה שהתחילה לפני איפוס ומגיעה לנעילה אחריו יוצאת כאן, # לפני שהיא קוראת את הדגל המשותף, בונה או כותבת משהו. if generation != _INDEX_STATE_GENERATION: return if _INDEX_READY or _cache_flag_ready(): return if time.monotonic() < _INDEX_RETRY_AFTER: return try: started = time.perf_counter() db = get_db() coll = db.sticky_notes try: from pymongo import IndexModel # type: ignore # הכיוונים כבר במפרט (``-1`` ל-``updated_desc``); ``ASCENDING`` # ו-``DESCENDING`` הם 1 ו--1 בדיוק, ולכן אין כאן תרגום. indexes = [ IndexModel(keys, name=name) for name, keys in _QUERY_INDEX_SPECS ] coll.create_indexes(indexes) except Exception: # Best-effort: if pymongo typings not available or running in stub env # # **``try`` לכל אינדקס בנפרד, ולא אחד סביב כולם.** ``try`` # יחיד הופך את הרשימה לשרשרת: כשל באינדקס הראשון מדלג על כל # השאר, והם לא נבנים לעולם — בלי שום שגיאה. האינדקס האחרון # ברשימה הוא הקורבן הסביר ביותר. בלוק ``note_reminders`` # שמתחת כבר בנוי כך; זה היה החריג. for name, keys in _QUERY_INDEX_SPECS: try: coll.create_index(keys, name=name) except Exception: logger.warning( "sticky notes index %s creation failed (non-fatal)", name, exc_info=True ) # **אימות בקריאה חוזרת לכל אינדקסי השאילתה** (``_QUERY_INDEX_SPECS``). # # עד כאן שום דבר לא נבדק: ``create_indexes`` ו-``create_index`` # מדווחים הצלחה בערך ההחזרה, וערך החזרה של כתיבה אינו אימות. # בסביבת stub הם אפילו no-op. קריאה אחת ל-``index_information`` # הופכת "בנינו" ל"קיים", וחסר מתועד בלוג במקום להיעלם. # # **ובכוונה אינו חוסם את** ``_INDEX_READY``, בשונה משני אינדקסי # השם שמתחת. ההבדל אינו קפריזה: אינדקס אכיפה חסר הוא באג # נכונות — ``duplicate_title`` מובטח ולא קיים — ולכן ראוי # שיחזור לנסות. אינדקס שאילתה חסר הוא האטה. חסימת הדגל עליו # הייתה מריצה את הבוטסטראפ כולו בכל בקשה, לנצח, בכל סביבת stub # וגם מול אינדקס שפשוט אינו ניתן לבנייה. try: present = coll.index_information() or {} missing, mismatched = [], [] for name, keys in _QUERY_INDEX_SPECS: info = present.get(name) if info is None: missing.append(name) continue # **השוואת מפתחות, לא רק שם.** אינדקס שקיים תחת השם הזה # עם מפתחות אחרים גורם למונגו לדחות את היצירה # ב-``code 85/86``, ובדיקה לפי שם בלבד הייתה מדווחת # "קיים" — כלומר בדיוק המצב שבו השאילתה ממשיכה # ב-COLLSCAN בשקט. מונגו מחזיר ``key`` כרשימת זוגות. actual = [(str(f), int(d)) for f, d in (info.get("key") or [])] if actual != [(f, int(d)) for f, d in keys]: mismatched.append((name, actual)) if missing: logger.error("sticky notes query indexes missing after build: %s", missing) if mismatched: # לא מיישבים כאן: הפלה-ובנייה על אינדקס חי היא פעולה # שדורשת החלטה, ולא תופעת לוואי של בוטסטראפ. השם # הממוספר הוא הכלי ליישוב מכוון (ראו # ``_ensure_versioned_unique_index``). logger.error( "sticky notes query indexes exist with a different key spec: %s", mismatched, ) except Exception: logger.warning("sticky notes index verification failed", exc_info=True) # האינדקס הייחודי נוצר **בנפרד משני המסלולים**, ולא בתוכם. # # שני טעמים. האחד: כשהוא ישב ברשימת ``create_indexes``, כשל שלו # הפיל את כל החמישה למסלול הפולבק — שלא יצר אותו — ואז # ``_INDEX_READY`` נדלק בעוד שאכיפת ``duplicate_title`` פשוט # אינה קיימת. השני: הוא דורש **יישוב** של גרסה קודמת, כי אינדקס # בשם קיים עם אפשרויות שונות נדחה ב-code 86. try: _TITLE_INDEX_OK = bool(ensure_title_index(coll)) if not _TITLE_INDEX_OK: logger.error("one_title_per_board index not confirmed after create") except Exception: _TITLE_INDEX_OK = False logger.error("one_title_per_board index creation failed", exc_info=True) # אח מקביל לפתקי ריפו, ומאותם שני טעמים בדיוק. דגל נפרד, כי # הצלחת האחד אינה עדות להצלחת השני — ודגל משותף היה מדליק # אכיפה שלא אומתה. try: _REPO_TITLE_INDEX_OK = bool(ensure_repo_title_index(coll)) if not _REPO_TITLE_INDEX_OK: logger.error("one_title_per_repo_file index not confirmed after create") except Exception: _REPO_TITLE_INDEX_OK = False logger.error("one_title_per_repo_file index creation failed", exc_info=True) # אינדקסים ללוחות הפתקים (best-effort) try: nb = db.note_boards # ``one_default_per_user`` ייחודי-חלקי: הוא מה שסוגר את המרוץ # שבו שתי בקשות מקבילות מגלות שאין לוח ברירת מחדל ושתיהן # יוצרות. הגנת קוד לבדה לא מספיקה שם — המסד חייב לדחות. try: from pymongo import ASCENDING, IndexModel # type: ignore nb.create_indexes([ IndexModel([("user_id", ASCENDING), ("order", ASCENDING)], name="user_order_idx"), IndexModel( [("user_id", ASCENDING)], name="one_default_per_user", unique=True, partialFilterExpression={"is_default": True}, ), ]) except Exception: try: nb.create_index([("user_id", 1), ("order", 1)], name="user_order_idx") except Exception: pass try: nb.create_index( [("user_id", 1)], name="one_default_per_user", unique=True, partialFilterExpression={"is_default": True}, ) except Exception: pass except Exception: pass # Ensure note reminders collection indexes (best-effort) try: nr = db.note_reminders try: from pymongo import ASCENDING, DESCENDING, IndexModel # type: ignore nr.create_indexes([ IndexModel([("user_id", ASCENDING), ("note_id", ASCENDING)], name="user_note_idx"), IndexModel([("user_id", ASCENDING), ("status", ASCENDING), ("remind_at", ASCENDING)], name="user_status_time_idx"), IndexModel([("remind_at", ASCENDING)], name="remind_at_idx"), ]) except Exception: try: nr.create_index([("user_id", 1), ("note_id", 1)], name="user_note_idx") except Exception: pass try: nr.create_index([("user_id", 1), ("status", 1), ("remind_at", 1)], name="user_status_time_idx") except Exception: pass try: nr.create_index([("remind_at", 1)], name="remind_at_idx") except Exception: pass except Exception: # Never fail request because of index creation pass duration_ms = int(max(0.0, (time.perf_counter() - started) * 1000.0)) # **שני אינדקסי השם חייבים להתאמת לפני סימון "מוכן".** אחרת, # אם אינדקס הלוח הצליח ואינדקס הריפו נכשל, הדגל היה נדלק (כולל # ברדיס ל-24 שעות), הבנייה הייתה מדלגת בכל הבקשות הבאות, ואכיפת # השם על פתקי ריפו הייתה נעדרת ליממה — בכל התהליכים. if _TITLE_INDEX_OK and _REPO_TITLE_INDEX_OK: _INDEX_RETRY_AFTER = 0.0 _mark_indexes_ready(duration_ms=duration_ms) else: _INDEX_RETRY_AFTER = time.monotonic() + _INDEX_RETRY_SECONDS which = "one_title_per_board" if not _TITLE_INDEX_OK else "one_title_per_repo_file" failure = f"{which} not confirmed" except Exception as exc: # ההשמה תחת הנעילה, כמו כל שאר הכתיבות של הבנייה: מחוץ לה, איפוס # שממתין לנעילה יכול להיכנס בין השחרור להשמה, וחלון ההמתנה נפתח # מחדש אחריו. _INDEX_RETRY_AFTER = time.monotonic() + _INDEX_RETRY_SECONDS failure = str(exc) if failure is not None: # שני מסלולי הכשל — חריגה, ואינדקס שם שלא אומת — שולחים את האירוע # אחרי שחרור הנעילה: ``emit_event`` על שגיאה עושה עבודה משלו — סיווג, # Sentry, ולפי ``ALERT_EACH_ERROR`` גם התראה — ובקשות שממתינות לנעילה # לא צריכות להמתין גם לה. ``is not None`` ולא אמת בוליאנית: חריגה בלי # הודעה נותנת מחרוזת ריקה, וגם עליה נשלח אירוע. _emit_index_event("failed", error=failure) # --- Helpers --- def _title_conflict(db: Any, user_id: Any, board_id: Any, title: str, exclude_id: Any = None) -> bool: """גיבוי לאכיפת השם, ורק כשהאינדקס לא אומת. במצב התקין הפונקציה מחזירה ``False`` מיד ואינה עולה שאילתה — האכיפה היא של המסד, וכך היא גם חסינה למרוץ. היא מתעוררת רק כש- ``_TITLE_INDEX_OK`` כבוי, כלומר כשהראוט עומד להבטיח ``duplicate_title`` בלי שיש מי שיאכוף אותו. """ if _TITLE_INDEX_OK or not title or not board_id: return False return title_is_taken( db.sticky_notes, user_id=user_id, board_id=board_id, title=title, exclude_id=exclude_id ) def _repo_title_conflict( db: Any, user_id: Any, repo_name: Any, repo_path: Any, title: str, exclude_id: Any = None ) -> bool: """אותו גיבוי בדיוק, לפתקי ריפו — ורק כשהאינדקס שלהם לא אומת.""" if _REPO_TITLE_INDEX_OK or not title or not repo_name or not repo_path: return False return repo_title_is_taken( db.sticky_notes, user_id=user_id, repo_name=repo_name, repo_path=repo_path, title=title, exclude_id=exclude_id, ) def _duplicate_title_for_note( db: Any, user_id: Any, note: Dict[str, Any], title: str, exclude_id: Any = None ) -> bool: """בדיקת הגיבוי לכפילות שם, **לפי סוג היעד של הפתק**. ``_title_conflict`` יוצא מיד כשאין ``board_id`` — ולפתק ריפו אין — ולכן כשאינדקס הריפו לא אומת לא הייתה שום אכיפה: אף אחד לא בדק, המסד לא אכף, ושני פתקים על אותו קובץ קיבלו את אותו שם. **הפיצול חי כאן ולא בכל ראוט בנפרד.** כשהוא היה משוכפל, ``update_note`` קיבל אותו ו-``batch`` נשאר מאחור — ומכיוון שהלקוח שומר דרך ``_queueSave``, שמאגד ל-``/batch``, דווקא המסלול השקוף היה זה שלא אכף. סוג יעד רביעי בעתיד ישנה שורה אחת, לא שתיים. """ if not title: return False if note.get('repo_path'): return _repo_title_conflict( db, user_id, note.get('repo_name'), note.get('repo_path'), title, exclude_id=exclude_id, ) return _title_conflict(db, user_id, note.get('board_id'), title, exclude_id=exclude_id)
[תיעוד] def require_auth(f): @wraps(f) def _inner(*args, **kwargs): if 'user_id' not in session: return jsonify({'ok': False, 'error': 'Unauthorized'}), 401 return f(*args, **kwargs) return _inner
def _failed(route: str, error: str = 'Failed'): """500 עם עקבה בשרת: הלוג נושא את ה-traceback, הלקוח מקבל רק ``error``. ``@traced`` רושם רק חריגה שיוצאת מהפונקציה, וה-``except`` הגורף במסלולי התזכורות תופס אותה קודם — ולכן עד היום נתיב שנפל לא השאיר שום סימן בשרת, בזמן שהלקוח הופך את ה-500 ל-backoff שקט. ההודעה קבועה, והחריגה עוברת את מסנן ההשחרה של הלוגים כמו כל ``exc_info`` אחר במודול. חייב להיקרא מתוך ה-``except``, כי ``exc_info=True`` קורא את החריגה הפעילה. ``error`` הוא הטקסט שהלקוח כבר מכיר במסלול הזה (``Failed``, או ``Failed to save`` בשמירה); הוא לעולם אינו נושא פרטי חריגה. """ logger.error("sticky notes %s failed", route, exc_info=True) return jsonify({'ok': False, 'error': error}), 500 def _json_object(): """גוף ה-JSON של הבקשה כמילון — או ``None`` כשהגוף אינו אובייקט. ``request.get_json(silent=True) or {}`` תופס רק גוף ריק: גוף שהוא רשימה או מחרוזת הוא truthy, עובר את ה-``or``, ואז ``.get`` זורק ``AttributeError`` שה-``except`` הגורף הופך ל-500 — ומאז ``_failed`` גם לשורת ERROR עם traceback — על טעות של הלקוח. הבדיקה היא על הטיפוס, לא על האמיתות: אין גוף ← מילון ריק, כי למסלולים יש ברירות מחדל (דחייה בלי ``minutes`` היא שעה); גוף שאינו אובייקט ← ``None``, והמסלול עונה ``invalid_payload`` 400. **"אין גוף" הוא גוף ריק באמת, ולא כל ``None`` של ``get_json``.** ``get_json(silent=True)`` מחזיר ``None`` גם על JSON פגום, גם על הליטרל ``null`` וגם על גוף שה-``Content-Type`` שלו אינו JSON — ועד נובמבר 2026 כל אלה הפכו כאן למילון ריק, כלומר בקשה שהלקוח שלח עם נתונים נענתה כאילו לא שלח כלום: נעיצה לעמוד הקבצים בלי ``device_limit`` שנשלח, דחייה של שעה במקום מה שנשלח. כל הלקוחות של המסלולים האלה שולחים ``application/json`` (``sticky-notes.js``, ``base.html``, ``sw.js``), ולכן גוף שיש בו משהו ולא פוענח לאובייקט הוא טעות של הלקוח. """ payload = request.get_json(silent=True) if payload is None: if request.get_data(cache=True).strip(): return None return {} return payload if isinstance(payload, dict) else None # Simple in-memory rate limiter per user and endpoint key _RATE_LOG: Dict[tuple, list] = {} def _rate_limit_check(user_id: int, key: str, max_per_minute: int) -> tuple[bool, int]: now = time.time() window_start = now - 60.0 bucket_key = (int(user_id or 0), str(key or "")) try: entries = _RATE_LOG.get(bucket_key, []) # drop old timestamps i = 0 for i, ts in enumerate(entries): if ts > window_start: break if entries: if entries[0] <= window_start: # remove all up to i (inclusive if still old) cutoff = i if entries[i] > window_start else (i + 1) entries = entries[cutoff:] # allow? allowed = len(entries) < max(1, int(max_per_minute or 1)) if allowed: entries.append(now) _RATE_LOG[bucket_key] = entries return True, 0 else: # estimate retry-after (rough) retry_after = int(max(1.0, 60.0 - (now - (entries[0] if entries else window_start)))) return False, retry_after except Exception: return True, 0
[תיעוד] def notes_rate_limit(key: str, max_per_minute: int): def _decorator(f): @wraps(f) def _inner(*args, **kwargs): try: uid = int(session.get('user_id') or 0) except Exception: uid = 0 if uid: allowed, retry_after = _rate_limit_check(uid, key, max_per_minute) if not allowed: resp = jsonify({'ok': False, 'error': 'Rate limited'}) try: resp.headers['Retry-After'] = str(int(retry_after)) except Exception: pass return resp, 429 return f(*args, **kwargs) return _inner return _decorator
def _decode_content_b64(value: Any, *, max_b64_len: int = 120000) -> str: """Decode Base64 UTF-8 content — **והטקסט שיוצא הוא בדיוק מה שקודד**. מיועד ל-`content_b64` כדי למנוע חסימות/פילטרים על מילים "חשודות" בזמן העברה. הפענוח הוא של ההעברה בלבד: ה-base64 מוסר, והתוכן עצמו אינו משתנה בשום צורה — ראו :func:`_note_content_from_request`. """ if value is None: return "" if not isinstance(value, str): raise ValueError("content_b64 must be a string") s = value.strip() if not s: return "" # Best-effort safety: avoid decoding extremely large blobs. # Note: Base64 is ~4/3 expansion. UTF-8 can be up to 4 bytes per char. # The limit stays above a full ``MAX_NOTE_CHARS`` note of emoji — the # arithmetic is in its docstring in ``sticky_notes_target``. if max_b64_len and len(s) > int(max_b64_len): raise ValueError("content_b64 too large") # Remove whitespace and normalize urlsafe variants — של מחרוזת ה-base64, # לא של התוכן. s = "".join(s.split()) s = s.replace("-", "+").replace("_", "/") # Fix missing padding (common in transport layers) pad = (-len(s)) % 4 if pad: s = s + ("=" * pad) try: raw = base64.b64decode(s, validate=True) except Exception as exc: raise ValueError("invalid base64") from exc try: return raw.decode("utf-8", errors="strict") except Exception as exc: raise ValueError("invalid utf-8") from exc def _coerce_int(value: Any, default: int, min_v: Optional[int] = None, max_v: Optional[int] = None) -> int: try: x = int(value) except Exception: x = int(default) if min_v is not None and x < min_v: x = min_v if max_v is not None and x > max_v: x = max_v return x def _mode_update(raw: Any, note: Dict[str, Any]) -> Tuple[Any, Optional[str]]: """מאמת ``mode`` שהתקבל בעדכון, ומחזיר את הערך לשמירה. מחזירה ``(ערך_לשמירה, קוד_שגיאה)``; אחד מהם תמיד ``None``. החזרת קוד ולא ``raise`` — כדי שלא יהיה טקסט של חריגה שיכול לזלוג לתשובה. ``mode`` נכתב עד היום רק ביצירה, ולכן כפתור המצב בלוח לא יכול היה להישמר בכלל. הוא מותר ב**לוח ובפתק ריפו** — שניהם נושאים ``surface``/``screen`` ומצמידים את הפתק למסגרת התצוגה — ונשאר חסום בפתקי **קובץ**: שם ``_resolveMode`` קורא את השדה **לפני** הסנטינלים, כך ש-``mode`` היה משתלט על מסלול העיגון לשורות המקור. """ from sticky_notes_target import is_valid_board_mode, normalize_mode, DEFAULT_BOARD_MODE # פתק ריפו נושא ``mode`` בדיוק כמו פתק לוח — surface/screen — ולכן כפתור # המצב שלו חייב להישמר. בלי ``repo_path`` כאן הוא היה נדחה ב- # ``mode_not_supported``, והכפתור היה נשבר בשקט. פתקי **קובץ** נשארים # מחוץ, כי אצלם ``_resolveMode`` קורא את ``mode`` לפני הסנטינלים והוא # היה משתלט על מסלול עיגון-השורה. if not note.get('board_id') and not note.get('repo_path'): return None, 'mode_not_supported' if raw is not None and not is_valid_board_mode(raw): return None, 'invalid_mode' return normalize_mode(raw, DEFAULT_BOARD_MODE), None class _ContentTooLong(ValueError): """התוכן חרג מהתקרה.""" class _InvalidContentB64(ValueError): """``content_b64`` פגום ואין ``content`` לנפול אליו.""" class _InvalidContent(ValueError): """``content`` שאינו מחרוזת.""" def _content_field(value: Any) -> str: """הערך של ``content`` כמו שנשלח — או :class:`_InvalidContent`. ``None`` הוא "אין תוכן", כמו שהיה תמיד. **כל מה שאינו מחרוזת נדחה**: עד היום ``str()`` הפך מילון ל-``"{'a': 1}"`` ושמר אותו כטקסט, ובלעדיו הוא היה נשמר כתת-מסמך בשדה שכל הקוראים מצפים בו למחרוזת. """ if value is None: return "" if not isinstance(value, str): raise _InvalidContent() return value def _note_content_from_request(data: Dict[str, Any]) -> str: """התוכן שיישמר, מ-``content_b64`` או מ-``content`` — **בדיוק כמו שנשלח**. **מקום אחד שמחליט.** לפני כן ההמרה הייתה משוכפלת בחמישה ראוטים, וכל אחד מהם הקליד את התקרה בעצמו. השינוי המהותי: התקרה נאכפת ב**דחייה** ולא בחיתוך. חיתוך שקט הוא מחיקת מידע — הדבקה של 16,291 תווים נשמרה כ-5,000 והשרת החזיר 200 OK, כלומר "נשמר". ``mcp_server/handlers`` דוחה כבר היום; הוובאפ היה החריג. **ואין כאן ניקוי.** עד אוקטובר 2026 כל תוכן עבר כאן ``html.unescape``, המרה של CRLF ל-LF ומחיקה של תווי בקרה. כך ``&amp;`` שהמשתמש הקליד נשמר כבר בשמירה הראשונה כ-``&``, וגם ``&copy=`` בתוך כתובת הפך ל-``©=``. הכלל הוא הכלל של הקבצים, ``docs/quality/code-normalization.md``: מה שנשלח הוא מה שנשמר, וה-escape שייך לתצוגה. ``tests/test_content_cleaning_stays_in_the_bot.py`` נופל אם ``unescape`` חוזר לוובאפ. **זהות השגיאה חיה בסוג החריגה ולא בטקסט שלה.** ``str(exc)`` בתשובה ל-HTTP הוא דלף ממתין: ``raise`` עתידי שמשרשר נתיב או שאילתה מוצא אותם ללקוח, ו-CodeQL מסמן בדיוק את הזרימה הזו. מי שתופס כאן מחזיר ליטרל. :raises _ContentTooLong: התוכן ארוך מ-:data:`MAX_NOTE_CHARS`. :raises _InvalidContentB64: ``content_b64`` פגום ואין ``content``. :raises _InvalidContent: ``content`` שאינו מחרוזת. """ if 'content_b64' in data: try: text = _decode_content_b64(data.get('content_b64')) except ValueError: # תאימות לאחור: ``content`` רגיל, אם נשלח לצד ה-b64 if 'content' not in data: raise _InvalidContentB64() text = _content_field(data.get('content')) else: text = _content_field(data.get('content', '')) if len(text) > MAX_NOTE_CHARS: raise _ContentTooLong() return text def _make_scope_id(user_id: int, file_name: Optional[str]) -> Optional[str]: # פונקציה קנונית (ללא תלות ב-Flask) כדי למנוע סטיות בין שירותים. from sticky_notes_scope import make_scope_id return make_scope_id(int(user_id), file_name) def _resolve_scope(db, user_id: int, file_id: Any) -> Tuple[Optional[str], Optional[str], List[str]]: normalized_id = str(file_id or '').strip() related_ids: List[str] = [] if normalized_id: related_ids.append(normalized_id) file_name: Optional[str] = None scope_id: Optional[str] = None if db is None: return scope_id, file_name, related_ids oid = None try: oid = ObjectId(str(file_id)) except Exception: oid = None doc = None if oid is not None: try: doc = db.code_snippets.find_one({'_id': oid, 'user_id': user_id}, {'file_name': 1}) except Exception: doc = None if doc and isinstance(doc, dict): file_name = doc.get('file_name') if file_name: scope_id = _make_scope_id(user_id, file_name) try: cursor = db.code_snippets.find({'user_id': user_id, 'file_name': file_name}, {'_id': 1}) except Exception: cursor = None if cursor is not None: for entry in cursor: try: rid = str((entry or {}).get('_id') or '') except Exception: rid = '' if rid: related_ids.append(rid) seen = set() deduped: List[str] = [] for rid in related_ids: if not rid or rid in seen: continue seen.add(rid) deduped.append(rid) return scope_id, file_name, deduped def _coerce_content_from_doc(value: Any) -> str: """התוכן שבמסמך כמחרוזת — **בלי פענוח**, כמו שהוא שמור. עד אוקטובר 2026 עבר כאן ``html.unescape``. הוא נועד לפתקים שהוובאפ שמר מקודדים, בין 23.10 ל-3.11.2025, וכשהוסר לא נשאר במסד אף פתק כזה — המדידה ברשומה של 10.10.2026 ב-``docs/whats-new.rst``. כל עוד הוא היה כאן, כל ``&amp;`` שמשתמש הקליד הוצג כ-``&``. ה-escape שייך לשכבת התצוגה, לא לכאן. """ if value is None: return "" return str(value) def _stored_now() -> datetime: """עכשיו ב-UTC, **ברזולוציה שהמסד שומר** — אלפית שנייה, ולא מיליונית. תאריך ב-BSON נשמר במילישניות: ``bson`` מוריד את המיקרו-שניות שמעבר לאלפית (``_datetime_to_millis`` ב-``bson/datetime_ms.py``, ``microsecond // 1000``, ב-pymongo 4.15.3 של ``requirements/base.txt``; נמדד — ``10:00:00.123456`` חוזר כ-``10:00:00.123000``, ``test_the_stored_resolution_survives_a_real_bson_round_trip``). ``updated_at`` הוא האסימון שהלקוח מחזיק (``prev_updated_at``), והוא מגיע אליו משתי דלתות: מהמסד (הרשימה, הפתק הבודד, ``?versions=1``) ומתשובת הכתיבה עצמה (``_update_answer``, תשובת היצירה). כשהכתיבה החזירה את הזמן שבזיכרון, שתי הדלתות נתנו לאותה כתיבה שתי מחרוזות שונות, והלקוח לא יכול היה לזהות שהפתק שבמסד הוא בדיוק מה שהוא עצמו שמר — כל שמירה שלו נראתה בדגימה הבאה כמו עדכון ממקום אחר. חיתוך לפני הכתיבה הופך את מה שנכתב למה שנשמר, ולכן גם למה שחוזר. """ now = datetime.now(timezone.utc) return now.replace(microsecond=now.microsecond - now.microsecond % 1000) def _updated_at_iso(stamp: Any) -> Optional[str]: """**האסימון כמחרוזת — הפורמט היחיד שלו בכל תשובה.** ``updated_at`` הוא האסימון שהלקוח שולח בשמירה הבאה (``prev_updated_at``), והלקוח משווה במחרוזת בין האסימון שבתשובת הכתיבה לזה שבדגימה ובפתק הבודד. שני ביטויים נפרדים היו יכולים להיסחף לשני פורמטים, ולכן כל תשובה שנושאת אסימון — הפתק המלא, ``?versions=1``, תשובת העדכון והיצירה, ``409`` וסימון משימה — עוברת כאן. ערך שאינו ``datetime`` (מסמך בלי השדה) הוא ``None``, ואז הלקוח שולח בלי אסימון. איזה זמן נכנס לכאן בתשובת עדכון: ב-``update_note`` וב-``batch_update_notes``, כשהעדכון היה עריכה — הזמן שנכתב באותה כתיבה. כשלא (``drop_unchanged_edits`` החזיר ``edited`` ריק) — הזמן שהיה שמור בפתק כשנקרא, ולא קריאה חוזרת אחרי הכתיבה: קריאה כזו יכולה לתפוס עריכה מקבילה מלשונית אחרת, והלקוח היה מקבל אסימון של תוכן שלא ראה — והשמירה הבאה שלו הייתה דורסת אותו בלי 409. """ return stamp.isoformat() if isinstance(stamp, datetime) else None def _note_token(doc: Dict[str, Any]) -> Optional[str]: """האסימון של מסמך פתק — :func:`_updated_at_iso` על ``updated_at`` שלו.""" return _updated_at_iso(doc.get('updated_at')) def _as_note_response(doc: Dict[str, Any]) -> Dict[str, Any]: return { 'id': str(doc.get('_id')), 'file_id': str(doc.get('file_id', '')), 'content': _coerce_content_from_doc(doc.get('content', '')), # שם הפתק. ריק = אין שם; במסמך השדה פשוט אינו קיים. 'title': str(doc.get('title', '') or ''), 'position': { 'x': int(doc.get('position_x', 100) or 100), 'y': int(doc.get('position_y', 100) or 100), }, 'size': { 'width': int(doc.get('width', 240) or 240), 'height': int(doc.get('height', 180) or 180), }, # ``color`` נשאר **תמיד ``hex`` חוקי**, כי הצרכן היחיד שלו הוא # ``style.backgroundColor`` — לקוח שנטען מקאש ישן ימשיך לצבוע # נכון גם אחרי שהמסד עבר למזהים. ``color_id`` הוא מה שבאמת # מאוחסן, והוא מה שהבורר מסמן ומה שסינון לפי צבע ישווה אליו; # ``''`` שם פירושו צבע ``legacy`` שאינו בפלטה. 'color': note_color_hex(doc.get('color')), 'color_id': note_color_id(doc.get('color')), 'is_minimized': bool(doc.get('is_minimized', False)), 'line_start': doc.get('line_start'), 'line_end': doc.get('line_end'), 'anchor_id': doc.get('anchor_id') or '', 'anchor_text': doc.get('anchor_text') or '', # פתק לוח. הלקוח מזהה לפי זה לאיזה משטח לצרף אותו, ו-``mode`` קובע # אם הוא נע עם הלוח או נשאר על המסך. בפתק קובץ שניהם ריקים, # והמצב ממשיך להיגזר מ-``anchor_id`` כמו קודם. 'board_id': str(doc.get('board_id', '') or ''), 'mode': str(doc.get('mode', '') or ''), # פתק בארכיון: מתי הועבר. ``None`` בכל פתק אחר — ולפי זה הלקוח יודע # שהפתק כבר אינו על המשטח שהוא מציג. אותו שדה ב-``_as_note`` של ה-MCP. 'archived_at': _iso_utc(doc.get('archived_at')), # נעוץ לראש עמוד הקבצים: מתי. ``None`` בפתק שאינו נעוץ — ולפי זה פריט 📎 בתפריט ⋮ # יודע אם להציע נעיצה או הסרה. אותו שדה ב-``_NOTE_FIELDS`` של ה-MCP. FILES_PAGE_PIN_FIELD: _iso_utc(doc.get(FILES_PAGE_PIN_FIELD)), 'updated_at': _note_token(doc), 'created_at': (doc.get('created_at').isoformat() if doc.get('created_at') else None), } #: מה ש-``?versions=1`` שולף לכל פתק — המזהה, האסימון והצבע, **בלי הגוף** (Smart Projection). _NOTE_VERSION_PROJECTION = {'_id': 1, 'updated_at': 1, 'color': 1} def _versions_requested() -> bool: """האם הבקשה היא דגימה (``?versions=1``) ולא טעינה של הרשימה המלאה.""" return request.args.get('versions') == '1' def _note_versions_answer(db: Any, query: Dict[str, Any]) -> Any: """**הדגימה של עדכון בזמן אמת: מזהה, אסימון וצבע לכל פתק במשטח — בלי תוכן.** הלקוח (``sticky-notes.js``) דוגם כל כמה שניות כשהלשונית גלויה, ולכן התשובה פרופורציונלית לשאלה "מה השתנה" ולא לגודל הפתקים: הגוף, השרשורים וכל שדה אחר נשלפים רק לפתק שהשתנה, בבקשה נפרדת לפתק הבודד (``get_note``). ``query`` הוא **אותו מסנן** של הרשימה המלאה באותו ראוט, כדי שפתק חדש שמופיע כאן הוא פתק שהרשימה הייתה מציגה. בלי כתיבות ובלי תקצירי שרשורים: דגימה היא קריאה טהורה. ``color`` הוא ה-``hex`` של ``_as_note_response`` — שינוי צבע אינו מזיז את ``updated_at`` (``sticky_notes_target.NOTE_EDIT_FIELDS``), ובלעדיו לא היה נראה. """ cursor = db.sticky_notes.find(query, _NOTE_VERSION_PROJECTION) if cursor is None: # אותה הבחנה של רשימת הריפו: ``None`` הוא כשל שאילתה, ולא "אין פתקים". raise RuntimeError('note versions query returned no cursor') versions = [ {'id': str(doc.get('_id')), 'updated_at': _note_token(doc), 'color': note_color_hex(doc.get('color'))} for doc in cursor if isinstance(doc, dict) ] return _no_store(jsonify({'ok': True, 'notes': versions, 'count': len(versions)})) # --- Routes --- @sticky_notes_bp.route('/<file_id>', methods=['GET']) @require_auth @notes_rate_limit('list', 180) @traced("sticky_notes.list") def list_notes(file_id: str): """List all sticky notes for current user and file.""" try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() scope_id, file_name, related_ids = _resolve_scope(db, user_id, file_id) query: Dict[str, Any] = {'user_id': user_id} criteria: List[Dict[str, Any]] = [] if scope_id: criteria.append({'scope_id': scope_id}) if related_ids: criteria.append({'file_id': {'$in': related_ids}}) if criteria: query['$or'] = criteria else: query['file_id'] = str(file_id) # הדגימה — לפני ההשלמה של ``scope_id`` שמתחת: היא כתיבה, ודגימה כל כמה שניות אינה המקום לה. if _versions_requested(): return _note_versions_answer(db, query) cursor = db.sticky_notes.find(query).sort('created_at', 1) raw_docs = list(cursor) if cursor is not None else [] notes = [ _as_note_response(doc) for doc in raw_docs if isinstance(doc, dict) ] if scope_id: missing_ids = [doc.get('_id') for doc in raw_docs if isinstance(doc, dict) and not doc.get('scope_id')] if missing_ids: try: update_payload: Dict[str, Any] = {'scope_id': scope_id} if file_name: update_payload['file_name'] = file_name db.sticky_notes.update_many({'_id': {'$in': missing_ids}}, {'$set': update_payload}) except Exception: pass payload: Dict[str, Any] = {'ok': True, 'notes': notes, 'count': len(notes)} if not _with_thread_summaries(db, user_id, notes): payload['threads_unavailable'] = True resp = jsonify(payload) # מניעת קאשינג בדפדפן/פרוקסי כדי שלא תוחזר גרסה ישנה של פתקים try: resp.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate' resp.headers['Pragma'] = 'no-cache' resp.headers['Expires'] = '0' except Exception: pass return resp except Exception as e: try: emit_event("sticky_notes_list_error", severity="anomaly", file_id=str(file_id), error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to list notes'}), 500 # --- Sticky note reminders API --- def _parse_when_to_utc(payload: Dict[str, Any], user_tz: str) -> Optional[datetime]: """Parse reminder time from payload into aware UTC datetime. Supports: - preset values: "1h", "3h", "24h", "1w", "today-21", "tomorrow-09" - explicit: payload["at"] as ISO-like string ("YYYY-MM-DDTHH:MM") with optional seconds - free text: payload["time_text"] using reminders.utils.parse_time """ try: from zoneinfo import ZoneInfo # type: ignore except Exception: # pragma: no cover ZoneInfo = None # type: ignore now_local = None try: tz = ZoneInfo(user_tz) if (user_tz and ZoneInfo) else None except Exception: tz = None try: now_local = datetime.now(tz or timezone.utc) except Exception: now_local = datetime.now(timezone.utc) preset = str((payload or {}).get('preset') or '').strip().lower() if preset: if preset in {'1h', '1hr'}: return (now_local + timedelta(hours=1)).astimezone(timezone.utc) if preset in {'3h', '3hr'}: return (now_local + timedelta(hours=3)).astimezone(timezone.utc) if preset in {'24h', '1d'}: return (now_local + timedelta(hours=24)).astimezone(timezone.utc) if preset in {'1w', '7d'}: return (now_local + timedelta(days=7)).astimezone(timezone.utc) if preset == 'today-21': base = now_local.replace(hour=21, minute=0, second=0, microsecond=0) if base <= now_local: # if passed, schedule for tomorrow 21:00 base = base + timedelta(days=1) return base.astimezone(timezone.utc) if preset == 'tomorrow-09': base = (now_local + timedelta(days=1)).replace(hour=9, minute=0, second=0, microsecond=0) return base.astimezone(timezone.utc) at = (payload or {}).get('at') if at: try: # Expecting local naive string like "YYYY-MM-DDTHH:MM" (datetime-local) # If seconds provided, they'll be ignored by slicing s = str(at).strip() # Normalize seconds if present if len(s) >= 16: from datetime import datetime as _dt local_naive = _dt.strptime(s[:16], '%Y-%m-%dT%H:%M') if tz: aware = local_naive.replace(tzinfo=tz) else: aware = local_naive.replace(tzinfo=timezone.utc) return aware.astimezone(timezone.utc) except Exception: pass # Free text time_text = (payload or {}).get('time_text') if time_text: try: try: from reminders.utils import parse_time as _parse except Exception: _parse = None # type: ignore if _parse: dt = _parse(str(time_text), user_tz or 'UTC') if dt: return dt.astimezone(timezone.utc) except Exception: pass return None def _ensure_user_owns_note(db, user_id: int, note_id: str) -> Optional[Dict[str, Any]]: raw_id = str(note_id or "").strip() if not raw_id: return None candidates: List[Any] = [] try: from bson import ObjectId # type: ignore except Exception: ObjectId = None # type: ignore if ObjectId and raw_id: try: candidates.append(ObjectId(raw_id)) except Exception: pass candidates.append(raw_id) for candidate in candidates: try: note = db.sticky_notes.find_one({'_id': candidate, 'user_id': int(user_id)}) except Exception: note = None if isinstance(note, dict): return note return None def _reminder_scope(user_id: int, note_doc_id: Any) -> Dict[str, Any]: """המסנן של התזכורות של פתק אחד של משתמש אחד — ``(user_id, note_id)`` של ``note_reminders``. **``note_id`` נגזר מה-``_id`` של מסמך הפתק, ולא מהמחרוזת שהגיעה בכתובת.** ``ObjectId`` מקבל hex באותיות גדולות, ו-``str`` שלו תמיד בקטנות; עד נובמבר 2026 ``set_note_reminder`` שמר את מה שהלקוח שלח, ו-``delete_note``, שמוחק לפי ``str(oid)``, לא מצא תזכורת שנקבעה דרך כתובת באותיות גדולות — והיא נשארה יתומה. הקורא מעביר את ה-``_id`` של הפתק כמו שהוא: את מה ש-``_ensure_user_owns_note`` החזיר (גם פתק ישן שה-``_id`` שלו מחרוזת), או את ה-``oid`` שנמחק. זו אותה צורה ש-``nt.thread_scope`` שומר לשרשורים. """ return {'user_id': int(user_id), 'note_id': str(note_doc_id)} @sticky_notes_bp.route('/note/<note_id>/reminder', methods=['GET']) @require_auth @notes_rate_limit('note_reminder_get', 180) @traced('sticky_notes.reminder_get') def get_note_reminder(note_id: str): try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() note = _ensure_user_owns_note(db, user_id, note_id) if not note: return jsonify({'ok': False, 'error': 'Note not found'}), 404 # הפילטר המלא, ולא ``status`` לבדו: מסמך שנכתב לפני שהמצב הסופי # היה קיים נושא ``ack_at`` מלא ו-``status`` ישן, ובלי בדיקת # ``ack_at`` הראוט היה מחזיר תזכורת שהמשתמש כבר סגר כאילו היא חיה. # וממוין: ל-``user_note_idx`` אין ``unique``, ושתי קביעות מקבילות יכולות להשאיר שני # מסמכים פעילים לאותו פתק. הנציג הוא זה שיירה ראשון — אותו סדר של ``reminders_summary``. r = db.note_reminders.find_one( dict(active_reminder_filter(), **_reminder_scope(user_id, note['_id'])), sort=[('remind_at', 1)], ) if not r: return jsonify({'ok': True, 'reminder': None}) out = { 'id': str(r.get('_id')), 'status': r.get('status', 'pending'), 'remind_at': (r.get('remind_at').isoformat() if isinstance(r.get('remind_at'), datetime) else None), 'snooze_until': (r.get('snooze_until').isoformat() if isinstance(r.get('snooze_until'), datetime) else None), } return jsonify({'ok': True, 'reminder': out}) except Exception: return _failed('get_note_reminder') @sticky_notes_bp.route('/note/<note_id>/reminder', methods=['POST']) @require_auth @notes_rate_limit('note_reminder_set', 60) @traced('sticky_notes.reminder_set') def set_note_reminder(note_id: str): try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() note = _ensure_user_owns_note(db, user_id, note_id) if not note: return jsonify({'ok': False, 'error': 'Note not found'}), 404 payload = _json_object() if payload is None: return jsonify({'ok': False, 'error': 'invalid_payload'}), 400 client_tz = str(payload.get('tz') or 'Asia/Jerusalem') dt_utc = _parse_when_to_utc(payload, client_tz) if not dt_utc: return jsonify({'ok': False, 'error': 'Invalid time'}), 400 if dt_utc <= datetime.now(timezone.utc): return jsonify({'ok': False, 'error': 'Time must be in the future'}), 400 now_utc = datetime.now(timezone.utc) scope = _reminder_scope(user_id, note['_id']) # Fields to set on every update set_fields = { **scope, 'file_id': str(note.get('file_id', '')), # לפתק לוח אין file_id, ובלי השדה הזה ה-Service Worker # לא היה יודע לאן לפתוח את ההתראה. 'board_id': str(note.get('board_id', '') or ''), # שדות מחזור החיים מגיעים מהמודול, כדי שקבוע שמשתנה ישנה גם את הכתיבה. **armed_fields(dt_utc, now_utc), } # Upsert על המפתח: מסמך אחד לפתק, בכוונה. זו כוונה ולא אכיפה — ל-``user_note_idx`` אין # ``unique``, ושתי קביעות מקבילות יכולות לכתוב שני מסמכים (ולכן ``delete_many`` בביטול). try: db.note_reminders.update_one( scope, { '$set': set_fields, '$setOnInsert': {'created_at': now_utc}, }, upsert=True, ) except Exception: return _failed('set_note_reminder.save', error='Failed to save') # **הפתק עדיין קיים? בדיקה חוזרת אחרי הכתיבה.** ``_ensure_user_owns_note`` למעלה וה-upsert # הם check-then-act: ``delete_note`` שרץ ביניהם מוחק את הפתק ואת התזכורות שלו עוד לפני # שה-upsert כתב, והתזכורת שנכתבת אחריו נשארת יתומה. ``delete_note`` מוחק את הפתק **לפני** # התזכורות, ולכן הבדיקה כאן סוגרת את החלון: אם הניקוי שלו רץ לפני ה-upsert, הפתק כבר חסר # כשקוראים כאן, ומוחקים את מה שנכתב; ואם הוא רץ אחרי, הוא מחק את זה בעצמו. # **מה-primary במפורש** (``Collection.with_options``, pymongo 4.15.3, כמו # ``find_version_by_id`` ב-``database/repository.py``): משני שמפגר יכול לא לראות פתק שזה # עתה נוצר, ואז הניקוי היה מוחק תזכורת חיה. **וקריאה שנכשלה אינה "אין פתק"**: לא מוחקים, # התזכורת נשארת כמו שנכתבה, ונשארת עקבה בלוג. from pymongo import ReadPreference # ייבוא עצל, כמו ב-``database/repository.py`` note_gone = False try: note_gone = db.sticky_notes.with_options(read_preference=ReadPreference.PRIMARY).find_one( {'_id': note['_id'], 'user_id': user_id}, {'_id': 1} ) is None except PyMongoError: logger.warning( "sticky notes: could not recheck note %s after setting its reminder", note['_id'], exc_info=True ) if note_gone: try: db.note_reminders.delete_many(scope) except PyMongoError: return _failed('set_note_reminder.orphan_cleanup') return jsonify({'ok': False, 'error': 'Note not found'}), 404 try: emit_event('note_reminder_set', severity='info', user_id=user_id, note_id=scope['note_id']) except Exception: pass return jsonify({'ok': True, 'remind_at': dt_utc.isoformat()}) except Exception: return _failed('set_note_reminder') @sticky_notes_bp.route('/note/<note_id>/reminder', methods=['DELETE']) @require_auth @notes_rate_limit('note_reminder_delete', 60) @traced('sticky_notes.reminder_delete') def delete_note_reminder(note_id: str): try: user_id = int(session['user_id']) db = get_db() note = _ensure_user_owns_note(db, user_id, note_id) if not note: return jsonify({'ok': False, 'error': 'Note not found'}), 404 # ``delete_many``: ביטול התזכורת של הפתק מבטל את כולה, גם מסמך כפול משתי קביעות # מקבילות (ל-``user_note_idx`` אין ``unique``). ``delete_one`` השאיר את הכפול פעיל, והוא # היה נורה אחרי שהמשתמש ביטל. db.note_reminders.delete_many(_reminder_scope(user_id, note['_id'])) return jsonify({'ok': True}) except Exception: return _failed('delete_note_reminder') @sticky_notes_bp.route('/note/<note_id>/snooze', methods=['POST']) @require_auth @notes_rate_limit('note_reminder_snooze', 120) @traced('sticky_notes.reminder_snooze') def snooze_note_reminder(note_id: str): try: user_id = int(session['user_id']) db = get_db() payload = _json_object() if payload is None: return jsonify({'ok': False, 'error': 'invalid_payload'}), 400 # קלט חיצוני, ולכן בדיקת טיפוס לפני ההמרה ולא ``except`` אחריה: ``int()`` # על מחרוזת או רשימה זורק — וזה היה 500 עם traceback על טעות של הלקוח — # ועל ``True`` או ``3.9`` הוא ממיר בשקט (1, 3) ומקבע דחייה שאיש לא ביקש. # מספר שלם בלבד; ``bool`` הוא תת-טיפוס של ``int`` ולכן מוחרג במפורש. # חסר או ``null`` ← ברירת המחדל המתועדת, שעה. minutes = payload.get('minutes') if minutes is None: minutes = 60 if isinstance(minutes, bool) or not isinstance(minutes, int) or minutes < 1 or minutes > 24 * 60: return jsonify({'ok': False, 'error': 'Invalid minutes'}), 400 new_time = datetime.now(timezone.utc) + timedelta(minutes=minutes) # גם כאן הפילטר המלא: דחייה מחיה תזכורת **פעילה**, לא כזו שהמשתמש כבר # סגר. בלי התנאי, לחיצה על דחייה בהתראה ישנה הייתה מחזירה לחיים תזכורת # שנסגרה מזמן, בשקט. ומכיוון שהפילטר כבר דורש ``ack_at`` ריק, הכתיבה # אינה נוגעת בו — שדות הדחייה מגיעים מהמודול. r = db.note_reminders.update_one( dict( active_reminder_filter(), user_id=user_id, note_id=str(note_id), ), {'$set': snoozed_fields(new_time, datetime.now(timezone.utc))}, ) if getattr(r, 'matched_count', 0) <= 0: return jsonify({'ok': False, 'error': 'Reminder not found'}), 404 return jsonify({'ok': True, 'remind_at': new_time.isoformat()}) except Exception: return _failed('snooze_note_reminder') #: כשיש בועה על המסך השרת מבקש מהלקוח לחזור לכל היותר בעוד חמש דקות — המרווח #: הקבוע שהיה כאן לפני הדגימה לפי השרת, וזה שריענן גם ניקוי ממכשיר אחר וגם #: מונה שהשתנה. הערך יושב בשרת ולא בלקוח כדי שללקוח יישאר כלל אחד: "ישן כמה #: שהשרת אמר, בין הרצפה לתקרה". תזכורת נוספת שמבשילה מוקדם יותר גוברת עליו. BADGE_REFRESH_SECONDS = 5 * 60 @sticky_notes_bp.route('/reminders/summary', methods=['GET']) @require_auth @notes_rate_limit('note_reminders_summary', 300) @traced('sticky_notes.reminders_summary') def reminders_summary(): """Return minimal summary for persistent UI badge. Response: { ok, has_due: bool, count_due: int, next_in_seconds: int | null } **``next_in_seconds`` הוא מה שמחליף את הדגימה הקבועה.** עד כאן הלקוח דגם כל חמש דקות בלי קשר למצב, כי "כן/לא" היה כל מה שקיבל — 954 קריאות ביממה שכולן החזירו "אין". השרת הוא היחיד שיודע גם *מתי* התזכורת הבאה, ולכן הוא זה שאומר ללקוח מתי לחזור — גם כשיש בועה: אז התשובה היא לכל היותר ``BADGE_REFRESH_SECONDS``, כדי שבועה שנוקתה ממכשיר אחר ומונה שהשתנה ייראו תוך דקות ולא אחרי חצי שעה. אין תזכורת עתידית ואין בועה ← ``None``, והלקוח נרדם עד התקרה שלו (חצי שעה) — לא לנצח, כדי שתזכורת שתיקבע ממכשיר אחר עדיין תתגלה. **והערך יחסי, לא חותמת.** ``remind_at`` שנקרא מהמסד הוא מודע-אזור רק כל עוד הלקוח נבנה עם ``tz_aware`` — ומחרוזת ISO בלי offset נקראת ב-JavaScript כזמן **מקומי**, כלומר שלוש שעות סטייה בלי שגיאה. מספר שניות אין לו אזור זמן, והוא גם חסין לשעון לקוח שסוטה. """ try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() now = datetime.now(timezone.utc) base_filter = active_reminder_filter() base_filter['user_id'] = user_id due_filter = dict(base_filter, remind_at={'$lte': now}) # **שאילתה שנכשלה אינה "אין תזכורות".** כאן ישב ``except`` שהחזיר # ``count_due = 0``, והתשובה יצאה ``ok: true, has_due: false`` — # כלומר המשתמש קיבל "הכול נקי" על מסד שלא ענה. עכשיו החריגה עולה # ל-``except`` החיצוני ומוחזרת כ-500, והלקוח מבדיל בין "אין" לבין # "לא ידוע". זה גם מה שהופך את ``next_in_seconds`` לאמין: לקוח # שנרדם לחצי שעה על סמך כשל הוא גרוע מלקוח שדוגם יותר מדי. count_due = int(db.note_reminders.count_documents(due_filter)) has_due = count_due > 0 # מתי כדאי לשאול שוב — בשני המצבים. התזכורת העתידית הקרובה קובעת את # המועד; כשיש בועה, התשובה נחתכת ב-BADGE_REFRESH_SECONDS, כי בועה שנוקתה # ממכשיר אחר אינה שולחת שום אות, וחצי שעה של בועה ישנה היא בדיוק מה # שהדגימה לפי השרת לא נועדה לייצר. זו השאילתה היחידה שנשארה לצד הספירה: # היא שואלת על העתיד והספירה על ההווה, ולכן שתי התשובות אינן יכולות # לסתור זו את זו — ``has_due`` נגזר מהספירה בלבד. upcoming = db.note_reminders.find_one( dict(base_filter, remind_at={'$gt': now}), {'remind_at': 1}, sort=[('remind_at', 1)], ) next_in_seconds = _seconds_until(upcoming.get('remind_at') if upcoming else None, now) if has_due: next_in_seconds = ( BADGE_REFRESH_SECONDS if next_in_seconds is None else min(BADGE_REFRESH_SECONDS, next_in_seconds) ) return jsonify({ 'ok': True, 'has_due': has_due, 'count_due': count_due, 'next_in_seconds': next_in_seconds, }) except Exception: return _failed('reminders_summary') @sticky_notes_bp.route('/reminders/list', methods=['GET']) @require_auth @notes_rate_limit('note_reminders_list', 300) @traced('sticky_notes.reminders_list') def reminders_list(): """Return a list of due sticky‑note reminders for the current user. Response: .. code-block:: json { "ok": true, "items": [ { "note_id": "...", "file_id": "...", "preview": "...", "anchor_id": "h2-intro", "anchor_text": "Intro", "remind_at": "2026-09-20T09:00:00+00:00" } ], "count": 1 } ``remind_at`` הוא המועד שהפריט הזה נורה עליו; החלונית מחזירה אותו ב-``ack``, כדי שהאישור ייקשר למועד הזה ולא ל"איזו שהיא" תזכורת של הפתק. ``preview`` הוא השם שבו החלונית מציגה את הפתק — ``sticky_notes_target.note_label``, אותה פונקציה שממלאת את התראת הפוש (``push_api._reminder_label``) ואת הדשבורד: שם הפתק, ובלעדיו השורה הראשונה שלו. שם השדה נשאר ``preview`` מהתקופה שלפני שמות, כדי לא לשבור את החוזה עם הדף. """ try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() now = datetime.now(timezone.utc) # Pagination bounds try: limit_param = int(request.args.get('limit', 20)) except Exception: limit_param = 20 limit_param = max(1, min(50, limit_param)) # בלי ``try`` סביב השאילתה — בכוונה. ``get_db()`` מחזיר ``None`` # בחלון הצינון שאחרי כשל התחברות, וה-``AttributeError`` שנובע מזה # חייב להגיע ל-handler החיצוני ולענות 500. הגרסה הקודמת בלעה אותו # ל-``cursor = []`` וענתה ``ok:true, count:0`` — "אין תזכורות" על # מסד שלא נקרא. ``reminders_summary`` עונה 500 על אותו מצב, ומסלולי # הבועה חייבים חוזה אחד: אחרת הבועה אומרת "3" והחלונית "0". cursor = ( db.note_reminders .find(dict( active_reminder_filter(), user_id=user_id, remind_at={'$lte': now}, )) .sort('remind_at', 1) .limit(limit_param) ) reminders = list(cursor) items = [] for r in reminders: try: note_id = str(r.get('note_id') or '') file_id = str(r.get('file_id') or '') board_id = str(r.get('board_id') or '') preview = '' anchor_id = '' anchor_text = '' note_doc = None # Try ObjectId first for performance/accuracy try: oid = ObjectId(note_id) except Exception: oid = None if oid is not None: try: note_doc = db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}) except Exception: note_doc = None if note_doc is None and note_id: try: note_doc = db.sticky_notes.find_one({'_id': note_id, 'user_id': user_id}) except Exception: note_doc = None if isinstance(note_doc, dict): # המילים כמו שהן שמורות — בלי פענוח (עד אוקטובר 2026 עבר כאן ``html.unescape``). preview = note_label(note_doc) anchor_id = str(note_doc.get('anchor_id') or '') anchor_text = str(note_doc.get('anchor_text') or '') # Prefer file_id/board_id from note if missing on reminder # (defensive — תזכורות ישנות נכתבו לפני שהשדה נוסף) if not file_id: try: file_id = str(note_doc.get('file_id') or '') except Exception: pass if not board_id: try: board_id = str(note_doc.get('board_id') or '') except Exception: pass else: preview = '' remind_at = r.get('remind_at') items.append({ 'note_id': note_id, 'file_id': file_id, 'board_id': board_id, 'preview': preview, 'anchor_id': anchor_id, 'anchor_text': anchor_text, 'remind_at': remind_at.isoformat() if isinstance(remind_at, datetime) else '', }) except Exception: # Skip malformed entries rather than failing the entire list continue return jsonify({'ok': True, 'items': items, 'count': len(items)}) except Exception: return _failed('reminders_list') @sticky_notes_bp.route('/reminders/ack', methods=['POST']) @require_auth @notes_rate_limit('note_reminders_ack', 300) @traced('sticky_notes.reminders_ack') def reminders_ack(): """Mark current due reminder as acknowledged (user opened it). **סוגר את שני שדות המצב יחד.** עד כאן נכתב ``ack_at`` בלבד, ו-``status`` נשאר ``pending`` לנצח — כך שכרטיס הדשבורד, שסופר לפי ``status``, דיווח תזכורות "בהמתנה" שאיש לא המתין להן. השדות מגיעים מ- :func:`note_reminder_state.acknowledge_fields`, שמחזירה את שניהם או אף אחד, ומונגו מחילה אותם ב-``$set`` יחיד. **ונקשר למועד שההתראה נשאה.** בלי ``remind_at`` בגוף, האישור סגר "איזו שהיא" תזכורת של הפתק; וכשהפתק נדרך מחדש אחרי שההתראה נורתה — בדיוק מה שעושים כשתזכורת מגיעה ברגע לא נוח — התראה ישנה במגש סגרה את התזכורת של מחר, כי ``set_note_reminder`` עושה upsert על אותו מסמך ויש תמיד שורה אחת לפגוע בה. עם המועד, הפילטר תופס רק את המסמך שעדיין נושא אותו: מסמך שנדרך מחדש או נדחה מאז עונה 404, ונשאר פעיל. לקוח שאינו שולח מועד (SW ישן במטמון, התראה שהוצגה לפני השדה) מאשר בלי קשירה — ההתנהגות של קודם. """ try: user_id = int(session['user_id']) db = get_db() payload = _json_object() if payload is None: return jsonify({'ok': False, 'error': 'invalid_payload'}), 400 note_id = str(payload.get('note_id') or '').strip() if not note_id: return jsonify({'ok': False, 'error': 'note_id required'}), 400 # קלט חיצוני: מחרוזת ISO או כלום. מחרוזת שאינה נקראת היא 400 ולא # "בלי קשירה" — אחרת באג בלקוח היה סוגר תזכורת שרירותית של הפתק. try: occurrence = parse_remind_at(payload.get('remind_at')) except ValueError: return jsonify({'ok': False, 'error': 'invalid_remind_at'}), 400 ack_filter = {'user_id': user_id, 'note_id': note_id, 'ack_at': None} if occurrence is not None: ack_filter['remind_at'] = occurrence r = db.note_reminders.update_one( ack_filter, {'$set': acknowledge_fields(datetime.now(timezone.utc))} ) if getattr(r, 'matched_count', 0) <= 0: return jsonify({'ok': False, 'error': 'Not found'}), 404 return jsonify({'ok': True}) except Exception: return _failed('reminders_ack') @sticky_notes_bp.route('/<file_id>', methods=['POST']) @require_auth @notes_rate_limit('create', 60) @traced("sticky_notes.create") def create_note(file_id: str): """Create a new sticky note for a file.""" try: from sticky_notes_target import NoteQuotaExceeded, NoteQuotaUnknown, check_note_quota _ensure_indexes() user_id = int(session['user_id']) db = get_db() scope_id, scope_file_name, _ = _resolve_scope(db, user_id, file_id) data = request.get_json(silent=True) or {} try: content = _note_content_from_request(data) except _ContentTooLong: return jsonify({'ok': False, 'error': 'content_too_long', 'max': MAX_NOTE_CHARS}), 400 except _InvalidContentB64: return jsonify({'ok': False, 'error': 'invalid_content_b64'}), 400 except _InvalidContent: return jsonify({'ok': False, 'error': 'invalid_content'}), 400 title = normalize_note_title(data.get('title')) pos = data.get('position') or {} size = data.get('size') or {} color = resolve_note_color(data.get('color')) is_minimized = bool(data.get('is_minimized', False)) line_start = data.get('line_start') line_end = data.get('line_end') anchor_id = (data.get('anchor_id') or '').strip()[:256] anchor_text = (data.get('anchor_text') or '').strip()[:256] # תקרת הפתקים למשתמש חלה על כל הפתקים, לא רק על אלה שבלוחות. # היא מתועדת מזה זמן ולא נאכפה בשום מקום; אכיפה רק במסלול הלוח # הייתה הופכת את התיעוד לנכון-למחצה. try: check_note_quota( _count_or_none(db.sticky_notes, active_notes_filter(user_id)), MAX_NOTES_PER_USER, is_admin=_current_user_is_admin(), ) except NoteQuotaUnknown: return jsonify({'ok': False, 'error': 'note_quota_unknown'}), 409 except NoteQuotaExceeded: return jsonify({'ok': False, 'error': 'note_quota_exceeded'}), 409 # זמן אחד ליצירה ולעדכון, ברזולוציה של המסד — הלקוח מקבל אותו כאסימון (``_stored_now``). created_at = _stored_now() doc = { 'user_id': user_id, 'file_id': str(file_id), 'content': content, # ריק ← השדה כלל אינו נכתב, כדי שלא ייכנס לאינדקס הייחודי **({'title': title} if title else {}), 'position_x': _coerce_int(pos.get('x'), 100, 0, 100000), 'position_y': _coerce_int(pos.get('y'), 100, 0, 1000000), 'width': _coerce_int(size.get('width'), 250, 120, 1200), 'height': _coerce_int(size.get('height'), 200, 80, 1200), 'color': color, 'is_minimized': bool(is_minimized), 'line_start': int(line_start) if isinstance(line_start, int) else None, 'line_end': int(line_end) if isinstance(line_end, int) else None, 'anchor_id': anchor_id or None, 'anchor_text': anchor_text or None, 'created_at': created_at, 'updated_at': created_at, } if scope_id: doc['scope_id'] = scope_id if scope_file_name: doc['file_name'] = scope_file_name try: res = db.sticky_notes.insert_one(doc) except DuplicateKeyError: # שם תפוס בלוח הזה — התנגשות, לא תקלה return jsonify({'ok': False, 'error': 'duplicate_title', 'max': MAX_NOTE_TITLE}), 409 nid = str(getattr(res, 'inserted_id', '')) try: emit_event("sticky_note_created", severity="info", user_id=int(user_id), file_id=str(file_id)) except Exception: pass resp = jsonify({'ok': True, 'id': nid, 'updated_at': _updated_at_iso(created_at)}) try: resp.headers['Cache-Control'] = 'no-store' except Exception: pass return resp, 201 except Exception as e: try: emit_event("sticky_notes_create_error", severity="anomaly", file_id=str(file_id), error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to create note'}), 500 def _update_answer(stamp: Any) -> Any: """תשובת ``ok`` של ``update_note``, עם :func:`_updated_at_iso`.""" return _no_store(jsonify({'ok': True, 'updated_at': _updated_at_iso(stamp)})) def _owned_notes_filter(user_id: int) -> Dict[str, Any]: """כל פתק של המשתמש, בכל משטח — המסנן של ``get_note``.""" return {'user_id': user_id} @sticky_notes_bp.route('/note/<note_id>', methods=['GET']) @require_auth @notes_rate_limit('note_get', 180) @traced("sticky_notes.note_get") def get_note(note_id: str): """פתק אחד, מלא, עם תקצירי השרשורים שלו — **מה שהלקוח מושך כשצריך את המצב הטרי של פתק**. שלושה צרכנים ב-``sticky-notes.js``: הרענון בכניסה לעריכה, משיכת פתק שהדגימה (``?versions=1``) מצאה שהשתנה או שנוסף, ובדיקה ישירה של פתק שנעלם מהדגימה — לפני שהוא יורד מהמסך. **בלי מסנן משטח**: הלקוח מחליט אם הפתק עדיין שלו לפי השדות שבו (``archived_at``, ``board_id``, הנעיצה), ולכן כל פתק של המשתמש מוחזר, ופתק שנמחק או של משתמש אחר עונה ``404 note_not_found``. הזרימה — ``_one_note_in_scope``, כמו הפתק הבודד בארכיון ובעמוד הקבצים. """ return _one_note_in_scope(note_id, _owned_notes_filter, 'get_note', 'Failed to load note') @sticky_notes_bp.route('/note/<note_id>', methods=['PUT']) @require_auth @notes_rate_limit('update', 300) @traced("sticky_notes.update") def update_note(note_id: str): """Update existing note; only owner can update.""" try: user_id = int(session['user_id']) data = request.get_json(silent=True) or {} updates: Dict[str, Any] = {} # Prefer content_b64 if provided (avoid "on-the-wire" clear text) if 'content_b64' in data or 'content' in data: try: updates['content'] = _note_content_from_request(data) except _ContentTooLong: return jsonify({'ok': False, 'error': 'content_too_long', 'max': MAX_NOTE_CHARS}), 400 except _InvalidContentB64: return jsonify({'ok': False, 'error': 'invalid_content_b64'}), 400 except _InvalidContent: return jsonify({'ok': False, 'error': 'invalid_content'}), 400 if 'position' in data and isinstance(data.get('position'), dict): pos = data['position'] updates['position_x'] = _coerce_int(pos.get('x'), 100, 0, 100000) updates['position_y'] = _coerce_int(pos.get('y'), 100, 0, 1000000) if 'size' in data and isinstance(data.get('size'), dict): size = data['size'] updates['width'] = _coerce_int(size.get('width'), 250, 120, 1200) updates['height'] = _coerce_int(size.get('height'), 200, 80, 1200) if 'color' in data: # ``default=None`` ← ערך פסול **נשמט** ואינו דורס את הצבע # הקיים בברירת מחדל. # # **ובכוונה שונה מ-``mcp_server/handlers``, שדוחה בשגיאה.** # הבורר כאן שולח רק מזהים שעברו בדיקה מול הפלטה בצד הלקוח, # ולכן ערך פסול אינו קלט משתמש אלא באג אצלנו; שם הכותב הוא # סוכן שכותב מה שהוא רוצה, ו-``ok`` על צבע שלא הוחל מגיע # למשתמש כדיווח שגוי. ההסבר המלא ב-``resolve_note_color``. color = resolve_note_color(data.get('color'), default=None) if color: updates['color'] = color if 'is_minimized' in data: updates['is_minimized'] = bool(data.get('is_minimized')) if 'line_start' in data: try: updates['line_start'] = int(data.get('line_start')) except Exception: updates['line_start'] = None if 'line_end' in data: try: updates['line_end'] = int(data.get('line_end')) except Exception: updates['line_end'] = None if 'anchor_id' in data: aid = (data.get('anchor_id') or '').strip()[:256] updates['anchor_id'] = aid or None if 'anchor_text' in data: atx = (data.get('anchor_text') or '').strip()[:256] updates['anchor_text'] = atx or None # שם ריק **מוחק** את השדה ולא שומר ``""``. ראו normalize_note_title. unset_fields: Dict[str, Any] = {} if 'title' in data: new_title = normalize_note_title(data.get('title')) if new_title: updates['title'] = new_title else: unset_fields['title'] = '' # ``mode`` מאומת כאן ומוחל רק אחרי טעינת הפתק — הבדיקה תלויה # ב-``board_id`` שלו, שעדיין לא ידוע בשלב הזה. wants_mode = 'mode' in data if not updates and not wants_mode and not unset_fields: return jsonify({'ok': False, 'error': 'No fields to update'}), 400 db = get_db() # Validate ObjectId early and return 400 on malformed input try: oid = ObjectId(note_id) except InvalidId: return jsonify({'ok': False, 'error': 'Invalid note_id'}), 400 note = db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}) if not note: return jsonify({'ok': False, 'error': 'Note not found'}), 404 if wants_mode: mode_value, mode_error = _mode_update(data.get('mode'), note) if mode_error: return jsonify({'ok': False, 'error': mode_error}), 400 updates['mode'] = mode_value # פתק לוח וּפתק ריפו אינם נושאים scope_id ולעולם לא יישאו — ובלי # השומר הזה כל עדכון שלהם היה מריץ _resolve_scope, כלומר קריאה # ל-code_snippets עם file_id ריק רק כדי לגלות שאין קובץ. if not note.get('scope_id') and not note.get('board_id') and not note.get('repo_path'): scope_id, scope_file_name, _ = _resolve_scope(db, user_id, note.get('file_id')) if scope_id: updates['scope_id'] = scope_id if scope_file_name and 'file_name' not in updates: updates['file_name'] = scope_file_name # מניעת דריסה בין מכשירים: אם התקבלה prev_updated_at ונמוכה מהעדכנית – החזר 409 try: prev_updated_at = data.get('prev_updated_at') if prev_updated_at: try: prev_dt = datetime.fromisoformat(str(prev_updated_at)) except Exception: prev_dt = None if prev_dt and isinstance(note.get('updated_at'), datetime) and prev_dt < note['updated_at']: return jsonify({'ok': False, 'error': 'Conflict', 'updated_at': _updated_at_iso(note['updated_at'])}), 409 except Exception: pass # ``updated_at`` זז רק כשהתוכן או השם באמת משתנים (``drop_unchanged_edits``): מזעור, הזזה, # צבע או מצב אינם עריכה, ופתק שרק נפתח ממזעור לא קופץ לראש "פתקים אחרונים". edit = drop_unchanged_edits(note, updates, unset_fields) updates, unset_fields = edit.set_fields, edit.unset_fields if edit.edited: updates['updated_at'] = _stored_now() if not updates and not unset_fields: # שום דבר לא משתנה — למשל אותו תוכן שנשלח שוב. אין כתיבה, וזמן העדכון הוא זה ששמור. return _update_answer(note.get('updated_at')) ops: Dict[str, Any] = {'$set': updates} if updates else {} if unset_fields: ops['$unset'] = unset_fields # **בדיקת הגיבוי נבחרת לפי סוג היעד.** ``_title_conflict`` יוצא # מיד כשאין ``board_id`` — ולפתק ריפו אין — ולכן כשאינדקס הריפו לא # אומת (``_REPO_TITLE_INDEX_OK`` כבוי) לא הייתה כאן שום אכיפה: אף # אחד לא בדק, המסד לא אכף, ושני פתקים על אותו קובץ קיבלו את אותו # שם. מסלול היצירה כבר מפצל כך; העדכון היה החריג. if 'title' in updates and _duplicate_title_for_note( db, user_id, note, updates['title'], exclude_id=oid ): return jsonify({'ok': False, 'error': 'duplicate_title', 'max': MAX_NOTE_TITLE}), 409 try: db.sticky_notes.update_one({'_id': oid, 'user_id': user_id}, ops) except DuplicateKeyError: # שם תפוס בלוח הזה. 409 ולא 500 — זו התנגשות, לא תקלה. return jsonify({'ok': False, 'error': 'duplicate_title', 'max': MAX_NOTE_TITLE}), 409 try: emit_event("sticky_note_updated", severity="info", user_id=int(user_id), note_id=str(note_id)) except Exception: pass return _update_answer(updates.get('updated_at') or note.get('updated_at')) except Exception as e: try: emit_event("sticky_notes_update_error", severity="anomaly", note_id=str(note_id), error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to update note'}), 500 @sticky_notes_bp.route('/note/<note_id>', methods=['DELETE']) @require_auth @notes_rate_limit('delete', 120) @traced("sticky_notes.delete") def delete_note(note_id: str): """Delete a note; only owner can delete.""" try: user_id = int(session['user_id']) db = get_db() try: oid = ObjectId(note_id) except InvalidId: return jsonify({'ok': False, 'error': 'Invalid note_id'}), 400 res = db.sticky_notes.delete_one({'_id': oid, 'user_id': user_id}) if int(getattr(res, 'deleted_count', 0) or 0) <= 0: return jsonify({'ok': False, 'error': 'Note not found'}), 404 # **השרשורים — רק עכשיו, אחרי שהפתק באמת נמחק.** בסדר ההפוך, מחיקה שנכשלה (פתק של # משתמש אחר, מזהה שכבר נמחק) הייתה מוחקת שרשורים של פתק שנשאר. ``str(oid)`` הוא # ה-``note_id`` הקנוני שהשרשורים נשמרים תחתיו. כשל כאן אינו מחזיר את הפתק: הוא כבר # נמחק, ושרשור יתום אינו מוצג בשום מקום — כל קורא מגיע לשרשורים דרך פתק קיים (ראו # בראש ``note_threads``). לכן לוג, בלי גופים, ולא כשל של הבקשה. threads_deleted: Optional[int] = None try: threads_deleted = nt.delete_note_threads( db[nt.NOTE_THREADS_COLLECTION], user_id=user_id, note_id=str(oid) ) except PyMongoError: logger.warning("sticky notes: deleting the threads of deleted note %s failed", oid, exc_info=True) # **והתזכורות — באותו סדר ומאותה סיבה, אבל כאן יתום כן נראה.** עד נובמבר 2026 המחיקה לא # נגעה ב-``note_reminders``, והתזכורת של פתק שנמחק נשארה פעילה: ``_build_push_card`` # בדשבורד בחר בה כ"התזכורת הבאה", לא מצא את הפתק וכתב "אין תזמון עתידי" גם כשתזכורת # אמיתית חיכתה אחריה; ``push_api`` שלח עליה התראה בלי שם, ו-``reminders_list`` הציג אותה # בפעמון בלי שם. ``delete_many`` ולא ``delete_one``: ``set_note_reminder`` עושה upsert על # ``(user_id, note_id)``, ולאינדקס ``user_note_idx`` אין ``unique``, כך ששתי קביעות מקבילות # יכולות להשאיר שני מסמכים לאותו פתק. כשל אינו מחזיר את הפתק (הוא כבר נמחק), ולכן לוג ולא # כשל של הבקשה — כמו בשרשורים. # ``set_note_reminder`` בודק שוב אחרי ה-upsert שהפתק קיים, ולכן גם תזכורת שנכתבת ממכשיר # אחר בדיוק ברגע הזה לא נשארת אחרי שהניקוי כאן רץ — אלא אם הבדיקה החוזרת שם נכשלה, ואז # נשארת שם עקבה בלוג. reminders_deleted: Optional[int] = None try: reminders_deleted = int( db.note_reminders.delete_many(_reminder_scope(user_id, oid)).deleted_count ) except PyMongoError: logger.warning("sticky notes: deleting the reminders of deleted note %s failed", oid, exc_info=True) try: emit_event( "sticky_note_deleted", severity="info", user_id=int(user_id), note_id=str(note_id), threads_deleted=threads_deleted, reminders_deleted=reminders_deleted, ) except Exception: pass resp = jsonify({'ok': True}) try: resp.headers['Cache-Control'] = 'no-store' except Exception: pass return resp except Exception as e: try: emit_event("sticky_notes_delete_error", severity="anomaly", note_id=str(note_id), error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to delete note'}), 500 @sticky_notes_bp.route('/batch', methods=['POST']) @require_auth @notes_rate_limit('batch', 300) @traced("sticky_notes.batch") def batch_update_notes(): """Batch update multiple notes in one request. Body format (JSON): .. code-block:: json { "updates": [ { "id": "...", "content": "...", "position": {"x": 120, "y": 240}, "size": {"width": 260, "height": 200}, "color": "yellow_light", "is_minimized": false, "line_start": 10, "line_end": null, "anchor_id": "h2-intro", "anchor_text": "Intro", "mode": "surface", "prev_updated_at": "2024-01-01T00:00:00+00:00" } ] } Response JSON contains ``results`` with per-item status, e.g. 200/409. """ try: user_id = int(session['user_id']) db = get_db() payload = request.get_json(silent=True) or {} updates_input = payload.get('updates') if isinstance(updates_input, list): items = updates_input elif isinstance(payload, list): items = payload else: items = [] if not items: return jsonify({'ok': False, 'error': 'No updates provided'}), 400 results: List[Dict[str, Any]] = [] for item in items: try: note_id = str((item or {}).get('id') or '').strip() if not note_id: results.append({'id': None, 'ok': False, 'status': 400, 'error': 'Missing id'}) continue try: oid = ObjectId(note_id) except InvalidId: results.append({'id': note_id, 'ok': False, 'status': 400, 'error': 'Invalid id'}) continue note = db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}) if not note: results.append({'id': note_id, 'ok': False, 'status': 404, 'error': 'Not found'}) continue fragment = item updates: Dict[str, Any] = {} if 'content_b64' in fragment or 'content' in fragment: try: updates['content'] = _note_content_from_request(fragment) except _ContentTooLong: results.append({'id': note_id, 'ok': False, 'status': 400, 'error': 'content_too_long', 'max': MAX_NOTE_CHARS}) continue except _InvalidContentB64: results.append({'id': note_id, 'ok': False, 'status': 400, 'error': 'invalid_content_b64'}) continue except _InvalidContent: results.append({'id': note_id, 'ok': False, 'status': 400, 'error': 'invalid_content'}) continue if 'position' in fragment and isinstance(fragment.get('position'), dict): pos = fragment['position'] updates['position_x'] = _coerce_int(pos.get('x'), 100, 0, 100000) updates['position_y'] = _coerce_int(pos.get('y'), 100, 0, 1000000) if 'size' in fragment and isinstance(fragment.get('size'), dict): size = fragment['size'] updates['width'] = _coerce_int(size.get('width'), 250, 120, 1200) updates['height'] = _coerce_int(size.get('height'), 200, 80, 1200) if 'color' in fragment: col = resolve_note_color(fragment.get('color'), default=None) if col: updates['color'] = col if 'is_minimized' in fragment: updates['is_minimized'] = bool(fragment.get('is_minimized')) if 'line_start' in fragment: try: updates['line_start'] = int(fragment.get('line_start')) except Exception: updates['line_start'] = None if 'line_end' in fragment: try: updates['line_end'] = int(fragment.get('line_end')) except Exception: updates['line_end'] = None if 'anchor_id' in fragment: aid = (fragment.get('anchor_id') or '').strip()[:256] updates['anchor_id'] = aid or None if 'anchor_text' in fragment: atx = (fragment.get('anchor_text') or '').strip()[:256] updates['anchor_text'] = atx or None if 'mode' in fragment: mode_value, mode_error = _mode_update(fragment.get('mode'), note) if mode_error: results.append({'id': note_id, 'ok': False, 'status': 400, 'error': mode_error}) continue updates['mode'] = mode_value # ``title`` חסר כאן עד היום, וזו הייתה **אבידת כתיבה שקטה**. # # הלקוח שולח שם דרך ``_queueSave``, וה-debounce מנקז אותו # לכאן — לא ל-PUT הבודד, שהוא רק פולבק. השדה נשמט מה- # allowlist, הראוט החזיר ``ok: True, status: 200``, הלקוח # ניקה את התור, והשם נעלם בלי שום חיווי. נמדד מול הראוט: # ``title`` במסד נשאר "ישן" אחרי בקשה ששלחה "שם חדש". # אותה סמנטיקה כמו ב-PUT הבודד: ריק ← מחיקת השדה. unset_fields: Dict[str, Any] = {} if 'title' in fragment: new_title = normalize_note_title(fragment.get('title')) if new_title: updates['title'] = new_title else: unset_fields['title'] = '' # conflict detection similar to single update try: prev_updated_at = fragment.get('prev_updated_at') if prev_updated_at: try: prev_dt = datetime.fromisoformat(str(prev_updated_at)) except Exception: prev_dt = None if prev_dt and isinstance(note.get('updated_at'), datetime) and prev_dt < note['updated_at']: results.append({'id': note_id, 'ok': False, 'status': 409, 'error': 'Conflict', 'updated_at': _updated_at_iso(note['updated_at'])}) continue # stamp scope if missing — אך לא לפתק לוח, שאין לו # scope ולעולם לא יהיה. ראו את השומר המקביל ב-update_note. if not note.get('scope_id') and not note.get('board_id'): scope_id, scope_file_name, _ = _resolve_scope(db, user_id, note.get('file_id')) if scope_id: updates['scope_id'] = scope_id if scope_file_name and 'file_name' not in updates: updates['file_name'] = scope_file_name except Exception: pass # אותו כלל של ``update_note``: ``updated_at`` זז רק כשהתוכן או השם באמת משתנים. edit = drop_unchanged_edits(note, updates, unset_fields) updates, unset_fields = edit.set_fields, edit.unset_fields if edit.edited: updates['updated_at'] = _stored_now() if not updates and not unset_fields: results.append({'id': note_id, 'ok': True, 'status': 200, 'updated_at': _updated_at_iso(note.get('updated_at'))}) continue ops: Dict[str, Any] = {'$set': updates} if updates else {} if unset_fields: ops['$unset'] = unset_fields if 'title' in updates and _duplicate_title_for_note( db, user_id, note, updates['title'], exclude_id=oid ): results.append({'id': note_id, 'ok': False, 'status': 409, 'error': 'duplicate_title', 'max': MAX_NOTE_TITLE}) continue try: db.sticky_notes.update_one({'_id': oid, 'user_id': user_id}, ops) except DuplicateKeyError: # שם תפוס — 409 עם הקוד הספציפי, ולא 500 גנרי. הלקוח # מבחין לפי ``error`` בין זה לבין התנגשות גרסה, ורק # ההבחנה הזו מונעת ממנו לנסות שוב לנצח. results.append({'id': note_id, 'ok': False, 'status': 409, 'error': 'duplicate_title', 'max': MAX_NOTE_TITLE}) continue results.append({'id': note_id, 'ok': True, 'status': 200, 'updated_at': _updated_at_iso(updates.get('updated_at') or note.get('updated_at'))}) except Exception as e: try: emit_event("sticky_notes_batch_item_error", severity="anomaly", error=str(e)) except Exception: pass nid = None try: nid = str((item or {}).get('id') or '') except Exception: nid = None results.append({'id': nid, 'ok': False, 'status': 500, 'error': 'Failed'}) resp = jsonify({'ok': True, 'results': results}) try: resp.headers['Cache-Control'] = 'no-store' except Exception: pass return resp except Exception as e: try: emit_event("sticky_notes_batch_error", severity="anomaly", error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to process batch'}), 500 # --- Archive --- # # הארכיון הוא **יעד רביעי** (``archived_at`` ב-``sticky_notes_target``), ולא דגל על פתק # שנשאר על הלוח: ההעברה מוחקת את שדות היעד הקודם, ולכן הפתק יוצא מכל רשימה של לוח, # קובץ או ריפו מעצמו, ושום ראוט קיים לא צריך סינון חדש. עריכה, מחיקה, תזכורות ושרשורים # מזהים פתק לפי ``_id + user_id`` בלבד, ולכן הם עובדים על פתק בארכיון כמו שהם. # # שלושה ראוטים: ההעברה, רשימת הכרטיסים לעמוד הארכיון, ופתק אחד מלא — כי הרשימה אינה # נושאת את גוף הפתקים (Smart Projection), והוא נשלף רק כשפותחים כרטיס. #: מה כרטיס בעמוד הארכיון צריך — ותו לא. ``content`` אינו כאן בכוונה: עד #: :data:`MAX_ARCHIVED_NOTES_PER_USER` פתקים, כל אחד עד :data:`MAX_NOTE_CHARS` תווים. _ARCHIVE_CARD_PROJECTION = {'title': 1, 'color': 1, 'archived_at': 1} def _as_archive_card(doc: Dict[str, Any]) -> Dict[str, Any]: """כרטיס אחד ברשת הארכיון. נבנה מרשימה מפורשת של שדות, לא מהמסמך כולו.""" return { 'id': str(doc.get('_id')), 'title': str(doc.get('title', '') or ''), # אותו חוזה צבע כמו ``_as_note_response``: ``color`` תמיד ``hex`` חוקי. 'color': note_color_hex(doc.get('color')), 'color_id': note_color_id(doc.get('color')), 'archived_at': _iso_utc(doc.get('archived_at')), } @sticky_notes_bp.route('/note/<note_id>/archive', methods=['POST']) @require_auth @notes_rate_limit('note_archive', 60) @traced('sticky_notes.archive') def archive_note(note_id: str): """מעביר פתק לארכיון — מכל יעד, ובלי דרך חזרה ליעד הקודם. גוף אופציונלי: ``{"title": "..."}`` — השם שהמשתמש אישר בחלון. בלעדיו נשאר השם הקיים, ופתק בלי שם אינו עובר (``resolve_archive_title``): הארכיון מנווט לפי שם. הסדר, וכל שלב בו מגן על משהו: 1. הפתק קיים ושייך למשתמש — אחרת ``404 note_not_found``. 2. **כבר בארכיון** ← ``200`` עם ``already_archived``, בלי כתיבה. לחיצה כפולה, או מכשיר שני שעוד מציג את הפתק על הלוח, אינם שגיאה. 3. השם, ואחריו תקרת הארכיון (``MAX_ARCHIVED_NOTES_PER_USER``, אדמין פטור). ספירה שנכשלה נדחית (``check_note_quota``), כמו בכל תקרה אחרת. 4. **כתיבה אחת מותנית (CAS):** ``find_one_and_update`` שהפילטר שלו דורש שהפתק עדיין אינו בארכיון (``active_notes_filter``). שתי העברות מקבילות — רק אחת כותבת. ``None`` מהמסד אינו הצלחה (K11): קוראים שוב ומסווגים — נמחק בינתיים, או הועבר בבקשה המקבילה. 5. **השרשורים הפתוחים נסגרים רק אחרי שההעברה נכתבה** (``nt.resolve_open_threads``). כשל שם אינו מבטל את ההעברה, שכבר קרתה: ``threads_resolved: null`` אומר ללקוח שהשרשורים לא נסגרו, והכשל נרשם בלוג. התזכורת אינה נוגעת: היא נשארת פעילה. התשובה נבנית מהמסמך שהכתיבה **הזו** השאירה (``ReturnDocument.AFTER``), לא ממה שביקשו. """ try: from pymongo import ReturnDocument from sticky_notes_target import ( NoteQuotaExceeded, NoteQuotaUnknown, check_note_quota, note_target_kind, ) _ensure_indexes() user_id = int(session['user_id']) payload = _json_object() if payload is None: return _no_store(jsonify({'ok': False, 'error': 'invalid_payload'})), 400 try: oid = ObjectId(str(note_id)) except InvalidId: return _no_store(jsonify({'ok': False, 'error': 'invalid_note_id'})), 400 db = get_db() note = db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}, {'title': 1, 'archived_at': 1}) if not note: return _no_store(jsonify({'ok': False, 'error': 'note_not_found'})), 404 if note_target_kind(note) == 'archive': return _no_store(jsonify({'ok': True, 'already_archived': True, 'threads_resolved': None})) title, title_error = resolve_archive_title( payload.get('title'), note.get('title'), requested_given='title' in payload ) if title_error: body: Dict[str, Any] = {'ok': False, 'error': title_error} if title_error == 'title_too_long': body['max'] = MAX_NOTE_TITLE return _no_store(jsonify(body)), 400 try: check_note_quota( _count_or_none(db.sticky_notes, archived_notes_filter(user_id)), MAX_ARCHIVED_NOTES_PER_USER, is_admin=_current_user_is_admin(), ) except NoteQuotaUnknown: return _no_store(jsonify({'ok': False, 'error': 'note_quota_unknown'})), 409 except NoteQuotaExceeded: return _no_store(jsonify({ 'ok': False, 'error': 'archive_quota_exceeded', 'max': MAX_ARCHIVED_NOTES_PER_USER, })), 409 now = datetime.now(timezone.utc) stored = db.sticky_notes.find_one_and_update( {'_id': oid, **active_notes_filter(user_id)}, archive_note_update(archived_at=now, title=title), return_document=ReturnDocument.AFTER, ) if stored is None: current = db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}, {'archived_at': 1}) if current is None: return _no_store(jsonify({'ok': False, 'error': 'note_not_found'})), 404 if note_target_kind(current) == 'archive': return _no_store(jsonify({'ok': True, 'already_archived': True, 'threads_resolved': None})) # הפילטר לא תפס, והפתק קיים ואינו בארכיון: ``archived_at`` שאינו ``null`` ואינו # תאריך. אף כותב אינו מייצר ערך כזה, ולכן זה נתון פגום ולא מרוץ — והתשובה # אומרת שההעברה לא נכתבה, במקום לדווח הצלחה. logger.error("sticky notes: archiving %s matched nothing although the note exists", oid) return _no_store(jsonify({'ok': False, 'error': 'archive_not_applied'})), 409 threads_resolved: Optional[int] = None try: threads_resolved = nt.resolve_open_threads( db[nt.NOTE_THREADS_COLLECTION], user_id=user_id, note_id=str(oid), author=nt.user_author(), now=now, ) except PyMongoError: logger.warning("sticky notes: resolving the open threads of archived note %s failed", oid, exc_info=True) try: emit_event( "sticky_note_archived", severity="info", user_id=int(user_id), note_id=str(oid), threads_resolved=threads_resolved, ) except Exception: # ההעברה כבר נכתבה: אירוע שלא יצא אינו הופך אותה ל-500, שהלקוח היה מציג ככישלון. logger.warning("sticky notes: emitting sticky_note_archived for %s failed", oid, exc_info=True) return _no_store(jsonify({ 'ok': True, 'already_archived': False, 'note': _as_note_response(stored), 'threads_resolved': threads_resolved, })) except Exception: return _failed('archive_note', 'Failed to archive note') @sticky_notes_bp.route('/archive', methods=['GET']) @require_auth @notes_rate_limit('archive_list', 180) @traced('sticky_notes.archive_list') def list_archived_notes(): """כרטיסי עמוד הארכיון — מהחדש לישן לפי זמן ההעברה, **בלי גוף הפתקים**. ``max`` הוא התקרה שחלה על המשתמש, או ``null`` לאדמין, שפטור ממנה. שאילתה שנכשלה עונה 500 ולא רשימה ריקה: העמוד אומר "לא הצלחתי לטעון", ולא "הארכיון ריק". **בלי ``limit``:** התשובה היא הרשת כולה, ו-``limit`` בלי דפדוף היה מסתיר מאדמין (שפטור מהתקרה) את הפתקים הישנים בלי שום סימן. העבודה פרופורציונלית לתשובה בדרך אחרת: שלושה שדות בלבד, בסדר של האינדקס ובלי מיון בזיכרון (נמדד ב-explain, ``tests/test_note_archive_mongo.py``), ולמשתמש שאינו אדמין התקרה חוסמת את הרשימה — כמו ברשימות הלוח, שגם בהן אדמין פטור. **לא ``GET /<file_id>``.** הקטע ``archive`` סטטי, ו-Werkzeug בודק קטע סטטי לפני קטע עם משתנה — וממילא מזהה קובץ הוא ``ObjectId``, ולכן ``archive`` אינו יכול להיות אחד. """ try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() cursor = db.sticky_notes.find( archived_notes_filter(user_id), _ARCHIVE_CARD_PROJECTION ).sort(list(ARCHIVE_LIST_SORT)) cards = [_as_archive_card(doc) for doc in cursor if isinstance(doc, dict)] return _no_store(jsonify({ 'ok': True, 'notes': cards, 'count': len(cards), 'max': None if _current_user_is_admin() else MAX_ARCHIVED_NOTES_PER_USER, })) except Exception: return _failed('list_archived_notes', 'Failed to list archived notes') @sticky_notes_bp.route('/archive/<note_id>', methods=['GET']) @require_auth @notes_rate_limit('archive_get', 180) @traced('sticky_notes.archive_get') def get_archived_note(note_id: str): """פתק אחד מהארכיון, מלא, עם תקצירי השרשורים שלו — כשפותחים כרטיס. רק פתק שבארכיון ושייך למשתמש; כל פתק אחר עונה ``404 note_not_found``. כשל בקריאת השרשורים אינו מפיל את התשובה: ``threads_unavailable``, כמו ברשימות של שאר היעדים. """ return _one_note_in_scope(note_id, archived_notes_filter, 'get_archived_note', 'Failed to load archived note') def _one_note_in_scope(note_id: str, scope_filter, route: str, error: str): """פתק אחד, מלא, עם תקצירי השרשורים שלו — **רק אם הוא בתוך המשטח** שהמסנן מגדיר. שני משטחים פותחים פתק אחד מעל כרטיסים, באותה זרימה בדיוק: הארכיון (``archived_notes_filter``) ועמוד הקבצים (``files_page_pinned_filter``). ההבדל ביניהם הוא המסנן ושם המסלול בלוג — ולכן הזרימה כאן פעם אחת. ``scope_filter(user_id)`` נותן גם את הבעלות (``user_id``), כך שפתק של משתמש אחר אינו בתוך אף משטח. מזהה פגום ← ``400 invalid_note_id``; פתק שאינו במשטח ← ``404 note_not_found``; כשל בקריאת השרשורים אינו מפיל את התשובה (``threads_unavailable``). כל חריגה אחרת ← ``_failed(route, error)``. """ try: user_id = int(session['user_id']) try: oid = ObjectId(str(note_id)) except InvalidId: return _no_store(jsonify({'ok': False, 'error': 'invalid_note_id'})), 400 db = get_db() doc = db.sticky_notes.find_one({'_id': oid, **scope_filter(user_id)}) if not doc: return _no_store(jsonify({'ok': False, 'error': 'note_not_found'})), 404 note = _as_note_response(doc) payload: Dict[str, Any] = {'ok': True, 'note': note} if not _with_thread_summaries(db, user_id, [note]): payload['threads_unavailable'] = True return _no_store(jsonify(payload)) except Exception: return _failed(route, error) # --- נעיצה לעמוד הקבצים --- # # פתק לוח שננעץ מוצג ככרטיס בראש עמוד הקבצים ("הבא בתור"). **זה לא יעד**: הפתק נשאר על # הלוח, והנעיצה היא שדה לצידו (``FILES_PAGE_PIN_FIELD``). ארבעה ראוטים — נעיצה, הסרה, # רשימת הכרטיסים לעמוד, ופתק אחד מלא כשפותחים כרטיס. הנעיצה וההסרה **אינן** נוגעות # ב-``updated_at``: הן אינן עריכה של הפתק, ושינוי שלו היה מפיל ב-409 את השמירה הבאה של לשונית # אחרת שעורכת את אותו פתק (``prev_updated_at`` ב-``update_note``), ומקפיץ את הפתק לראש # "עודכן לאחרונה" בחיפוש ובדשבורד. #: מה שכרטיס בעמוד הקבצים צריך — התווית, הצבע וזמן הנעיצה. **הגוף כן נשלף**, בניגוד לכלל #: ה-Smart Projection של רשימות: כרטיס של פתק בלי שם מציג את השורה הראשונה של התוכן #: (``note_label``), ומי ששולף פתק בשבילה שולף לפחות את ``NOTE_LABEL_FIELDS``. הרשימה חסומה #: בתקרה של ``MAX_FILES_PAGE_PINNED_NOTES`` פתקים, כך שהעבודה חסומה גם היא. _FILES_PAGE_CARD_PROJECTION = {**NOTE_LABEL_FIELDS, 'color': 1, FILES_PAGE_PIN_FIELD: 1} #: מה שהבדיקות לפני הכתיבה ואחרי כתיבה שלא תפסה צריכות לקרוא — הסוג והנעיצה. _FILES_PAGE_PIN_STATE_PROJECTION = {'board_id': 1, 'archived_at': 1, FILES_PAGE_PIN_FIELD: 1} def _as_files_page_card(doc: Dict[str, Any]) -> Dict[str, Any]: """כרטיס אחד בראש עמוד הקבצים. נבנה מרשימה מפורשת של שדות, לא מהמסמך כולו.""" return { 'id': str(doc.get('_id')), # פתק נעוץ יכול להיות בלי שם — ``note_label`` נותנת את השורה הראשונה, כמו בפוש ובפעמון. 'label': note_label(doc), # אותו חוזה צבע כמו ``_as_note_response``: ``color`` תמיד ``hex`` חוקי. 'color': note_color_hex(doc.get('color')), 'color_id': note_color_id(doc.get('color')), FILES_PAGE_PIN_FIELD: _iso_utc(doc.get(FILES_PAGE_PIN_FIELD)), } def _pinned_answer(stamp: Any, *, already: bool, note: Optional[Dict[str, Any]] = None): """תשובת הצלחה של נעיצה — ``files_page_pinned_at`` תמיד, ``note`` כשהכתיבה הזו קרתה.""" body: Dict[str, Any] = { 'ok': True, 'already_pinned': already, FILES_PAGE_PIN_FIELD: _iso_utc(stamp), } if note is not None: body['note'] = _as_note_response(note) return _no_store(jsonify(body)) @sticky_notes_bp.route('/note/<note_id>/files-page-pin', methods=['POST']) @require_auth @notes_rate_limit('files_page_pin', 60) @traced('sticky_notes.files_page_pin') def pin_note_to_files_page(note_id: str): """נועץ פתק לוח לראש עמוד הקבצים. גוף אופציונלי: ``{"device_limit": N}`` — כמה כרטיסים נכנסים בשורה בעמוד הקבצים במסך שממנו נועצים. הוא רק מוריד את התקרה (``files_page_pin_limit``), כדי שמכשיר שנכנסים בו שני כרטיסים לא ינעץ שלישי שיוצג אצלו רק כ-"+N". הסדר, וכל שלב בו מגן על משהו: 1. הפתק קיים ושייך למשתמש — אחרת ``404 note_not_found``. פתק בארכיון — ``409 note_archived``; פתק שאינו פתק לוח — ``400 not_a_board_note``. 2. **כבר נעוץ** ← ``200`` עם ``already_pinned``, בלי כתיבה. לחיצה כפולה, או מכשיר שני שעוד מציג את הפתק כלא-נעוץ, אינם שגיאה. 3. **התקרה** — ``MAX_FILES_PAGE_PINNED_NOTES``, או פחות לפי המכשיר. תקרה של צורת-תוכן, ולכן ``is_admin=False`` תמיד; ספירה שנכשלה נדחית (``note_quota_unknown``), ולא נחשבת אפס. מלא ← ``409 files_page_pins_full``, והפתק הישן **אינו** יורד אוטומטית. 4. **כתיבה אחת מותנית (CAS):** ``find_one_and_update`` שהפילטר שלו דורש פתק לוח פעיל שעוד אינו נעוץ. ``None`` מהמסד אינו הצלחה (K11): קוראים שוב ומסווגים — נמחק בינתיים, ננעץ בבקשה מקבילה, או הועבר לארכיון. התשובה נבנית מהמסמך שהכתיבה **הזו** השאירה (``ReturnDocument.AFTER``). הספירה והכתיבה אינן אטומיות — אותה מגבלה ידועה של כל התקרות (``docs/dev/sticky_notes_extending_backend.rst``). """ try: from pymongo import ReturnDocument from sticky_notes_target import ( NoteQuotaExceeded, NoteQuotaUnknown, check_note_quota, note_target_kind, ) _ensure_indexes() user_id = int(session['user_id']) payload = _json_object() if payload is None: return _no_store(jsonify({'ok': False, 'error': 'invalid_payload'})), 400 limit, limit_error = files_page_pin_limit( payload.get('device_limit'), given='device_limit' in payload ) if limit_error: return _no_store(jsonify({'ok': False, 'error': limit_error})), 400 try: oid = ObjectId(str(note_id)) except InvalidId: return _no_store(jsonify({'ok': False, 'error': 'invalid_note_id'})), 400 db = get_db() note = db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}, _FILES_PAGE_PIN_STATE_PROJECTION) if not note: return _no_store(jsonify({'ok': False, 'error': 'note_not_found'})), 404 kind = note_target_kind(note) if kind == 'archive': return _no_store(jsonify({'ok': False, 'error': 'note_archived'})), 409 if kind != 'board': return _no_store(jsonify({'ok': False, 'error': 'not_a_board_note'})), 400 if isinstance(note.get(FILES_PAGE_PIN_FIELD), datetime): return _pinned_answer(note.get(FILES_PAGE_PIN_FIELD), already=True) pinned = _count_or_none(db.sticky_notes, files_page_pinned_filter(user_id)) try: check_note_quota(pinned, limit, is_admin=False) except NoteQuotaUnknown: return _no_store(jsonify({'ok': False, 'error': 'note_quota_unknown'})), 409 except NoteQuotaExceeded: return _no_store(jsonify({ 'ok': False, 'error': 'files_page_pins_full', 'max': limit, 'pinned': pinned, 'device_limited': limit < MAX_FILES_PAGE_PINNED_NOTES, })), 409 now = datetime.now(timezone.utc) stored = db.sticky_notes.find_one_and_update( { **any_board_note_filter(user_id), **active_notes_filter(user_id), '_id': oid, FILES_PAGE_PIN_FIELD: None, }, {'$set': {FILES_PAGE_PIN_FIELD: now}}, return_document=ReturnDocument.AFTER, ) if stored is None: current = db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}, _FILES_PAGE_PIN_STATE_PROJECTION) if current is None: return _no_store(jsonify({'ok': False, 'error': 'note_not_found'})), 404 if note_target_kind(current) == 'archive': return _no_store(jsonify({'ok': False, 'error': 'note_archived'})), 409 if isinstance(current.get(FILES_PAGE_PIN_FIELD), datetime): return _pinned_answer(current.get(FILES_PAGE_PIN_FIELD), already=True) # הפילטר לא תפס, והפתק קיים, פעיל ואינו נעוץ: ערך בשדה שאינו ``null`` ואינו תאריך. # אף כותב אינו מייצר כזה, ולכן זה נתון פגום ולא מרוץ — והתשובה אומרת שהנעיצה לא # נכתבה, במקום לדווח הצלחה. logger.error("sticky notes: pinning %s to the files page matched nothing although the note exists", oid) return _no_store(jsonify({'ok': False, 'error': 'pin_not_applied'})), 409 try: emit_event("sticky_note_files_page_pinned", severity="info", user_id=int(user_id), note_id=str(oid)) except Exception: # הנעיצה כבר נכתבה: אירוע שלא יצא אינו הופך אותה ל-500, שהלקוח היה מציג ככישלון. logger.warning("sticky notes: emitting sticky_note_files_page_pinned for %s failed", oid, exc_info=True) return _pinned_answer(stored.get(FILES_PAGE_PIN_FIELD), already=False, note=stored) except Exception: return _failed('pin_note_to_files_page', 'Failed to pin note') @sticky_notes_bp.route('/note/<note_id>/files-page-pin', methods=['DELETE']) @require_auth @notes_rate_limit('files_page_pin', 60) @traced('sticky_notes.files_page_unpin') def unpin_note_from_files_page(note_id: str): """מסיר פתק מראש עמוד הקבצים. הפתק נשאר על הלוח שלו. כתיבה מותנית אחת: ``$unset`` רק על פתק שהשדה קיים בו — כל ערך, גם פגום, כדי שהסרה תמיד תנקה. ``None`` מהמסד מסווג בקריאה חוזרת: פתק שאינו קיים ← ``404``; פתק שאינו נעוץ ← ``200`` עם ``already_unpinned`` (לחיצה כפולה או מכשיר שני אינם שגיאה). """ try: from pymongo import ReturnDocument user_id = int(session['user_id']) try: oid = ObjectId(str(note_id)) except InvalidId: return _no_store(jsonify({'ok': False, 'error': 'invalid_note_id'})), 400 db = get_db() stored = db.sticky_notes.find_one_and_update( {'_id': oid, 'user_id': user_id, FILES_PAGE_PIN_FIELD: {'$exists': True}}, {'$unset': {FILES_PAGE_PIN_FIELD: ''}}, projection={'_id': 1}, return_document=ReturnDocument.AFTER, ) if stored is None: if db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}, {'_id': 1}) is None: return _no_store(jsonify({'ok': False, 'error': 'note_not_found'})), 404 return _no_store(jsonify({'ok': True, 'already_unpinned': True, FILES_PAGE_PIN_FIELD: None})) try: emit_event("sticky_note_files_page_unpinned", severity="info", user_id=int(user_id), note_id=str(oid)) except Exception: logger.warning("sticky notes: emitting sticky_note_files_page_unpinned for %s failed", oid, exc_info=True) return _no_store(jsonify({'ok': True, 'already_unpinned': False, FILES_PAGE_PIN_FIELD: None})) except Exception: return _failed('unpin_note_from_files_page', 'Failed to unpin note') @sticky_notes_bp.route('/files-page', methods=['GET']) @require_auth @notes_rate_limit('files_page_list', 180) @traced('sticky_notes.files_page_list') def list_files_page_notes(): """הכרטיסים לראש עמוד הקבצים — הפתקים הנעוצים, מהראשון שננעץ לאחרון. **בלי ``limit``**, ובכוונה: הספירה והכתיבה של הנעיצה אינן אטומיות, ושתי נעיצות מקבילות יכולות להשאיר אחד מעל התקרה. ``limit`` היה מסתיר אותו בלי שום סימן, וממנו גם את הדרך להסיר אותו מעמוד הקבצים. שאילתה שנכשלה עונה 500 ולא רשימה ריקה: העמוד אומר "לא הצלחתי לטעון", ולא מציג עמוד בלי פתקים כאילו אין נעוצים. """ try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() cursor = db.sticky_notes.find( files_page_pinned_filter(user_id), _FILES_PAGE_CARD_PROJECTION ).sort(list(FILES_PAGE_PINNED_SORT)) cards = [_as_files_page_card(doc) for doc in cursor if isinstance(doc, dict)] return _no_store(jsonify({ 'ok': True, 'notes': cards, 'count': len(cards), 'max': MAX_FILES_PAGE_PINNED_NOTES, })) except Exception: return _failed('list_files_page_notes', 'Failed to list pinned notes') @sticky_notes_bp.route('/files-page/<note_id>', methods=['GET']) @require_auth @notes_rate_limit('files_page_get', 180) @traced('sticky_notes.files_page_get') def get_files_page_note(note_id: str): """פתק נעוץ אחד, מלא, עם תקצירי השרשורים שלו — כשפותחים כרטיס בעמוד הקבצים. רק פתק נעוץ ופעיל של המשתמש (``files_page_pinned_filter``); כל פתק אחר — נמחק, הוסר מהנעיצה או הועבר לארכיון ממכשיר אחר — עונה ``404 note_not_found``, והעמוד מוריד את הכרטיס. כשל בקריאת השרשורים אינו מפיל את התשובה: ``threads_unavailable``, כמו בשאר הרשימות. """ return _one_note_in_scope(note_id, files_page_pinned_filter, 'get_files_page_note', 'Failed to load pinned note') # --- Board notes --- # # ראוטים נפרדים לפתקי לוח, ולא הכללה של ``/<file_id>``. הכללה הייתה מכריחה # כל צרכן להכיר קידוד כלשהו בתוך הפרמטר, ושוברת גם את ה-JS וגם את הטסטים # שמניחים שהסגמנט הזה הוא מזהה קובץ. אין התנגשות ניתוב: ``/board/<x>`` הוא # שני סגמנטים ו-``/<file_id>`` אחד — בדיוק כמו ``/note/<id>`` ו- # ``/reminders/*`` שכבר חיים כאן. # # מה שלא חוזר על עצמו כאן בכוונה: ``PUT /note/<id>``, ``DELETE /note/<id>``, # ``POST /batch`` וכל ראוטי התזכורות מזהים פתק לפי ``_id + user_id`` בלבד, # ולכן הם עובדים על פתקי לוח בלי שורת קוד אחת. זה כל הרווח של "אוסף פתקים # אחד": מסלול הכתיבה, ה-debounce, ה-optimistic concurrency וה-keepalive # מגיעים בירושה. def _current_user_is_admin() -> bool: """אדמין פטור מתקרות. ``user_roles`` הוא מודול טהור ולכן אין כאן מעגל.""" try: from user_roles import is_admin return bool(is_admin(int(session.get('user_id') or 0))) except Exception: return False def _count_or_none(coll: Any, query: Dict[str, Any]) -> Optional[int]: """ספירה, או ``None`` כשהיא נכשלה. ההבחנה חשובה: ``check_note_quota`` דוחה על ``None`` במקום להניח אפס. """ try: return int(coll.count_documents(query)) except Exception: return None def _resolve_owned_board(db: Any, user_id: int, board_id: str) -> Optional[Dict[str, Any]]: """הלוח, אם הוא קיים ושייך למשתמש. אחרת ``None``. בלי הבדיקה הזו אפשר היה ליצור פתקים על ``board_id`` שרירותי — פתקים שאינם נראים בשום ממשק אבל כן נספרים בתקרה. ``mcp_server/backend`` עושה את המקבילה לקובץ ומחזיר ``file_not_found``. """ try: oid = ObjectId(str(board_id)) except Exception: return None try: doc = db.note_boards.find_one({'_id': oid, 'user_id': int(user_id)}) except Exception: return None return doc if isinstance(doc, dict) else None @sticky_notes_bp.route('/board/<board_id>', methods=['GET']) @require_auth @notes_rate_limit('board_list', 180) @traced("sticky_notes.board_list") def list_board_notes(board_id: str): """פתקי לוח. שאילתה ישירה, בלי ``$or`` ובלי מעבר ב-``code_snippets``.""" try: from sticky_notes_target import board_notes_filter _ensure_indexes() user_id = int(session['user_id']) db = get_db() if not _resolve_owned_board(db, user_id, board_id): return jsonify({'ok': False, 'error': 'board_not_found'}), 404 if _versions_requested(): return _note_versions_answer(db, board_notes_filter(user_id, board_id)) cursor = db.sticky_notes.find(board_notes_filter(user_id, board_id)).sort('created_at', 1) raw_docs = list(cursor) if cursor is not None else [] notes = [_as_note_response(doc) for doc in raw_docs if isinstance(doc, dict)] payload: Dict[str, Any] = {'ok': True, 'notes': notes, 'count': len(notes)} if not _with_thread_summaries(db, user_id, notes): payload['threads_unavailable'] = True resp = jsonify(payload) try: resp.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate' resp.headers['Pragma'] = 'no-cache' resp.headers['Expires'] = '0' except Exception: pass return resp except Exception as e: try: emit_event("sticky_notes_board_list_error", severity="anomaly", error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to list board notes'}), 500 @sticky_notes_bp.route('/board/<board_id>', methods=['POST']) @require_auth @notes_rate_limit('board_create', 60) @traced("sticky_notes.board_create") def create_board_note(board_id: str): """פתק חדש על לוח.""" try: from sticky_notes_target import ( DEFAULT_BOARD_MODE, NoteQuotaExceeded, NoteQuotaUnknown, board_notes_filter, build_note_target, check_note_quota, is_valid_board_mode, normalize_mode, ) _ensure_indexes() user_id = int(session['user_id']) db = get_db() if not _resolve_owned_board(db, user_id, board_id): return jsonify({'ok': False, 'error': 'board_not_found'}), 404 data = request.get_json(silent=True) or {} raw_mode = data.get('mode') if raw_mode is not None and not is_valid_board_mode(raw_mode): return jsonify({'ok': False, 'error': 'invalid_mode'}), 400 mode = normalize_mode(raw_mode, DEFAULT_BOARD_MODE) try: content = _note_content_from_request(data) except _ContentTooLong: return jsonify({'ok': False, 'error': 'content_too_long', 'max': MAX_NOTE_CHARS}), 400 except _InvalidContentB64: return jsonify({'ok': False, 'error': 'invalid_content_b64'}), 400 except _InvalidContent: return jsonify({'ok': False, 'error': 'invalid_content'}), 400 title = normalize_note_title(data.get('title')) # תקרות — ולפני הכתיבה, לא אחריה. ``_count_or_none`` מבחין בין אפס # לבין ספירה שנכשלה, ו-``check_note_quota`` דוחה על השנייה. is_admin_user = _current_user_is_admin() try: check_note_quota( _count_or_none(db.sticky_notes, board_notes_filter(user_id, board_id)), MAX_NOTES_PER_BOARD, is_admin=is_admin_user, ) check_note_quota( _count_or_none(db.sticky_notes, active_notes_filter(user_id)), MAX_NOTES_PER_USER, is_admin=is_admin_user, ) except NoteQuotaUnknown: return jsonify({'ok': False, 'error': 'note_quota_unknown'}), 409 except NoteQuotaExceeded: return jsonify({'ok': False, 'error': 'note_quota_exceeded'}), 409 pos = data.get('position') or {} size = data.get('size') or {} color = resolve_note_color(data.get('color')) # זמן אחד ליצירה ולעדכון, ברזולוציה של המסד — הלקוח מקבל אותו כאסימון (``_stored_now``). created_at = _stored_now() doc: Dict[str, Any] = { 'user_id': user_id, 'content': content, # ריק ← השדה כלל אינו נכתב, כדי שלא ייכנס לאינדקס הייחודי **({'title': title} if title else {}), 'position_x': _coerce_int(pos.get('x'), 100, 0, 100000), 'position_y': _coerce_int(pos.get('y'), 100, 0, 1000000), 'width': _coerce_int(size.get('width'), 250, 120, 1200), 'height': _coerce_int(size.get('height'), 200, 80, 1200), 'color': color, 'is_minimized': bool(data.get('is_minimized', False)), 'mode': mode, 'created_at': created_at, 'updated_at': created_at, } # שדות היעד עוברים דרך הבנאי, ולא נכתבים כאן ביד. זה מה שמונע # ממסמך לצאת עם שני משטחים או בלי אף אחד. doc.update(build_note_target(board_id=board_id)) # גיבוי לאכיפה כשהאינדקס לא אומת. במצב התקין אינו עולה שאילתה. if _title_conflict(db, user_id, doc.get('board_id'), title): return jsonify({'ok': False, 'error': 'duplicate_title', 'max': MAX_NOTE_TITLE}), 409 try: res = db.sticky_notes.insert_one(doc) except DuplicateKeyError: # שם תפוס בלוח הזה — התנגשות, לא תקלה return jsonify({'ok': False, 'error': 'duplicate_title', 'max': MAX_NOTE_TITLE}), 409 nid = str(getattr(res, 'inserted_id', '')) try: emit_event("sticky_note_created", severity="info", user_id=int(user_id), board_id=str(board_id)) except Exception: pass resp = jsonify({'ok': True, 'id': nid, 'updated_at': _updated_at_iso(created_at)}) try: resp.headers['Cache-Control'] = 'no-store' except Exception: pass return resp, 201 except Exception as e: try: emit_event("sticky_notes_board_create_error", severity="anomaly", error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to create note'}), 500 # --------------------------------------------------------------------------- # פתקי ריפו — היעד השלישי # # **שני ראוטי היתומים יושבים מחוץ לתת-העץ ``/repo/<name>/`` בכוונה.** # ``GET /repo/<name>/orphans`` היה מתנגש עם ``/repo/<name>/<path:repo_path>``, # והראוט הסטטי מנצח — כלומר קובץ אמיתי בשם ``orphans`` בשורש ריפו (שם סביר # לגמרי) לא היה נגיש דרך ה-API לעולם, בלי שום שגיאה. לכן ``repo-orphans`` # ו-``orphan-repos``, ולא תת-נתיבים. # --------------------------------------------------------------------------- @sticky_notes_bp.route('/repo/<repo_name>/<path:repo_path>', methods=['GET']) @require_auth @notes_rate_limit('repo_list', 180) @traced("sticky_notes.repo_list") def list_repo_notes(repo_name: str, repo_path: str): """פתקים על קובץ בריפו ממורר. **סימון היתומים נעשה בקריאה, ולא בכתיבה.** אין סריקה תקופתית ואין ``update_many`` על מסלול קריאה — זה הלקח מסריקת היתומים של הלוחות. הפתק ממשיך להיות מוחזר עם הנתיב האחרון הידוע, ורק נושא דגל. """ try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() clean_path = normalize_repo_path(repo_path) if not clean_path: return jsonify({'ok': False, 'error': 'invalid_repo_path'}), 400 # הדגימה — בלי בדיקת קיום הקובץ במניפסט: היא שייכת לטעינה המלאה, שמציגה את סימון היתום. if _versions_requested(): return _note_versions_answer(db, repo_notes_filter(user_id, repo_name, clean_path)) cursor = db.sticky_notes.find( repo_notes_filter(user_id, repo_name, clean_path) ).sort('created_at', 1) # אותה הבחנה שהראוט הזה עושה על המניפסט, גם על הפתקים עצמם: # ``None`` הוא כשל שאילתה ולא "אין פתקים". החזרת ``notes: []`` # כאן אינה רק תצוגה חסרה — הלקוח כותב את התשובה לקאש המקומי # (``_saveCache``), ולכן קריאה שנכשלה הייתה **מוחקת** את הפתקים # שהיו שמורים בו. if cursor is None: raise RuntimeError('repo notes query returned no cursor') raw_docs = list(cursor) notes = [_as_note_response(doc) for doc in raw_docs if isinstance(doc, dict)] # ``None`` (כשל שאילתה) אינו "הקובץ נעלם" — ואז לא מסמנים כלום. exists = repo_file_exists(db, str(repo_name), clean_path) payload: Dict[str, Any] = {'ok': True, 'notes': notes, 'count': len(notes)} if exists is False: payload['orphaned'] = True if not _with_thread_summaries(db, user_id, notes): payload['threads_unavailable'] = True resp = jsonify(payload) try: resp.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate' resp.headers['Pragma'] = 'no-cache' resp.headers['Expires'] = '0' except Exception: pass return resp except Exception as e: try: emit_event("sticky_notes_repo_list_error", severity="anomaly", error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to list repo notes'}), 500 @sticky_notes_bp.route('/repo/<repo_name>/<path:repo_path>', methods=['POST']) @require_auth @notes_rate_limit('repo_create', 60) @traced("sticky_notes.repo_create") def create_repo_note(repo_name: str, repo_path: str): """פתק חדש על קובץ בריפו ממורר.""" try: from sticky_notes_target import ( DEFAULT_BOARD_MODE, NoteQuotaExceeded, NoteQuotaUnknown, NoteTargetError, build_note_target, check_note_quota, is_valid_board_mode, normalize_mode, ) _ensure_indexes() user_id = int(session['user_id']) db = get_db() clean_path = normalize_repo_path(repo_path) if not clean_path: return jsonify({'ok': False, 'error': 'invalid_repo_path'}), 400 # רק ריפו ממורר. בלי הבדיקה אפשר היה ליצור פתקים על ``repo_name`` # שרירותי — פתקים שאינם נראים בשום ממשק אבל כן נספרים בתקרה, # בדיוק כמו ש-``_resolve_owned_board`` מונע בלוחות. # # **כשל בקריאת רשימת המראות נסגר, לא נפתח.** ``None`` אינו "אין # ריפואים" — הוא "לא ידוע", וקריאה שנכשלה אינה רשיון ליצור פתק על # ריפו שאולי אינו ממורר. זה אותו כלל של ``check_note_quota``: כשל # בדיקה נסגר. known = mirrored_repo_names(db) if known is None: return jsonify({'ok': False, 'error': 'repo_list_unavailable'}), 503 if str(repo_name) not in known: return jsonify({'ok': False, 'error': 'repo_not_found'}), 404 # **וגם הקובץ עצמו חייב להיות בעץ.** ריפו ממורר אינו מספיק: נתיב # שאינו ב-``repo_files`` הוא בדיוק מה שמסלול הקריאה מסמן # ``orphaned`` — כלומר הפתק היה נולד יתום, נספר בתקרה, ומוצג # ברשימת היתומים בלי שאי-פעם היה לו קובץ. עץ הדפדפן נבנה מאותו # ``repo_files``, ולכן כל קובץ שניתן לפתוח בממשק עובר כאן. # # ``None`` נסגר, בדיוק כמו רשימת המראות: קריאה שנכשלה אינה עדות # שהקובץ קיים, ואינה רשיון לכתוב. file_exists = repo_file_exists(db, str(repo_name), clean_path) if file_exists is None: return jsonify({'ok': False, 'error': 'repo_file_unavailable'}), 503 if not file_exists: return jsonify({'ok': False, 'error': 'repo_file_not_found'}), 404 data = request.get_json(silent=True) # גוף שאינו אובייקט (מערך, מחרוזת) הוא קלט פגום — 400, לא 500 # מ-``data.get`` על טיפוס לא נכון. if data is None: data = {} elif not isinstance(data, dict): return jsonify({'ok': False, 'error': 'invalid_payload'}), 400 # ``anchored`` אינו חוקי כאן מאותה סיבה שהוא אינו חוקי בלוח: הוא # דורש שורת מקור, והעיגון כאן הוא ברמת קובץ. שני המצבים מצמידים # את הפתק למסגרת התצוגה, לא לשורת קוד. raw_mode = data.get('mode') if raw_mode is not None and not is_valid_board_mode(raw_mode): return jsonify({'ok': False, 'error': 'invalid_mode'}), 400 mode = normalize_mode(raw_mode, DEFAULT_BOARD_MODE) try: content = _note_content_from_request(data) except _ContentTooLong: return jsonify({'ok': False, 'error': 'content_too_long', 'max': MAX_NOTE_CHARS}), 400 except _InvalidContentB64: return jsonify({'ok': False, 'error': 'invalid_content_b64'}), 400 except _InvalidContent: return jsonify({'ok': False, 'error': 'invalid_content'}), 400 title = normalize_note_title(data.get('title')) # **ה-cap לקובץ נאכף גם על אדמין, במכוון.** דפדפן הריפו חסום # לאדמינים, ולכן ``is_admin=is_admin_user`` היה הופך את התקרה # לקבוע מת שלא נאכף על אף אחד. מטרתה שמירת צורת-תוכן ("עשרים # פתקים על קובץ = זה כבר עמוד תיעוד") ולא הגנת-משאבים. # תקרת המשתמש, לעומתה, היא הגנת-משאבים ונשארת פטורה-לאדמין. is_admin_user = _current_user_is_admin() try: check_note_quota( _count_or_none(db.sticky_notes, repo_notes_filter(user_id, repo_name, clean_path)), MAX_NOTES_PER_REPO_FILE, is_admin=False, ) check_note_quota( _count_or_none(db.sticky_notes, active_notes_filter(user_id)), MAX_NOTES_PER_USER, is_admin=is_admin_user, ) except NoteQuotaUnknown: return jsonify({'ok': False, 'error': 'note_quota_unknown'}), 409 except NoteQuotaExceeded: return jsonify({'ok': False, 'error': 'note_quota_exceeded'}), 409 # ``position``/``size`` שאינם אובייקט הם קלט פגום — ``{}`` רק כשחסר, # אחרת ``pos.get`` על מערך/מחרוזת היה מפיל ל-500. pos = data.get('position') size = data.get('size') if pos is not None and not isinstance(pos, dict): return jsonify({'ok': False, 'error': 'invalid_payload'}), 400 if size is not None and not isinstance(size, dict): return jsonify({'ok': False, 'error': 'invalid_payload'}), 400 pos = pos or {} size = size or {} color = resolve_note_color(data.get('color')) # זמן אחד ליצירה ולעדכון, ברזולוציה של המסד — הלקוח מקבל אותו כאסימון (``_stored_now``). created_at = _stored_now() doc: Dict[str, Any] = { 'user_id': user_id, 'content': content, **({'title': title} if title else {}), 'position_x': _coerce_int(pos.get('x'), 100, 0, 100000), 'position_y': _coerce_int(pos.get('y'), 100, 0, 1000000), 'width': _coerce_int(size.get('width'), 250, 120, 1200), 'height': _coerce_int(size.get('height'), 200, 80, 1200), 'color': color, 'is_minimized': bool(data.get('is_minimized', False)), 'mode': mode, 'created_at': created_at, 'updated_at': created_at, } # שדות היעד דרך הבנאי, שמריץ את הנרמול ואת האילוץ "בדיוק יעד אחד". try: doc.update(build_note_target(repo_name=repo_name, repo_path=clean_path)) except NoteTargetError: return jsonify({'ok': False, 'error': 'invalid_repo_target'}), 400 if _repo_title_conflict(db, user_id, repo_name, clean_path, title): return jsonify({'ok': False, 'error': 'duplicate_title', 'max': MAX_NOTE_TITLE}), 409 try: res = db.sticky_notes.insert_one(doc) except DuplicateKeyError: return jsonify({'ok': False, 'error': 'duplicate_title', 'max': MAX_NOTE_TITLE}), 409 nid = str(getattr(res, 'inserted_id', '')) try: emit_event("sticky_note_created", severity="info", user_id=int(user_id), repo_name=str(repo_name)) except Exception: pass resp = jsonify({'ok': True, 'id': nid, 'updated_at': _updated_at_iso(created_at)}) try: resp.headers['Cache-Control'] = 'no-store' except Exception: pass return resp, 201 except Exception as e: try: emit_event("sticky_notes_repo_create_error", severity="anomaly", error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to create note'}), 500 @sticky_notes_bp.route('/repo-orphans/<repo_name>', methods=['GET']) @require_auth @notes_rate_limit('repo_orphans', 60) @traced("sticky_notes.repo_orphans") def list_repo_orphans(repo_name: str): """קומה ראשונה: פתקים בריפו הזה שהקובץ שלהם כבר אינו בעץ. **"מיותם" נגזר מהמראה, לא מ-GitHub.** דפדפן הריפו מציג עותק מסונכרן, ולכן קובץ שנמחק ב-GitHub לפני שעתיים עדיין קיים כאן והפתק עליו ייראה תקין עד הסנכרון הבא. לכן מוחזר גם ``last_sync_time`` — זה לא באג אם כתוב, וכן באג אם לא. """ try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() # כשל בקריאת הפתקים אינו "אין יתומים" — הוא "לא ידוע", בדיוק כמו # כשל בקריאת המניפסט. בלי ההבחנה, נפילת שאילתה הייתה מוצגת כרשימה # ריקה של יתומים. # # ``None`` הוא ערוץ כשל בפני עצמו, לא רק חריגה: דרייבר או שכבת # עטיפה שמחזירים ``None`` במקום סמן לא זורקים כלום, והקוד הישן # המשיך עם רשימה ריקה ועם ``notes_failed=False`` — כלומר ``unknown`` # היה יוצא ``false`` ו"לא הצלחנו לקרוא" היה מוצג כ"אין יתומים". notes_failed = False try: cursor = db.sticky_notes.find({ 'user_id': user_id, 'repo_name': str(repo_name), 'repo_path': {'$exists': True}, }).sort('created_at', 1) if cursor is None: raw_docs = [] notes_failed = True else: raw_docs = list(cursor) except Exception: raw_docs = [] notes_failed = True # מניפסט הריפו בשאילתה אחת, במקום ``find_one`` לכל פתק. try: paths = db.repo_files.distinct('path', {'repo_name': str(repo_name)}) known_paths = {str(p) for p in paths if p} if isinstance(paths, (list, tuple, set)) else None except Exception: known_paths = None orphans = [] if known_paths is not None and not notes_failed: for doc in raw_docs: if not isinstance(doc, dict): continue if str(doc.get('repo_path') or '') not in known_paths: item = _as_note_response(doc) item['repo_path'] = str(doc.get('repo_path') or '') item['repo_name'] = str(doc.get('repo_name') or '') orphans.append(item) last_sync = None try: meta = db.repo_metadata.find_one({'repo_name': str(repo_name)}, {'last_sync_time': 1}) if isinstance(meta, dict) and meta.get('last_sync_time'): last_sync = str(meta.get('last_sync_time')) except Exception: last_sync = None return jsonify({ 'ok': True, 'notes': orphans, 'count': len(orphans), 'last_sync_time': last_sync, # ``True`` פירושו שלא הצלחנו לקרוא את המניפסט **או** את הפתקים, # ולכן הרשימה הריקה למעלה אינה "אין יתומים" אלא "לא ידוע". 'unknown': known_paths is None or notes_failed, }) except Exception as e: try: emit_event("sticky_notes_repo_orphans_error", severity="anomaly", error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to list repo orphans'}), 500 @sticky_notes_bp.route('/orphan-repos', methods=['GET']) @require_auth @notes_rate_limit('orphan_repos', 60) @traced("sticky_notes.orphan_repos") def list_orphan_repos(): """קומה שנייה: ריפואים שיש להם פתקים ואינם ממוררים עוד. בלי הקומה הזו פתקים של ריפו שהוסר **לא מופיעים בשום תצוגה** — לא בעץ שלו, כי אין עץ, ולא ברשימת היתומים, כי היא פר-ריפו. זה בדיוק "המצב שנעלם בשקט". """ try: _ensure_indexes() user_id = int(session['user_id']) db = get_db() try: names = db.sticky_notes.distinct('repo_name', { 'user_id': user_id, 'repo_path': {'$exists': True}, }) with_notes = {str(n) for n in names if n} if isinstance(names, (list, tuple, set)) else set() except Exception: return jsonify({'ok': False, 'error': 'Failed to list orphan repos'}), 500 mirrored = mirrored_repo_names(db) if mirrored is None: # אין רשימת מראות ⇒ אי אפשר לדעת מי נעלם. לא מדווחים על אף # ריפו כיתום על סמך שאילתה שנכשלה. return jsonify({'ok': True, 'repos': [], 'count': 0, 'unknown': True}) missing = sorted(with_notes - mirrored) repos = [] for name in missing: try: count = int(db.sticky_notes.count_documents({ 'user_id': user_id, 'repo_name': name, 'repo_path': {'$exists': True}, })) except Exception: # הריפו בטוח שקיים ברשימה (הוא הגיע מ-``distinct``), ולכן יש # לו לפחות פתק אחד. ``0`` היה נתון שגוי; ``None`` (null ב-JSON) # אומר "המספר לא ידוע" בלי להמציא אפס. count = None repos.append({'repo_name': name, 'notes': count}) return jsonify({'ok': True, 'repos': repos, 'count': len(repos), 'unknown': False}) except Exception as e: try: emit_event("sticky_notes_orphan_repos_error", severity="anomaly", error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to list orphan repos'}), 500 @sticky_notes_bp.route('/note/<note_id>/task', methods=['POST']) @require_auth @notes_rate_limit('note_task_toggle', 300) @traced("sticky_notes.task_toggle") def toggle_note_task(note_id: str): """מסמן או מבטל צ'קבוקס בתוך פתק. **הראוט הזה קיים כדי שאפשר יהיה לאמת את הכתיבה.** האלטרנטיבה — לשלוח את התוכן המלא ב-``PUT /note/<id>`` — הופכת כל קליק לדריסת last-writer-wins של עריכות מקבילות, ובעיקר הופכת אימות לבלתי אפשרי: אפשר לאמת רק שכתבנו את מה ששלחנו. הבקשה כאן נושאת **כוונה** (מספר סידורי + מצב רצוי), וזה הדבר היחיד שניתן לאמת מול המסד. הסדר, וכל שלב בו מגן על משהו: 1. הפתק קיים ושייך למשתמש — אחרת 404. 2. ``prev_updated_at`` — אחרת 409, בדיוק כמו ב-``update_note``. 3. סידורי שאינו קיים ⇒ **409**, לא 200. התצוגה של הלקוח מיושנת. 4. כבר במצב המבוקש ⇒ 200 בלי כתיבה. אידמפוטנטי. 5. Compare-and-swap: הפילטר כולל את התוכן הקודם, כך שכותב מקביל אינו נדרס. 6. **קריאה חוזרת מהמסד** ובדיקה שהתו אכן השתנה. לא ``modified_count``, לא ``ok: true`` — אלה מדווחים על הקריאה, לא על המצב. בכל מסלול התשובה נושאת את התוכן הסמכותי, כדי שהלקוח יסתנכרן בלי סיבוב נוסף — וגם במסלול הכשל, שם זה מה שמאפשר לו להחזיר את התצוגה למה שבאמת שמור. """ try: from sticky_notes_tasks import task_state_at_index, toggle_task_at_index user_id = int(session['user_id']) db = get_db() try: oid = ObjectId(str(note_id)) except InvalidId: return jsonify({'ok': False, 'error': 'Invalid note_id'}), 400 data = request.get_json(silent=True) or {} try: index = int(data.get('index')) except Exception: return jsonify({'ok': False, 'error': 'invalid_index'}), 400 if index < 0: return jsonify({'ok': False, 'error': 'invalid_index'}), 400 checked = bool(data.get('checked')) note = db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}) if not note: return jsonify({'ok': False, 'error': 'Note not found'}), 404 prev_updated_at = data.get('prev_updated_at') if prev_updated_at: try: # ``fromisoformat`` מקבל סיומת ``Z`` מ-Python 3.11, וה-CI # רץ על 3.11 ו-3.12 בלבד — אותה צורה כמו בשני # מסלולי העדכון האחרים. prev_dt = datetime.fromisoformat(str(prev_updated_at)) except Exception: prev_dt = None if prev_dt and isinstance(note.get('updated_at'), datetime) and prev_dt < note['updated_at']: return jsonify({ 'ok': False, 'error': 'Conflict', 'content': note.get('content', ''), 'updated_at': _updated_at_iso(note['updated_at']), }), 409 original = note.get('content', '') or '' new_content, changed = toggle_task_at_index(original, index, checked) if not changed: # שתי סיבות אפשריות, ורק אחת מהן תקינה. if task_state_at_index(original, index) is None: # הסידורי אינו קיים — התצוגה של הלקוח מתארת פתק אחר. return jsonify({ 'ok': False, 'error': 'task_index_not_found', 'content': original, }), 409 # כבר במצב המבוקש. אין כתיבה, וזה בסדר גמור. return jsonify({'ok': True, 'changed': False, 'content': original}) now = datetime.now(timezone.utc) db.sticky_notes.update_one( {'_id': oid, 'user_id': user_id, 'content': original}, {'$set': {'content': new_content, 'updated_at': now}}, ) fresh = db.sticky_notes.find_one({'_id': oid, 'user_id': user_id}) applied = bool(fresh) and task_state_at_index(fresh.get('content', '') or '', index) is checked if not applied: try: emit_event( "sticky_note_task_not_applied", severity="error", user_id=int(user_id), note_id=str(note_id), ) except Exception: pass return jsonify({ 'ok': False, 'error': 'task_toggle_not_applied', 'content': (fresh.get('content', '') if fresh else original), }), 409 return jsonify({ 'ok': True, 'changed': True, 'content': fresh.get('content', ''), 'updated_at': _note_token(fresh), }) except Exception as e: try: emit_event("sticky_notes_task_error", severity="anomaly", error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to toggle task'}), 500 # --------------------------------------------------------------------------- # שרשורי תגובות על פתקים # # הכללים, צורת המסמך וכל כתיבה לאוסף יושבים ב-``note_threads`` (מודול שורש, משותף עם # שירות ה-MCP), ו-``tests/test_note_threads_single_writer.py`` נופל על כתיבה לאוסף מכאן. # מה שיש כאן: ההרשאה — הפתק שייך למשתמש, **לפני** כל קריאה למודול — קריאת הקלט, והתשובה, # שנבנית ממה שהמסד החזיר (``result["thread"]``, ``nt.stored_comment``) ולא ממה שנשלח. # # **אין כאן שער אדמין לפתקי ריפו, בעקביות עם שאר ראוטי הפתקים בוובאפ.** שרשור תמיד שייך # לפתק של המשתמש עצמו (``user_id`` מה-session בכל פילטר), ולכן אין דרך להגיע לשרשור של # מישהו אחר. ב-MCP פתק ריפו פתוח רק לאדמין (``is_repo_note`` ב-``mcp_server/handlers.py``); # ההבדל הוא החלטה, וראוטי פתקי הריפו בוובאפ ממילא אינם בודקים אדמין. # --------------------------------------------------------------------------- #: סטטוס HTTP לכל קוד סירוב של ``note_threads`` — סירוב פירושו שלא נכתב דבר. גוף שאינו #: תקין ← 400; שרשור שאינו קיים בפתק הזה ← 404; מצב שאינו מאפשר את הפעולה (מלא, כבר נפתר, #: לא נפתר, התנגשות) ← 409. שלושת הקודים של ``working_on`` אינם יכולים להגיע מכאן (כותב #: משתמש אינו נושא ``working_on``), והם כאן כדי שהמיפוי יכסה את כל הקודים של המודול — #: ``tests/test_note_threads_webapp.py`` משווה מול המקור. _THREAD_ERROR_STATUS = { 'invalid_body': 400, 'empty_body': 400, 'body_too_long': 400, 'invalid_thread_id': 400, 'working_on_required': 400, 'invalid_working_on': 400, 'working_on_too_long': 400, 'thread_not_found': 404, 'thread_full': 409, 'thread_too_long': 409, 'already_resolved': 409, 'not_resolved': 409, 'conflict': 409, } #: הגוון של תגובת סוכן בחלונית, לפי שם הלקוח. **המפתחות הם בדיוק המפתחות של** #: ``nt.AGENT_CLIENT_LABELS``, וטסט משווה ביניהם: לקוח שיתווסף שם בלי גוון כאן היה מקבל #: בשקט את הגוון של "סוכן אחר" (R6). הצבעים עצמם ב-CSS, לפי ``data-tone``. _AGENT_CLIENT_TONES = { 'claude-code': 'cc', 'Anthropic/ClaudeAI': 'claude', 'Gemini': 'gemini', } #: השם שמוצג ליד תגובה של המשתמש כשאין לו ``first_name`` ב-session. _THREAD_USER_FALLBACK_NAME = 'אני' def _iso_utc(value: Any) -> Optional[str]: """זמן כ-ISO עם היסט UTC מפורש — או ``None``. הלקוח מחשב מזה "לפני 20 דק׳". **בלי היסט הדפדפן היה קורא את הערך כשעון מקומי** (R7), ו-``as_utc`` מבטיח היסט גם כשהלקוח של המסד אינו ``tz_aware``. """ return as_utc(value).isoformat() if isinstance(value, datetime) else None def _thread_user_name() -> str: """השם שמוצג ליד תגובה של המשתמש: ``first_name`` מה-session. הפיצ'ר פתוח לכל המשתמשים ("אמיר" באפיון הוא דוגמה), ולכן השם הוא של המשתמש המחובר. הערך הגיע מ-Telegram בהתחברות, ואין הבטחה שהוא מחרוזת לא ריקה (U3). """ data = session.get('user_data') name = data.get('first_name') if isinstance(data, dict) else None name = name.strip() if isinstance(name, str) else '' return name or _THREAD_USER_FALLBACK_NAME def _author_initials(label: str, *, is_user: bool) -> str: """ראשי התיבות שבעיגול ליד התגובה, לפי העיצוב: משתמש — שתי האותיות הראשונות של השם ("אמ"); סוכן — השם כולו כשהוא עד שני תווים ("CC"), ואחרת האות הראשונה ("C", "G").""" text = ''.join(str(label or '').split()) if not text: return '?' if is_user: return text[:2] return text if len(text) <= 2 else text[:1].upper() def _author_tone(author: Any) -> str: """``data-tone`` של התגובה: ``user``, גוון של לקוח מוכר, או ``agent`` לכל סוכן אחר.""" if not isinstance(author, dict): return 'agent' if author.get('kind') == nt.AUTHOR_USER: return 'user' client = author.get('client') return _AGENT_CLIENT_TONES.get(client, 'agent') if isinstance(client, str) else 'agent' def _comment_out(comment: Any, *, user_name: str) -> Optional[Dict[str, Any]]: """תגובה כפי שהיא נשמרה, בצורה שהחלונית מציגה. השם נקבע ב-``nt.author_label`` — מקום אחד.""" if not isinstance(comment, dict): return None raw_author = comment.get('author') author: Dict[str, Any] = raw_author if isinstance(raw_author, dict) else {} is_user = author.get('kind') == nt.AUTHOR_USER label = nt.author_label(author, user_name=user_name) working_on = author.get('working_on') body = comment.get('body') return { 'id': str(comment.get('id') or ''), 'author_kind': nt.AUTHOR_USER if is_user else nt.AUTHOR_AGENT, 'author_label': label, 'author_initials': _author_initials(label, is_user=is_user), 'author_tone': _author_tone(author), 'working_on': working_on if isinstance(working_on, str) else '', 'body': body if isinstance(body, str) else '', 'created_at': _iso_utc(comment.get('created_at')), } def _thread_summary_out(row: Dict[str, Any]) -> Dict[str, Any]: """תקציר שרשור — מה שבועה שמעל הפתק צריכה. ``row`` מ-``nt.list_threads`` / ``nt.list_threads_for_notes``, ולכן הוא נושא ``number``.""" number = row.get('number') count = row.get('comment_count') return { 'id': str(row.get('_id')), 'number': number if isinstance(number, int) else None, 'status': nt.STATUS_RESOLVED if row.get('status') == nt.STATUS_RESOLVED else nt.STATUS_OPEN, 'comment_count': count if isinstance(count, int) else 0, 'awaits_user': nt.awaits_user(row), } def _thread_state_out(row: Dict[str, Any], *, number: Any, user_name: str) -> Dict[str, Any]: """התקציר, ועוד מי סגר ומתי — מה שהחלונית של שרשור פתוח מציגה בכותרת ובשורת "נפתר".""" out = _thread_summary_out({**row, 'number': number}) resolved_by = row.get('resolved_by') out['resolved_by_label'] = ( nt.author_label(resolved_by, user_name=user_name) if isinstance(resolved_by, dict) else '' ) out['resolved_at'] = _iso_utc(row.get('resolved_at')) return out def _with_thread_summaries(db: Any, user_id: int, notes: List[Dict[str, Any]]) -> bool: """מצרף לכל פתק ברשימה את תקצירי השרשורים שלו (``threads``) — שאילתה אחת לכל הרשימה. **``False`` כשהשאילתה נכשלה.** הפתקים עדיין מוחזרים, בלי ``threads``, והקורא מוסיף לתשובה ``threads_unavailable`` — כדי שהלקוח יבחין בין "אין שרשורים" לבין "לא נטענו", ולא יציג פתק בלי בועות כאילו אין עליו שיחה (``silent-fallback-to-worse-path``). רק ``PyMongoError`` נתפס: זה הסיכון שהמצב הזה הוצהר בשבילו, ובאג אחר עולה (``widened- exception-scope``). רשימה בלי פתקים אינה ניגשת לאוסף בכלל. """ ids = [note['id'] for note in notes if nt.is_canonical_note_id(note.get('id'))] by_note: Dict[str, List[Dict[str, Any]]] = {} if ids: try: by_note = nt.list_threads_for_notes( db[nt.NOTE_THREADS_COLLECTION], user_id=user_id, note_ids=ids ) except PyMongoError: logger.warning("sticky notes: loading thread summaries for %d notes failed", len(ids), exc_info=True) return False for note in notes: note['threads'] = [_thread_summary_out(row) for row in by_note.get(str(note.get('id')), [])] return True def _owned_note_id(db: Any, user_id: int, note_id: str) -> Union[str, Tuple[Any, int]]: """``note_id`` קנוני (``str``) של פתק שבבעלות המשתמש — או תשובת שגיאה מוכנה, ושום דבר לא נכתב. זו ההרשאה של כל ראוטי השרשורים, והיא קודמת לכל קריאה ל-``note_threads``: פתק של משתמש אחר ופתק שאינו קיים עונים אותו 404 — מבחוץ אי אפשר להבחין ביניהם (IDOR). ``str(oid)`` הוא הצורה שהשרשורים נשמרים תחתיה (hex באותיות קטנות). הקורא מבחין בין השניים ב-``isinstance``. """ try: oid = ObjectId(str(note_id)) except InvalidId: return jsonify({'ok': False, 'error': 'invalid_note_id'}), 400 if not db.sticky_notes.find_one({'_id': oid, 'user_id': int(user_id)}, {'_id': 1}): return jsonify({'ok': False, 'error': 'note_not_found'}), 404 return str(oid) def _no_store(resp: Any) -> Any: """תשובה שאסור לשמור בקאש — כמו כל תשובה של ראוטי הפתקים.""" resp.headers['Cache-Control'] = 'no-store' return resp def _thread_refusal(result: Dict[str, Any]): """סירוב של ``note_threads`` כתשובת HTTP — הקוד כמו שהוא, עם התקרה כשהיא חלק ממנו.""" code = str(result.get('error') or '') body: Dict[str, Any] = {'ok': False, 'error': code} for key in ('max', 'max_bytes'): if key in result: body[key] = result[key] return _no_store(jsonify(body)), _THREAD_ERROR_STATUS.get(code, 400) def _thread_written(db: Any, user_id: int, note_id: str, result: Dict[str, Any], *, status: int = 200): """התשובה לכתיבה שהצליחה — **ממה שהמסד החזיר**, לא ממה שנשלח. ``thread`` הוא המצב שהכתיבה הזו השאירה (``ReturnDocument.AFTER``, או הקריאה החוזרת אחרי יצירה), ``comment`` הוא התגובה שנכתבה כפי שנשמרה (``nt.stored_comment``), ו-``threads`` הם תקצירי כל השרשורים של הפתק, נקראים אחרי הכתיבה: בשביל הבועות, וכדי שהמספר של שרשור חדש ("שרשור N") יגיע מהמקום היחיד שמחשב אותו. **כשל בקריאה החוזרת אינו כשל של הכתיבה** — היא כבר קרתה. ``threads: None`` (או ``thread: None`` כשהקריאה שאחרי היצירה נכשלה) אומר ללקוח "לא ידוע, קרא שוב", ולא "אין שרשורים". """ user_name = _thread_user_name() rows: Optional[List[Dict[str, Any]]] try: rows = nt.list_threads(db[nt.NOTE_THREADS_COLLECTION], user_id=user_id, note_id=note_id) except PyMongoError: logger.warning( "sticky notes: reading the threads back after %s failed (note=%s)", result.get('action'), note_id, exc_info=True, ) rows = None thread_id = result.get('thread_id') number = next((row.get('number') for row in rows or [] if str(row.get('_id')) == thread_id), None) stored = result.get('thread') comment = nt.stored_comment(result) return _no_store(jsonify({ 'ok': True, 'action': result.get('action'), 'thread_id': thread_id, 'thread': ( _thread_state_out(stored, number=number, user_name=user_name) if isinstance(stored, dict) else None ), 'comment': _comment_out(comment, user_name=user_name) if comment else None, 'threads': [_thread_summary_out(row) for row in rows] if rows is not None else None, })), status @sticky_notes_bp.route('/note/<note_id>/threads', methods=['GET']) @require_auth @notes_rate_limit('thread_read', 180) @traced("sticky_notes.threads_list") def list_note_threads(note_id: str): """תקצירי השרשורים של פתק, בלי התגובות — לרענון הבועות.""" try: user_id = int(session['user_id']) db = get_db() nid = _owned_note_id(db, user_id, note_id) if not isinstance(nid, str): return nid rows = nt.list_threads(db[nt.NOTE_THREADS_COLLECTION], user_id=user_id, note_id=nid) return _no_store(jsonify({'ok': True, 'threads': [_thread_summary_out(row) for row in rows]})) except Exception: return _failed('threads_list') @sticky_notes_bp.route('/note/<note_id>/threads/<thread_id>', methods=['GET']) @require_auth @notes_rate_limit('thread_read', 180) @traced("sticky_notes.thread_get") def get_note_thread(note_id: str, thread_id: str): """שרשור אחד עם כל התגובות שלו — מה שהחלונית מציגה. **שרשור אחד בכל פעם, ולא כל שרשורי הפתק:** שרשור יכול להגיע ל- ``nt.MAX_THREAD_BODY_BYTES``, ומספר השרשורים על פתק אינו מוגבל. התקצירים של כולם (בלי תגובות) חוזרים יחד איתו, בשביל המספור והבועות. """ try: user_id = int(session['user_id']) db = get_db() nid = _owned_note_id(db, user_id, note_id) if not isinstance(nid, str): return nid tid = nt.parse_thread_id(thread_id) if tid is None: return _thread_refusal({'error': 'invalid_thread_id'}) coll = db[nt.NOTE_THREADS_COLLECTION] rows = nt.list_threads(coll, user_id=user_id, note_id=nid) row = next((r for r in rows if str(r.get('_id')) == tid), None) if row is None: return _thread_refusal({'error': 'thread_not_found'}) comments = nt.load_comments(coll, user_id=user_id, note_id=nid, thread_ids=[tid]).get(tid, []) user_name = _thread_user_name() thread = _thread_state_out(row, number=row.get('number'), user_name=user_name) thread['comments'] = [out for out in (_comment_out(c, user_name=user_name) for c in comments) if out] return _no_store(jsonify({ 'ok': True, 'thread': thread, 'threads': [_thread_summary_out(r) for r in rows], })) except Exception: return _failed('thread_get') @sticky_notes_bp.route('/note/<note_id>/threads', methods=['POST']) @require_auth @notes_rate_limit('thread_write', 60) @traced("sticky_notes.thread_create") def create_note_thread(note_id: str): """שרשור חדש על פתק, עם התגובה הראשונה שלו. גוף: ``{"body": "..."}``. השרשור נוצר רק עם תגובה — "השרשור נשמר עם שליחת התגובה הראשונה" (העיצוב). ``201``. """ try: user_id = int(session['user_id']) db = get_db() nid = _owned_note_id(db, user_id, note_id) if not isinstance(nid, str): return nid payload = _json_object() if payload is None: return jsonify({'ok': False, 'error': 'invalid_payload'}), 400 result = nt.create_thread( db[nt.NOTE_THREADS_COLLECTION], user_id=user_id, note_id=nid, author=nt.user_author(), body=payload.get('body'), ) if not result.get('ok'): return _thread_refusal(result) return _thread_written(db, user_id, nid, result, status=201) except Exception: return _failed('thread_create') @sticky_notes_bp.route('/note/<note_id>/threads/<thread_id>/comments', methods=['POST']) @require_auth @notes_rate_limit('thread_write', 60) @traced("sticky_notes.thread_reply") def reply_note_thread(note_id: str, thread_id: str): """תשובה בשרשור. גוף: ``{"body": "...", "reopen": true|false}``. ``reopen`` (ברירת מחדל ``true``) — תשובה על שרשור שנפתר פותחת אותו באותה כתיבה; ``false`` עונה ומשאיר אותו נפתר ("שליחה בלי פתיחה", לפי ההחלטה שבפתק על האפיון). ``reopen`` שאינו בוליאני ← 400 ``invalid_reopen``: אחרת ``"false"`` כמחרוזת היה נקרא כאמת ופותח שרשור. """ try: user_id = int(session['user_id']) db = get_db() nid = _owned_note_id(db, user_id, note_id) if not isinstance(nid, str): return nid payload = _json_object() if payload is None: return jsonify({'ok': False, 'error': 'invalid_payload'}), 400 reopen = payload.get('reopen', True) if not isinstance(reopen, bool): return jsonify({'ok': False, 'error': 'invalid_reopen'}), 400 result = nt.add_comment( db[nt.NOTE_THREADS_COLLECTION], user_id=user_id, note_id=nid, thread_id=thread_id, author=nt.user_author(), body=payload.get('body'), reopen=reopen, ) if not result.get('ok'): return _thread_refusal(result) return _thread_written(db, user_id, nid, result) except Exception: return _failed('thread_reply') @sticky_notes_bp.route('/note/<note_id>/threads/<thread_id>/resolve', methods=['POST']) @require_auth @notes_rate_limit('thread_write', 60) @traced("sticky_notes.thread_resolve") def resolve_note_thread(note_id: str, thread_id: str): """סגירת שרשור. גוף: ``{}``, או ``{"body": "..."}`` — משפט סיכום שנשמר כתגובה אחרונה **באותה כתיבה** (כפתור "✓ נפתר" כשיש טקסט בתיבה, כמו ``resolve`` עם ``body`` ב-MCP).""" try: user_id = int(session['user_id']) db = get_db() nid = _owned_note_id(db, user_id, note_id) if not isinstance(nid, str): return nid payload = _json_object() if payload is None: return jsonify({'ok': False, 'error': 'invalid_payload'}), 400 result = nt.resolve_thread( db[nt.NOTE_THREADS_COLLECTION], user_id=user_id, note_id=nid, thread_id=thread_id, author=nt.user_author(), body=payload.get('body'), ) if not result.get('ok'): return _thread_refusal(result) return _thread_written(db, user_id, nid, result) except Exception: return _failed('thread_resolve') @sticky_notes_bp.route('/note/<note_id>/threads/<thread_id>/reopen', methods=['POST']) @require_auth @notes_rate_limit('thread_write', 60) @traced("sticky_notes.thread_reopen") def reopen_note_thread(note_id: str, thread_id: str): """פתיחה מחדש של שרשור שנפתר, בלי תגובה — הכפתור "פתיחה מחדש".""" try: user_id = int(session['user_id']) db = get_db() nid = _owned_note_id(db, user_id, note_id) if not isinstance(nid, str): return nid result = nt.reopen_thread( db[nt.NOTE_THREADS_COLLECTION], user_id=user_id, note_id=nid, thread_id=thread_id, ) if not result.get('ok'): return _thread_refusal(result) return _thread_written(db, user_id, nid, result) except Exception: return _failed('thread_reopen') #: כמה תוצאות מוחזרות כשלא נתבקש אחרת, וכמה הכי הרבה אפשר לבקש. #: #: **התקרה אינה קוסמטית.** ``limit`` מגיע מה-URL, כלומר מחוץ לתהליך, ובלי #: חסם עליון בקשה אחת יכולה לגרור את כל מכסת המשתמש #: (:data:`~sticky_notes_target.MAX_NOTES_PER_USER`) לתוך המיון ולתוך #: התשובה. חמישים תוצאות הן יותר ממה שמישהו סורק בעין; מי שצריך יותר #: מצמצם את החיפוש. NOTE_SEARCH_DEFAULT_LIMIT = 30 NOTE_SEARCH_MAX_LIMIT = 100 #: אורך מרבי למחט החיפוש עצמה. #: #: קבוע **נפרד** מ-:data:`~sticky_notes_target.NOTE_SEARCH_PREVIEW_CHARS` #: אף ששניהם 200 היום: זה חוסם קלט שנכנס לרג'קס, וזה קובע כמה מהגוף מוצג. #: מספר משותף לשני דברים שאינם אותו דבר הוא מספר שמישהו ישנה בשביל האחד #: וישבור את השני. NOTE_SEARCH_MAX_NEEDLE = 200 def _search_limit(raw: Any) -> int: """‏``limit`` מהשאילתה, חסום משני הצדדים. ערך שאינו מספר אינו שגיאה אלא ברירת מחדל: הוא מגיע מ-URL שאפשר להקליד ביד, והפלת הבקשה על ``?limit=abc`` מחליפה חיפוש שעובד בשגיאה על פרמטר שאיש לא התכוון לשלוח. """ try: want = int(str(raw).strip()) except (TypeError, ValueError): return NOTE_SEARCH_DEFAULT_LIMIT if want < 1: return NOTE_SEARCH_DEFAULT_LIMIT return min(want, NOTE_SEARCH_MAX_LIMIT) #: **מה ממשיך אחרי הדירוג — רשימה של מה שנשאר, ולא של מה שיורד.** השדות #: ש-:func:`_as_search_hit` קורא, שדות היעד ש-``note_target_ref`` מסווג לפיהם #: (כל :data:`~sticky_notes_target.TARGET_FIELDS`, כדי שיעד שיתווסף יגיע מאליו), #: והשדות שנגזרו ב-``$addFields``. ``_id`` נשאר תמיד. הכללה ולא החרגה, כי החרגה #: אחרי ``$addFields`` השאירה את הגוף בקלט של ``$sort`` (הנימוק המלא — שלב 3 ב- #: :func:`build_note_search_pipeline`), וגם כי שדה כבד חדש בפתק לא ייגרר לכאן #: בשקט. _SEARCH_HIT_PROJECTION: Dict[str, int] = { field: 1 for field in ( "title", "color", "updated_at", *(name for names in TARGET_FIELDS.values() for name in names), "preview", "preview_truncated", "_title_hit", ) }
[תיעוד] def build_note_search_pipeline( user_id: int, needle: str, *, color_id: Optional[str], limit: int, include_archived: bool = False, ) -> List[Dict[str, Any]]: """הצינור שמחפש פתקים — **בנוי כאן, ונבדק כפי שנשלח**. סדר השלבים אינו קוסמטי, ושלושה מהם קיימים בגלל תקלות שכבר קרו בריפו הזה: 1. ``$match`` — הפילטר המשותף עם ה-MCP (:func:`~sticky_notes_target.note_search_filter`). **אותה פונקציה ולא העתק**: שני חיפושי פתקים שמתאימים אחרת הם שני מוצרים שמתחזים לאחד. גם הסתרת הארכיון (``include_archived``) קורית שם. 2. ``$addFields`` — הדירוג והתצוגה המקדימה, שניהם **לפני** שהגוף יורד, כי שניהם נגזרים ממנו. 3. ``$project`` **בהכללה** (:data:`_SEARCH_HIT_PROJECTION`) — רק מה שהתשובה צריכה ממשיך ל-``$sort``. בסדר ההפוך — מיון ואז היטלה — מונגו החזירה בפרודקשן שגיאה 292 (``QueryExceededMemoryLimitNoDiskUseAllowed``) והקוד נפל למסלול איטי; ``allowDiskUse`` אינו מציל כי Atlas מתעלם ממנו ב-Flex. מתועד ב-``tests/test_files_pipelines_drop_heavy_fields_early.py``. **ולמה הכללה ולא ``{"content": 0}``, שהיה כאן עד אוקטובר 2026.** החרגה שבאה אחרי ``$addFields`` לא הורידה את הגוף מהמיון: ``explain`` מול מונגו 8 הראה ``totalDataSizeSortedBytesEstimate`` של 1,792,484 בייטים על 200 פתקים ארוכים (תקרה 50), ו-57,260 עם הכללה — אותה תוצאה. זה ``amir-bug-patterns``, ``BY-STACK/mongodb.md`` דפוס 5, שנותן את הפונקציה הזו כדוגמה. נעול ב-``tests/test_note_archive_mongo.py``. 4. ``$sort`` — כותרת לפני גוף, ובתוך כל קבוצה לפי עדכון אחרון. ‏``false < true`` בסדר ה-BSON, ולכן ``-1`` מעלה את פגיעות הכותרת. 5. ``$limit`` עם **שורת סנטינל** (``limit + 1``), כמו ב-MCP: שורה נוספת שחזרה היא ראיה שיש עוד, ולא ניחוש מתוך ספירה ששווה לתקרה. 6. ``$unset`` — שדה העזר של הדירוג אינו חלק מהתשובה. **‏``$substrCP`` ו-``$strLenCP``, ולעולם לא הגרסאות ב-Bytes.** אות עברית היא שני בייטים, וחיתוך בבייטים על מספר שנספר בתווים נוחת באמצע תו ומפיל את השאילתה (``Location28657``). זה ``amir-bug-patterns`` H6, והאירוע עצמו קרה כאן. **הדירוג פשוט בכוונה.** אין כאן משקלות מכוילים: ``_calculate_relevance_score`` שהתיעוד מזכיר אינה קיימת בקוד כלל, וניקוד שאיש אינו יכול להסביר הוא ניקוד שאיש לא יתחזק. פתק הוא נושא שלם, ולכן השאלה היא **איזה** פתק — ומופע בשם הוא עדות חזקה יותר ממופע בגוף. """ from sticky_notes_target import NOTE_SEARCH_PREVIEW_CHARS, note_search_filter pattern = re.escape(str(needle)) body = {"$ifNull": ["$content", ""]} return [ {"$match": note_search_filter( int(user_id), needle, search_content=True, content_needle=needle, color_id=color_id, include_archived=include_archived, )}, {"$addFields": { "_title_hit": {"$regexMatch": { # ``$ifNull`` כי ל-61% מהפתקים במסד אין שדה ``title`` כלל, # ו-``$regexMatch`` על ``missing`` נופל בשגיאה במקום להחזיר # ``false``. "input": {"$ifNull": ["$title", ""]}, "regex": pattern, "options": "i", }}, "preview": {"$substrCP": [body, 0, NOTE_SEARCH_PREVIEW_CHARS]}, "preview_truncated": {"$gt": [{"$strLenCP": body}, NOTE_SEARCH_PREVIEW_CHARS]}, }}, {"$project": _SEARCH_HIT_PROJECTION}, {"$sort": {"_title_hit": -1, "updated_at": -1}}, {"$limit": int(limit) + 1}, {"$unset": "_title_hit"}, ]
def _as_search_hit(doc: Dict[str, Any]) -> Dict[str, Any]: """שורת תוצאה — זהות, תצוגה מקדימה, ו**לעולם לא הגוף**. ``url`` מצביע על ``/note/<id>`` ואינו מורכב כאן משדות היעד. ‏``webapp/boards_ui.note_permalink`` הוא הבונה היחיד של קישור לפתק, והוא מכיר את שלושת הסוגים — כולל רביעי שיתווסף. צרכן שמרכיב URL בעצמו הוא בדיוק מה שהפונקציה ההיא נכתבה כדי לבטל. """ from sticky_notes_target import note_target_ref note_id = str(doc.get('_id')) updated = doc.get('updated_at') hit = { 'id': note_id, 'url': f'/note/{note_id}', 'title': str(doc.get('title', '') or ''), 'preview': _coerce_content_from_doc(doc.get('preview', '')), 'preview_truncated': bool(doc.get('preview_truncated')), 'color': note_color_hex(doc.get('color')), 'color_id': note_color_id(doc.get('color')), 'updated_at': updated.isoformat() if isinstance(updated, datetime) else None, } hit.update(note_target_ref(doc)) return hit @sticky_notes_bp.route('/search', methods=['GET']) @require_auth @notes_rate_limit('search', 60) @traced("sticky_notes.search") def search_notes(): """חיפוש בפתקים של המשתמש — בשם ובגוף, חוצה את שלושת היעדים. **אותה התאמה כמו ב-MCP.** שניהם עוברים דרך :func:`~sticky_notes_target.note_search_filter`, ולכן חיפוש של אותה מילה בעמוד ובסוכן מחזיר את אותה קבוצת פתקים. מה שנבדל הוא רק מה שכל צרכן **מציג**: ה-MCP מחזיר הפניות בלבד, והעמוד מוסיף תצוגה מקדימה. **הרשאות: הפתקים של המשתמש, כל שלושת הסוגים** — בדיוק כמו ``codekeeper_search_notes``, שאינו מגודר לאדמין (הגידור שם חל על ``list_repo_notes``/``create_repo_note`` בלבד). גם ``/api/sticky-notes/repo/…`` בוובאפ נושא ``@require_auth`` בלבד, כלומר גייט אדמין כאן היה מסתיר מהמשתמש פתקים שהוא כבר מושך בקריאה אחרת — גייט שאינו מגן על דבר. **פתקי הארכיון — רק כשביקשו.** ``include_archived=1`` מחזיר אותם, וזו התיבה "כלול ארכיון" בעמוד; בלעדיו הם מוסתרים בפילטר המשותף, כמו ב- ``codekeeper_search_notes`` בלי הפרמטר באותו שם. התשובה מחזירה את ``include_archived`` שהוחל, כמו ``color_id``. """ try: _ensure_indexes() user_id = int(session['user_id']) # המחט היא מה שהוקלד, אחרי ``strip`` בלבד — בלי פענוח, כי הפילטר משווה # אותה לגוף כמו שהוא שמור (``_note_content_from_request``). ה-``strip`` # נשאר בכוונה: ``?q=%20%20`` היה אחרת מחט "לא ריקה" שמתורגמת לרג'קס # שתופס כל פתק שיש בו שני רווחים — כלומר בדיוק ה"הכול" שהבדיקה למטה # נועדה למנוע. needle = str(request.args.get('q', '') or '').strip() if not needle: # **ולא "הכול".** שאילתה ריקה על פילטר רג'קס תופסת כל פתק, כלומר # משיבה תשובה לשאלה שלא נשאלה. אותה הכרעה כבר מקודדת # ב-``note_search_filter``, שמעלה ``ValueError`` על מחט ריקה. return jsonify({'ok': False, 'error': 'empty_query'}), 400 if len(needle) > NOTE_SEARCH_MAX_NEEDLE: # **סירוב, לא חיתוך.** מחט שנחתכה מחפשת את הקידומת שלה, כלומר עונה # על שאלה אחרת מזו שנשאלה — ו-``codekeeper_search_notes`` כבר עונה # כאן ``query_too_long``. שדה החיפוש בעמוד מוגבל לאותה תקרה. return jsonify({'ok': False, 'error': 'query_too_long', 'max': NOTE_SEARCH_MAX_NEEDLE}), 400 needle_error = note_search_needle_error(needle) if needle_error: return jsonify({'ok': False, 'error': needle_error}), 400 color_id = str(request.args.get('color', '') or '').strip().lower() if color_id: from sticky_notes_target import NOTE_COLOR_ORDER if color_id not in NOTE_COLOR_ORDER: # רשימת המזהים התקינים בתשובה, בדיוק כמו ב-``mcp_server``: # קורא שיודע מה חוקי יכול לתקן, וקורא שקיבל ``ok`` על מסנן # שלא הוחל מדווח דבר לא נכון. return jsonify({ 'ok': False, 'error': 'invalid_color', 'allowed': list(NOTE_COLOR_ORDER), }), 400 else: color_id = None # **"כלול ארכיון" — ``1`` או כלום, וכל ערך אחר נדחה.** הערך מגיע מה-query, # כלומר מחוץ לתהליך, ו-``bool()`` עליו היה הופך ``"false"`` ו-``"0"`` לאמת — # חושף את הארכיון דווקא כשביקשו שלא. וסירוב ולא התעלמות, מאותה סיבה # כמו ``invalid_color``: קורא שקיבל ``ok`` על מסנן שלא הוחל מדווח דבר # לא נכון. העמוד שולח ``1`` רק כשהתיבה מסומנת. raw_archived = str(request.args.get('include_archived', '') or '').strip() if raw_archived not in ('', '0', '1'): return jsonify({ 'ok': False, 'error': 'invalid_include_archived', 'allowed': ['0', '1'], }), 400 include_archived = raw_archived == '1' limit = _search_limit(request.args.get('limit')) db = get_db() pipeline = build_note_search_pipeline( user_id, needle, color_id=color_id, limit=limit, include_archived=include_archived, ) cursor = db.sticky_notes.aggregate(pipeline) rows = list(cursor) if cursor is not None else [] truncated = len(rows) > limit if truncated: rows = rows[:limit] resp = jsonify({ 'ok': True, 'query': needle, 'color_id': color_id or '', 'include_archived': include_archived, 'count': len(rows), 'truncated': truncated, 'results': [_as_search_hit(doc) for doc in rows if isinstance(doc, dict)], }) try: resp.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate' except Exception: pass return resp except Exception as e: try: emit_event("sticky_notes_search_error", severity="anomaly", error=str(e)) except Exception: pass return jsonify({'ok': False, 'error': 'Failed to search notes'}), 500