udata 14.0.3.dev1__py3-none-any.whl → 14.7.3.dev4__py3-none-any.whl

udata/core/organization/api.py

@@ -21,6 +21,7 @@ from udata.core.discussions.api import discussion_fields
 from udata.core.discussions.csv import DiscussionCsvAdapter
 from udata.core.discussions.models import Discussion
 from udata.core.followers.api import FollowAPI
+from udata.core.legal.mails import add_send_legal_notice_argument, send_legal_notice_on_deletion
 from udata.core.reuse.models import Reuse
 from udata.core.storages.api import (
     image_parser,
@@ -137,6 +138,9 @@ class OrganizationListAPI(API):
         return organization, 201
 
 
+org_delete_parser = add_send_legal_notice_argument(api.parser())
+
+
 @ns.route("/<org:org>/", endpoint="organization", doc=common_doc)
 @api.response(404, "Organization not found")
 @api.response(410, "Organization has been deleted")
@@ -170,12 +174,16 @@ class OrganizationAPI(API):
 
     @api.secure
     @api.doc("delete_organization")
+    @api.expect(org_delete_parser)
     @api.response(204, "Organization deleted")
     def delete(self, org):
         """Delete a organization given its identifier"""
+        args = org_delete_parser.parse_args()
         if org.deleted:
             api.abort(410, "Organization has been deleted")
         EditOrganizationPermission(org).test()
+        send_legal_notice_on_deletion(org, args)
+
         org.deleted = datetime.utcnow()
         org.save()
         return "", 204
@@ -383,12 +391,13 @@ class MembershipRequestAPI(API):
 
         form = api.validate(MembershipRequestForm, membership_request)
 
-        if not membership_request:
+        if membership_request:
+            form.populate_obj(membership_request)
+            org.save()
+        else:
             membership_request = MembershipRequest()
-            org.requests.append(membership_request)
-
-        form.populate_obj(membership_request)
-        org.save()
+            form.populate_obj(membership_request)
+            org.add_membership_request(membership_request)
 
         notify_membership_request.delay(str(org.id), str(membership_request.id))
 
@@ -424,6 +433,7 @@ class MembershipAcceptAPI(MembershipAPI):
         org.members.append(member)
         org.count_members()
         org.save()
+        MembershipRequest.after_handle.send(membership_request, org=org)
 
         notify_membership_response.delay(str(org.id), str(membership_request.id))
 
@@ -446,6 +456,7 @@ class MembershipRefuseAPI(MembershipAPI):
         membership_request.refusal_comment = form.comment.data
 
         org.save()
+        MembershipRequest.after_handle.send(membership_request, org=org)
 
         notify_membership_response.delay(str(org.id), str(membership_request.id))
 

udata/core/organization/api_fields.py

@@ -14,7 +14,7 @@ org_ref_fields = api.inherit(
         "name": fields.String(description="The organization name", readonly=True),
         "acronym": fields.String(description="The organization acronym"),
         "slug": fields.String(
-            description="The organization string used as permalink", required=True
+            description="The organization string used as permalink", readonly=True
         ),
         "uri": fields.String(
             attribute=lambda o: o.self_api_url(),
@@ -122,12 +122,12 @@ member_fields = api.model(
 org_fields = api.model(
     "Organization",
     {
-        "id": fields.String(description="The organization identifier", required=True),
+        "id": fields.String(description="The organization identifier", readonly=True),
         "name": fields.String(description="The organization name", required=True),
         "acronym": fields.String(description="The organization acronym"),
         "url": fields.String(description="The organization website URL"),
         "slug": fields.String(
-            description="The organization string used as permalink", required=True
+            description="The organization string used as permalink", readonly=True
         ),
         "description": fields.Markdown(
             description="The organization description in Markdown", required=True

udata/core/organization/apiv2.py

@@ -3,7 +3,6 @@ from flask import request
 from udata import search
 from udata.api import API, apiv2
 from udata.core.contact_point.api_fields import contact_point_fields
-from udata.utils import multi_to_dict
 
 from .api_fields import member_fields, org_fields, org_page_fields
 from .permissions import EditOrganizationPermission
@@ -16,7 +15,7 @@ apiv2.inherit("ContactPoint", contact_point_fields)
 
 
 ns = apiv2.namespace("organizations", "Organization related operations")
-search_parser = OrganizationSearch.as_request_parser()
+search_parser = OrganizationSearch.as_request_parser(store_missing=False)
 
 DEFAULT_SORTING = "-created_at"
 
@@ -30,8 +29,8 @@ class OrganizationSearchAPI(API):
     @apiv2.marshal_with(org_page_fields)
     def get(self):
         """Search all organizations"""
-        search_parser.parse_args()
-        return search.query(OrganizationSearch, **multi_to_dict(request.args))
+        args = search_parser.parse_args()
+        return search.query(OrganizationSearch, **args)
 
 
 @ns.route("/<org:org>/extras/", endpoint="organization_extras")

udata/core/organization/mails.py

@@ -16,7 +16,7 @@ def new_membership_request(org: Organization, request: MembershipRequest) -> Mai
                 )
             ),
             LabelledContent(_("Reason for the request:"), request.comment),
-            MailCTA(_("See the request"), cdata_url(f"/admin/organizations/{org.id}/members/")),
+            MailCTA(_("See the request"), cdata_url(f"/admin/organizations/{org.id}/members")),
         ],
     )
 

udata/core/organization/models.py

@@ -7,7 +7,7 @@ from flask_babel import LazyString
 from mongoengine.signals import post_save, pre_save
 from werkzeug.utils import cached_property
 
-from udata.api_fields import field
+from udata.api_fields import field, generate_fields
 from udata.core.activity.models import Auditable
 from udata.core.badges.models import Badge, BadgeMixin, BadgesList
 from udata.core.linkable import Linkable
@@ -21,6 +21,7 @@ from udata.uris import cdata_url
 
 from .constants import (
     ASSOCIATION,
+    BIGGEST_LOGO_SIZE,
     CERTIFIED,
     COMPANY,
     DEFAULT_ROLE,
@@ -44,6 +45,7 @@ BADGES: dict[str, LazyString] = {
 }
 
 
+@generate_fields()
 class Team(db.EmbeddedDocument):
     name = db.StringField(required=True)
     slug = db.SlugField(
@@ -54,6 +56,7 @@ class Team(db.EmbeddedDocument):
     members = db.ListField(db.ReferenceField("User"))
 
 
+@generate_fields()
 class Member(db.EmbeddedDocument):
     user = db.ReferenceField("User")
     role = db.StringField(choices=list(ORG_ROLES), default=DEFAULT_ROLE)
@@ -64,6 +67,7 @@ class Member(db.EmbeddedDocument):
         return ORG_ROLES[self.role]
 
 
+@generate_fields()
 class MembershipRequest(db.EmbeddedDocument):
     """
     Pending organization membership requests
@@ -81,6 +85,9 @@ class MembershipRequest(db.EmbeddedDocument):
     comment = db.StringField()
     refusal_comment = db.StringField()
 
+    after_create = Signal()
+    after_handle = Signal()
+
     @property
     def status_label(self):
         return MEMBERSHIP_STATUS[self.status]
@@ -110,20 +117,27 @@ class OrganizationBadge(Badge):
 
 
 class OrganizationBadgeMixin(BadgeMixin):
-    badges = field(BadgesList(OrganizationBadge), **BadgeMixin.default_badges_list_params)
+    badges = field(
+        BadgesList(OrganizationBadge), show_as_ref=True, **BadgeMixin.default_badges_list_params
+    )
     __badges__ = BADGES
 
 
+@generate_fields()
 class Organization(
     Auditable, WithMetrics, OrganizationBadgeMixin, Linkable, db.Datetimed, db.Document
 ):
-    name = field(db.StringField(required=True))
-    acronym = field(db.StringField(max_length=128))
+    name = field(db.StringField(required=True), show_as_ref=True)
+    acronym = field(db.StringField(max_length=128), show_as_ref=True)
     slug = field(
         db.SlugField(max_length=255, required=True, populate_from="name", update=True, follow=True),
         auditable=False,
+        show_as_ref=True,
+    )
+    description = field(
+        db.StringField(required=True),
+        markdown=True,
     )
-    description = field(db.StringField(required=True))
     url = field(db.URLField())
     image_url = field(db.StringField())
     logo = field(
@@ -132,7 +146,11 @@ class Organization(
             basename=default_image_basename,
             max_size=LOGO_MAX_SIZE,
             thumbnails=LOGO_SIZES,
-        )
+        ),
+        show_as_ref=True,
+        thumbnail_info={
+            "size": BIGGEST_LOGO_SIZE,
+        },
     )
     business_number_id = field(db.StringField(max_length=ORG_BID_SIZE_LIMIT))
 
@@ -162,6 +180,8 @@ class Organization(
         "auto_create_index_on_save": True,
     }
 
+    verbose_name = _("organization")
+
     def __str__(self):
         return self.name or ""
 
@@ -198,7 +218,7 @@ class Organization(
         cls.before_save.send(document)
 
     def self_web_url(self, **kwargs):
-        return cdata_url(f"/organizations/{self._link_id(**kwargs)}/", **kwargs)
+        return cdata_url(f"/organizations/{self._link_id(**kwargs)}", **kwargs)
 
     def self_api_url(self, **kwargs):
         return url_for(
@@ -257,6 +277,14 @@ class Organization(
                 return request
         return None
 
+    @field(description="Link to the API endpoint for this organization", show_as_ref=True)
+    def uri(self, *args, **kwargs):
+        return self.self_api_url(*args, **kwargs)
+
+    @field(description="Link to the udata web page for this organization", show_as_ref=True)
+    def page(self, *args, **kwargs):
+        return self.self_web_url(*args, **kwargs)
+
     @classmethod
     def get(cls, id_or_slug):
         obj = cls.objects(slug=id_or_slug).first()
@@ -304,6 +332,11 @@ class Organization(
     def views_count(self):
         return self.metrics.get("views", 0)
 
+    def add_membership_request(self, membership_request):
+        self.requests.append(membership_request)
+        self.save()
+        MembershipRequest.after_create.send(membership_request, org=self)
+
     def count_members(self):
         self.metrics["members"] = len(self.members)
         self.save(signal_kwargs={"ignores": ["post_save"]})

udata/core/organization/notifications.py

@@ -1,10 +1,94 @@
 import logging
 
+from udata.api_fields import field, generate_fields
+from udata.core.organization.api_fields import org_ref_fields
+from udata.core.organization.models import MembershipRequest, Organization
+from udata.core.user.api_fields import user_ref_fields
+from udata.core.user.models import User
 from udata.features.notifications.actions import notifier
+from udata.models import db
 
 log = logging.getLogger(__name__)
 
 
+@generate_fields()
+class MembershipRequestNotificationDetails(db.EmbeddedDocument):
+    request_organization = field(
+        db.ReferenceField(Organization),
+        readonly=True,
+        nested_fields=org_ref_fields,
+        auditable=False,
+        allow_null=True,
+        filterable={},
+    )
+    request_user = field(
+        db.ReferenceField(User),
+        nested_fields=user_ref_fields,
+        readonly=True,
+        auditable=False,
+        allow_null=True,
+        filterable={},
+    )
+
+
+@MembershipRequest.after_create.connect
+def on_new_membership_request(request: MembershipRequest, **kwargs):
+    from udata.features.notifications.models import Notification
+
+    """Create notification when a new membership request is created"""
+    organization = kwargs.get("org")
+
+    if organization is None:
+        return
+
+    # Get all admin users for the organization
+    admin_users = [member.user for member in organization.members if member.role == "admin"]
+
+    # For each pending request, check if a notification already exists
+    for admin_user in admin_users:
+        try:
+            # Check if notification already exists
+            existing = Notification.objects(
+                user=admin_user,
+                details__request_organization=organization,
+                details__request_user=request.user,
+            ).first()
+
+            if not existing:
+                notification = Notification(
+                    user=admin_user,
+                    details=MembershipRequestNotificationDetails(
+                        request_organization=organization, request_user=request.user
+                    ),
+                )
+                notification.created_at = request.created
+                notification.save()
+        except Exception as e:
+            log.error(
+                f"Error creating notification for user {admin_user.id} "
+                f"and organization {organization.id}: {e}"
+            )
+
+
+@MembershipRequest.after_handle.connect
+def on_handle_membership_request(request: MembershipRequest, **kwargs):
+    from udata.features.notifications.models import Notification
+
+    organization = kwargs.get("org")
+
+    if organization is None:
+        return
+
+    notifications = Notification.objects(
+        details__request_organization=organization,
+        details__request_user=request.user,
+    )
+
+    for notification in notifications:
+        notification.handled_at = request.handled_on
+        notification.save()
+
+
 @notifier("membership_request")
 def membership_request_notifications(user):
     """Notify user about pending membership requests"""

udata/core/organization/permissions.py

@@ -2,7 +2,7 @@ from collections import namedtuple
 from functools import partial
 
 from udata.auth import Permission, current_user, identity_loaded
-from udata.models import Organization
+from udata.core.organization.models import Organization
 from udata.utils import get_by
 
 OrganizationNeed = namedtuple("organization", ("role", "value"))

udata/core/organization/tasks.py

@@ -1,5 +1,6 @@
 from udata.core import storages
 from udata.core.badges.tasks import notify_new_badge
+from udata.features.notifications.models import Notification
 from udata.models import Activity, ContactPoint, Dataset, Follow, Transfer
 from udata.search import reindex
 from udata.tasks import get_logger, job, task
@@ -25,6 +26,8 @@ def purge_organizations(self):
         Transfer.objects(owner=organization).delete()
         # Remove related contact points
         ContactPoint.objects(organization=organization).delete()
+        # Remove related notifications
+        Notification.objects.with_organization_in_details(organization).delete()
         # Store datasets for later reindexation
         d_ids = [d.id for d in Dataset.objects(organization=organization)]
         # Remove organization's logo in all sizes

udata/core/pages/models.py

@@ -83,6 +83,55 @@ class LinksListBloc(BlocWithTitleMixin, Bloc):
     links = field(db.EmbeddedDocumentListField(LinkInBloc))
 
 
+HERO_COLORS = ("primary", "green", "purple")
+
+
+@generate_fields()
+class HeroBloc(Bloc):
+    title = field(db.StringField(required=True))
+    description = field(db.StringField())
+    color = field(db.StringField(choices=HERO_COLORS))
+
+
+@generate_fields()
+class MarkdownBloc(Bloc):
+    # Not using BlocWithTitleMixin because title should be optional here
+    title = field(db.StringField())
+    subtitle = field(db.StringField())
+    content = field(
+        db.StringField(required=True),
+        markdown=True,
+    )
+
+
+BLOCS_DISALLOWED_IN_ACCORDION = ("AccordionListBloc", "HeroBloc")
+
+
+def check_no_recursive_blocs(blocs, **kwargs):
+    for bloc in blocs:
+        if bloc.__class__.__name__ in BLOCS_DISALLOWED_IN_ACCORDION:
+            raise db.ValidationError(
+                f"{bloc.__class__.__name__} cannot be nested inside an accordion"
+            )
+
+
+@generate_fields()
+class AccordionItemBloc(db.EmbeddedDocument):
+    title = field(db.StringField(required=True))
+    content = field(
+        db.EmbeddedDocumentListField(Bloc),
+        generic=True,
+        checks=[check_no_recursive_blocs],
+    )
+
+
+@generate_fields()
+class AccordionListBloc(Bloc):
+    title = field(db.StringField())
+    description = field(db.StringField())
+    items = field(db.EmbeddedDocumentListField(AccordionItemBloc))
+
+
 @generate_fields()
 class Page(Auditable, Owned, Datetimed, db.Document):
     blocs = field(

udata/core/pages/tests/test_api.py

@@ -2,7 +2,7 @@ from flask import url_for
 
 from udata.core.dataset import tasks
 from udata.core.dataset.factories import DatasetFactory
-from udata.core.pages.models import Page
+from udata.core.pages.models import AccordionItemBloc, AccordionListBloc, Page
 from udata.core.user.factories import AdminFactory
 from udata.tests.api import APITestCase
 
@@ -103,3 +103,167 @@ class PageAPITest(APITestCase):
 
         response = self.get(url_for("api.page", page=page_id))
         self.assert200(response)
+
+    def test_hero_bloc(self):
+        self.login()
+
+        response = self.post(
+            url_for("api.pages"),
+            {
+                "blocs": [
+                    {
+                        "class": "HeroBloc",
+                        "title": "Welcome to our portal",
+                        "description": "Discover our datasets",
+                        "color": "primary",
+                    }
+                ],
+            },
+        )
+        self.assert201(response)
+
+        self.assertEqual("HeroBloc", response.json["blocs"][0]["class"])
+        self.assertEqual("Welcome to our portal", response.json["blocs"][0]["title"])
+        self.assertEqual("Discover our datasets", response.json["blocs"][0]["description"])
+        self.assertEqual("primary", response.json["blocs"][0]["color"])
+
+        page = Page.objects().first()
+        response = self.get(url_for("api.page", page=page))
+        self.assert200(response)
+
+        self.assertEqual("HeroBloc", response.json["blocs"][0]["class"])
+        self.assertEqual("Welcome to our portal", response.json["blocs"][0]["title"])
+        self.assertEqual("Discover our datasets", response.json["blocs"][0]["description"])
+        self.assertEqual("primary", response.json["blocs"][0]["color"])
+
+    def test_accordion_bloc(self):
+        self.login()
+        datasets = DatasetFactory.create_batch(2)
+
+        response = self.post(
+            url_for("api.pages"),
+            {
+                "blocs": [
+                    {
+                        "class": "AccordionListBloc",
+                        "title": "FAQ",
+                        "description": "Frequently asked questions",
+                        "items": [
+                            {
+                                "title": "What is udata?",
+                                "content": [
+                                    {
+                                        "class": "LinksListBloc",
+                                        "title": "Related links",
+                                        "links": [
+                                            {
+                                                "title": "Documentation",
+                                                "url": "https://doc.data.gouv.fr",
+                                            },
+                                        ],
+                                    }
+                                ],
+                            },
+                            {
+                                "title": "How to use datasets?",
+                                "content": [
+                                    {
+                                        "class": "DatasetsListBloc",
+                                        "title": "Example datasets",
+                                        "datasets": [str(d.id) for d in datasets],
+                                    }
+                                ],
+                            },
+                            {
+                                "title": "What is markdown?",
+                                "content": [
+                                    {
+                                        "class": "MarkdownBloc",
+                                        "content": "# Hello\n\nThis is **bold** text.",
+                                    }
+                                ],
+                            },
+                        ],
+                    }
+                ],
+            },
+        )
+        self.assert201(response)
+
+        bloc = response.json["blocs"][0]
+        self.assertEqual("AccordionListBloc", bloc["class"])
+        self.assertEqual("FAQ", bloc["title"])
+        self.assertEqual("Frequently asked questions", bloc["description"])
+        self.assertEqual(3, len(bloc["items"]))
+
+        self.assertEqual("What is udata?", bloc["items"][0]["title"])
+        self.assertEqual("LinksListBloc", bloc["items"][0]["content"][0]["class"])
+        self.assertEqual("Documentation", bloc["items"][0]["content"][0]["links"][0]["title"])
+
+        self.assertEqual("How to use datasets?", bloc["items"][1]["title"])
+        self.assertEqual("DatasetsListBloc", bloc["items"][1]["content"][0]["class"])
+        self.assertEqual(2, len(bloc["items"][1]["content"][0]["datasets"]))
+
+        self.assertEqual("What is markdown?", bloc["items"][2]["title"])
+        self.assertEqual("MarkdownBloc", bloc["items"][2]["content"][0]["class"])
+
+        page = Page.objects().first()
+        self.assertIsInstance(page.blocs[0], AccordionListBloc)
+        self.assertIsInstance(page.blocs[0].items[0], AccordionItemBloc)
+        self.assertEqual("What is udata?", page.blocs[0].items[0].title)
+
+        response = self.get(url_for("api.page", page=page))
+        self.assert200(response)
+        self.assertEqual("AccordionListBloc", response.json["blocs"][0]["class"])
+        self.assertEqual(3, len(response.json["blocs"][0]["items"]))
+
+        response = self.put(
+            url_for("api.page", page=page),
+            {
+                "blocs": [
+                    {
+                        "class": "AccordionListBloc",
+                        "title": "Updated FAQ",
+                        "items": [
+                            {
+                                "title": "Single question",
+                                "content": [],
+                            }
+                        ],
+                    }
+                ],
+            },
+        )
+        self.assert200(response)
+        self.assertEqual("Updated FAQ", response.json["blocs"][0]["title"])
+        self.assertIsNone(response.json["blocs"][0]["description"])
+        self.assertEqual(1, len(response.json["blocs"][0]["items"]))
+        self.assertEqual("Single question", response.json["blocs"][0]["items"][0]["title"])
+
+    def test_accordion_bloc_cannot_be_nested(self):
+        self.login()
+
+        response = self.post(
+            url_for("api.pages"),
+            {
+                "blocs": [
+                    {
+                        "class": "AccordionListBloc",
+                        "title": "FAQ",
+                        "items": [
+                            {
+                                "title": "Question",
+                                "content": [
+                                    {
+                                        "class": "AccordionListBloc",
+                                        "title": "Nested accordion",
+                                        "items": [],
+                                    }
+                                ],
+                            },
+                        ],
+                    }
+                ],
+            },
+        )
+        self.assert400(response)