support for default notification rules

Rules with NULL id_role are used if there are no rules for current user.

backend/geonature/core/notifications/models.py

@@ -3,9 +3,11 @@
 """
 import datetime
 
+import sqlalchemy as sa
 from sqlalchemy import ForeignKey
 from sqlalchemy.sql import select
 from sqlalchemy.orm import relationship
+from flask import g
 
 from utils_flask_sqla.serializers import serializable
 from pypnusershub.db.models import User
@@ -85,23 +87,57 @@ class Notification(db.Model):
     user = db.relationship(User)
 
 
+class NotificationRuleQuery(db.Query):
+    def filter_by_role_with_defaults(self, id_role=None):
+        if id_role is None:
+            id_role = g.current_user.id_role
+        cte = (
+            NotificationRule.query.filter(
+                sa.or_(
+                    NotificationRule.id_role.is_(None),
+                    NotificationRule.id_role == id_role,
+                )
+            )
+            .distinct(NotificationRule.code_category, NotificationRule.code_method)
+            .order_by(
+                NotificationRule.code_category.desc(),
+                NotificationRule.code_method.desc(),
+                NotificationRule.id_role.asc(),
+            )
+            .cte("cte")
+        )
+        return self.filter(NotificationRule.id == cte.c.id)
+
+
 @serializable
 class NotificationRule(db.Model):
     __tablename__ = "t_notifications_rules"
     __table_args__ = (
         db.UniqueConstraint(
             "id_role", "code_method", "code_category", name="un_role_method_category"
         ),
+        db.Index(
+            "un_method_category",
+            "code_method",
+            "code_category",
+            unique=True,
+            postgresql_ops={
+                "where": sa.text("id_role IS NULL"),
+            },
+        ),
         {"schema": "gn_notifications"},
     )
+    query_class = NotificationRuleQuery
+
     id = db.Column(db.Integer, primary_key=True)
-    id_role = db.Column(db.Integer, ForeignKey(User.id_role), nullable=False)
+    id_role = db.Column(db.Integer, ForeignKey(User.id_role), nullable=True)
     code_method = db.Column(db.Unicode, ForeignKey(NotificationMethod.code), nullable=False)
     code_category = db.Column(
         db.Unicode,
         ForeignKey(NotificationCategory.code),
         nullable=False,
     )
+    subscribed = db.Column(db.Boolean, nullable=False)
 
     method = relationship(NotificationMethod)
     category = relationship(NotificationCategory)

backend/geonature/core/notifications/routes.py

@@ -80,28 +80,20 @@ def update_notification(id_notification):
 @routes.route("/rules", methods=["GET"])
 @permissions.login_required
 def list_notification_rules():
-    rules = (
-        NotificationRule.query.filter(NotificationRule.id_role == g.current_user.id_role)
-        .order_by(
-            NotificationRule.code_category.desc(),
-            NotificationRule.code_method.desc(),
-        )
-        .options(
-            joinedload("method"),
-            joinedload("category"),
-        )
+    rules = NotificationRule.query.filter_by_role_with_defaults().options(
+        joinedload("method"),
+        joinedload("category"),
     )
     result = [
         rule.as_dict(
             fields=[
-                "id",
-                "id_role",
                 "code_method",
                 "code_category",
                 "method.label",
                 "method.description",
                 "category.label",
                 "category.description",
+                "subscribed",
             ]
         )
         for rule in rules.all()
@@ -121,39 +113,45 @@ def delete_all_notifications():
 
 
 # add rule for user
-@routes.route("/rules", methods=["PUT"])
+@routes.route(
+    "/rules/category/<code_category>/method/<code_method>/subscribe",
+    methods=["POST"],
+    defaults={"subscribe": True},
+)
+@routes.route(
+    "/rules/category/<code_category>/method/<code_method>/unsubscribe",
+    methods=["POST"],
+    defaults={"subscribe": False},
+)
 @permissions.login_required
-def create_rule():
-
-    requestData = request.get_json()
-    if requestData is None:
-        raise BadRequest("Empty request data")
-
-    code_method = requestData.get("code_method")
-    if not code_method:
-        raise BadRequest("Missing method")
-    if not db.session.query(
-        NotificationMethod.query.filter_by(code=str(code_method)).exists()
-    ).scalar():
-        raise BadRequest("Invalid method")
-
-    code_category = requestData.get("code_category")
-    if not code_category:
-        raise BadRequest("Missing category")
+def update_rule(code_category, code_method, subscribe):
     if not db.session.query(
         NotificationCategory.query.filter_by(code=str(code_category)).exists()
     ).scalar():
         raise BadRequest("Invalid category")
+    if not db.session.query(
+        NotificationMethod.query.filter_by(code=str(code_method)).exists()
+    ).scalar():
+        raise BadRequest("Invalid method")
 
     # Create new rule for current user
-    new_rule = NotificationRule(
+    rule = NotificationRule.query.filter_by(
         id_role=g.current_user.id_role,
         code_method=code_method,
         code_category=code_category,
-    )
-    db.session.add(new_rule)
+    ).one_or_none()
+    if rule:
+        rule.subscribed = subscribe
+    else:
+        rule = NotificationRule(
+            id_role=g.current_user.id_role,
+            code_method=code_method,
+            code_category=code_category,
+            subscribed=subscribe,
+        )
+        db.session.add(rule)
     db.session.commit()
-    return jsonify(new_rule.as_dict())
+    return jsonify(rule.as_dict(fields=["code_method", "code_category", "subscribed"]))
 
 
 # Delete all rules for current user
@@ -167,18 +165,6 @@ def delete_all_rules():
     return jsonify(nbRulesDeleted)
 
 
-# Delete a specific rule
-@routes.route("/rules/<int:id>", methods=["DELETE"])
-@permissions.login_required
-def delete_rule(id):
-    rule = NotificationRule.query.get_or_404(id)
-    if rule.user != g.current_user:
-        raise Forbidden
-    db.session.delete(rule)
-    db.session.commit()
-    return "", 204
-
-
 # Get all availabe method for notification
 @routes.route("/methods", methods=["GET"])
 @permissions.login_required

backend/geonature/core/notifications/utils.py

@@ -2,6 +2,7 @@
 
 from jinja2 import Template
 from flask import current_app
+import sqlalchemy as sa
 
 from pypnusershub.db.models import User
 
@@ -40,9 +41,9 @@ def dispatch_notification(category, role, title=None, url=None, *, content=None,
     # add role, title and url to rendering context
     context = {"role": role, "title": title, "url": url, **context}
 
-    rules = NotificationRule.query.filter(
-        NotificationRule.id_role == role.id_role,
+    rules = NotificationRule.query.filter_by_role_with_defaults(role.id_role).filter(
         NotificationRule.code_category == category.code,
+        NotificationRule.subscribed.is_(sa.true()),
     )
     for rule in rules.all():
         if content:

backend/geonature/migrations/versions/09a637f06b96_default_notification_rules.py

@@ -0,0 +1,59 @@
+"""Default notification rules
+
+Revision ID: 09a637f06b96
+Revises: 4cf3fd5d06f5
+Create Date: 2023-01-13 09:55:53.525869
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "09a637f06b96"
+down_revision = "4cf3fd5d06f5"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Allows NULL id_role to define default rules
+    op.alter_column(
+        schema="gn_notifications",
+        table_name="t_notifications_rules",
+        column_name="id_role",
+        nullable=True,
+    )
+    # Create partial index on (code_method, code_category) where id_role IS NULL.
+    # This allows to create only one default rule for each method / category couple.
+    op.create_index(
+        schema="gn_notifications",
+        table_name="t_notifications_rules",
+        index_name="un_method_category",
+        columns=["code_method", "code_category"],
+        postgresql_where=sa.text("id_role IS NULL"),
+    )
+    op.add_column(
+        schema="gn_notifications",
+        table_name="t_notifications_rules",
+        column=sa.Column("subscribed", sa.Boolean, nullable=False, server_default=sa.true()),
+    )
+
+
+def downgrade():
+    op.drop_column(
+        schema="gn_notifications",
+        table_name="t_notifications_rules",
+        column_name="subscribed",
+    )
+    op.drop_index(
+        schema="gn_notifications",
+        table_name="t_notifications_rules",
+        index_name="un_method_category",
+    )
+    op.alter_column(
+        schema="gn_notifications",
+        table_name="t_notifications_rules",
+        column_name="id_role",
+        nullable=False,
+    )