First commit

app/api/notifications.py

@@ -0,0 +1,165 @@
+"""
+app/api/notifications.py
+------------------------
+Mobile API endpoint for polling in-app notifications.
+
+GET  /api/v1/notifications
+     Returns unread notifications for the authenticated user.
+     Accepts ?since=<ISO 8601> to fetch only notifications created after
+     that datetime — used by the iPad poller to avoid re-delivering already-
+     seen alerts.  Returns a maximum of 50 notifications per call.
+
+PATCH /api/v1/notifications/mark-read
+     Marks a list of notification IDs as read.
+     Request JSON: { "ids": [1, 2, 3] }
+"""
+
+import logging
+from datetime import datetime
+
+import sqlalchemy.exc
+from flask import Blueprint, request, g
+from app import db
+from app.models.notification import Notification
+from app.api.errors import api_ok, api_error
+from app.api.decorators import jwt_required
+
+logger = logging.getLogger(__name__)
+
+bp = Blueprint('api_notifications', __name__)
+
+
+def _parse_since(value):
+    """Parse ?since= ISO 8601 string; return None on failure."""
+    if not value:
+        return None
+    for fmt in ('%Y-%m-%dT%H:%M:%S', '%Y-%m-%dT%H:%M:%S.%f', '%Y-%m-%d'):
+        try:
+            return datetime.strptime(value, fmt)
+        except (ValueError, TypeError):
+            pass
+    return None
+
+
+def _build_payload(notifications, has_event_type):
+    """Serialise notification rows to dicts. Works before and after phase17 migration."""
+    rows = []
+    for n in notifications:
+        rows.append({
+            'id':         n.id,
+            'title':      n.title,
+            'body':       n.body,
+            'event_type': (n.event_type if has_event_type else None),
+            'issue_id':   n.issue_id,
+            'created_at': n.created_at.strftime('%Y-%m-%dT%H:%M:%S'),
+        })
+    return rows
+
+
+@bp.route('/notifications', methods=['GET'])
+@jwt_required
+def list_notifications():
+    """
+    Return unread notifications for the authenticated user.
+
+    Query parameters
+    ----------------
+    since   ISO 8601 datetime  Only return notifications created after this time.
+    limit   int (default 50, max 50)
+
+    Response 200
+    ------------
+    { "ok": true, "data": { "notifications": [...], "count": N } }
+    """
+    user  = g.api_user
+    since = _parse_since(request.args.get('since'))
+    limit = min(int(request.args.get('limit', 50)), 50)
+
+    def _run_orm():
+        q = Notification.query.filter_by(user_id=user.id, is_read=False)
+        if since:
+            q = q.filter(Notification.created_at > since)
+        return q.order_by(Notification.created_at.asc()).limit(limit).all()
+
+    # Attempt the ORM query (works after phase17 migration runs).
+    # If the event_type column does not yet exist in the DB, MySQL raises
+    # OperationalError: Unknown column 'notifications.event_type' in SELECT.
+    # getattr() does NOT protect against this — the failure is at the SQL layer.
+    # The fallback raw-SQL query selects only the pre-phase17 columns so the
+    # endpoint stays functional before the migration runs.
+    try:
+        notifications  = _run_orm()
+        has_event_type = True
+    except sqlalchemy.exc.OperationalError:
+        db.session.rollback()
+        sql_parts = (
+            "SELECT id, title, body, issue_id, is_read, created_at "
+            "FROM notifications "
+            "WHERE user_id = :uid AND is_read = 0 "
+        )
+        params = {'uid': user.id, 'lim': limit}
+        if since:
+            sql_parts += "AND created_at > :since "
+            params['since'] = since
+        sql_parts += "ORDER BY created_at ASC LIMIT :lim"
+
+        rows = db.session.execute(db.text(sql_parts), params).fetchall()
+
+        class _Row:
+            """Minimal shim so _build_payload works with raw SQL rows."""
+            __slots__ = ('id', 'title', 'body', 'issue_id', 'created_at')
+            def __init__(self, r):
+                self.id         = r[0]
+                self.title      = r[1]
+                self.body       = r[2]
+                self.issue_id   = r[3]
+                self.created_at = r[5]
+
+        notifications  = [_Row(r) for r in rows]
+        has_event_type = False
+
+    payload = _build_payload(notifications, has_event_type)
+
+    logger.info('API NOTIFICATIONS | list | user=%s | since=%s | count=%d | has_event_type=%s',
+                user.username, since, len(payload), has_event_type)
+
+    return api_ok({'notifications': payload, 'count': len(payload)})
+
+
+@bp.route('/notifications/mark-read', methods=['PATCH'])
+@jwt_required
+def mark_read():
+    """
+    Mark a list of notification IDs as read.
+
+    Request JSON: { "ids": [1, 2, 3] }
+
+    Response 200
+    ------------
+    { "ok": true, "data": { "marked": 3 } }
+    """
+    user = g.api_user
+    data = request.get_json(silent=True) or {}
+    ids  = data.get('ids') or []
+
+    if not isinstance(ids, list):
+        return api_error('ids must be a list', 400)
+
+    if ids:
+        updated = (
+            Notification.query
+            .filter(
+                Notification.id.in_(ids),
+                Notification.user_id == user.id,
+            )
+            .all()
+        )
+        for n in updated:
+            n.is_read = True
+        db.session.commit()
+        count = len(updated)
+    else:
+        count = 0
+
+    logger.info('API NOTIFICATIONS | mark_read | user=%s | count=%d', user.username, count)
+    return api_ok({'marked': count})