udata 10.0.8.dev33570__py2.py3-none-any.whl → 10.0.8.dev33610__py2.py3-none-any.whl

udata/api/__init__.py

@@ -15,6 +15,7 @@ from flask import (
     url_for,
 )
 from flask_restx import Api, Resource
+from flask_restx.reqparse import RequestParser
 from flask_storage import UnauthorizedFileType
 
 from udata import entrypoints, tracking
@@ -138,7 +139,7 @@ class UDataApi(Api):
         response.headers["WWW-Authenticate"] = challenge
         return response
 
-    def page_parser(self):
+    def page_parser(self) -> RequestParser:
         parser = self.parser()
         parser.add_argument("page", type=int, default=1, location="args", help="The page to fetch")
         parser.add_argument(
@@ -251,9 +252,9 @@ def handle_value_error(error):
 def handle_unauthorized_file_type(error):
     """Error occuring when the user try to upload a non-allowed file type"""
     url = url_for("api.allowed_extensions", _external=True)
-    msg = (
-        "This file type is not allowed." "The allowed file type list is available at {url}"
-    ).format(url=url)
+    msg = ("This file type is not allowed.The allowed file type list is available at {url}").format(
+        url=url
+    )
     return {"message": msg}, 400
 
 

udata/commands/db.py

@@ -9,11 +9,8 @@ import mongoengine
 from bson import DBRef
 
 from udata import migrations
-from udata import models as core_models
-from udata.api import oauth2 as oauth2_models
 from udata.commands import cli, cyan, echo, green, magenta, red, white, yellow
-from udata.harvest import models as harvest_models
-from udata.mongo import db
+from udata.mongo.document import get_all_models
 
 # Date format used to for display
 DATE_FORMAT = "%Y-%m-%d %H:%M"
@@ -148,16 +145,8 @@ def check_references(models_to_check):
 
     errors = collections.defaultdict(int)
 
-    _models = []
-    for models in core_models, harvest_models, oauth2_models:
-        _models += [
-            elt
-            for _, elt in models.__dict__.items()
-            if isinstance(elt, type) and issubclass(elt, (db.Document))
-        ]
-
     references = []
-    for model in set(_models):
+    for model in get_all_models():
         if model.__name__ == "Activity":
             print("Skipping Activity model, scheduled for deprecation")
             continue
@@ -291,7 +280,7 @@ def check_references(models_to_check):
 
     print("Those references will be inspected:")
     for reference in references:
-        print(f'- {reference["repr"]}({reference["destination"]}) — {reference["type"]}')
+        print(f"- {reference['repr']}({reference['destination']}) — {reference['type']}")
     print("")
 
     total = 0
@@ -305,7 +294,7 @@ def check_references(models_to_check):
         with click.progressbar(qs, length=count) as models:
             for obj in models:
                 for reference in model_references:
-                    key = f'\t- {reference["repr"]}({reference["destination"]}) — {reference["type"]}…'
+                    key = f"\t- {reference['repr']}({reference['destination']}) — {reference['type']}…"
                     if key not in errors[model]:
                         errors[model][key] = 0
 
@@ -316,7 +305,7 @@ def check_references(models_to_check):
                             except mongoengine.errors.DoesNotExist:
                                 errors[model][key] += 1
                                 print_and_save(
-                                    f'\t{model.__name__}#{obj.id} have a broken reference for `{reference["name"]}`'
+                                    f"\t{model.__name__}#{obj.id} have a broken reference for `{reference['name']}`"
                                 )
                         elif reference["type"] == "list":
                             attr_list = getattr(obj, reference["name"], [])
@@ -326,7 +315,7 @@ def check_references(models_to_check):
                                 if isinstance(sub, DBRef):
                                     errors[model][key] += 1
                                     print_and_save(
-                                        f'\t{model.__name__}#{obj.id} have a broken reference for {reference["name"]}[{i}]'
+                                        f"\t{model.__name__}#{obj.id} have a broken reference for {reference['name']}[{i}]"
                                     )
                         elif reference["type"] == "embed_list":
                             p1, p2 = reference["name"].split("__")
@@ -366,7 +355,7 @@ def check_references(models_to_check):
                                         f"\t{model.__name__}#{obj.id} have a broken reference for {p1}.{p2}[{i}]"
                                     )
                         else:
-                            print_and_save(f'Unknown ref type {reference["type"]}')
+                            print_and_save(f"Unknown ref type {reference['type']}")
                     except mongoengine.errors.FieldDoesNotExist:
                         print_and_save(
                             f"[ERROR for {model.__name__} {obj.id}] {traceback.format_exc()}"

udata/core/dataset/csv.py

@@ -90,6 +90,7 @@ class ResourcesCsvAdapter(csv.NestedAdapter):
         ("harvest.modified_at", lambda o: o.harvest and o.harvest.modified_at),
         ("schema_name", "schema.name"),
         ("schema_version", "schema.version"),
-        ("preview_url", lambda o: o.preview_url or False),
+        ("preview_url", lambda o: o.preview_url or None),
+        ("extras", lambda o: o.extras),
     )
     attribute = "resources"

udata/core/post/api.py

@@ -15,6 +15,8 @@ from udata.core.user.api_fields import user_ref_fields
 from .forms import PostForm
 from .models import Post
 
+DEFAULT_SORTING = "-published"
+
 ns = api.namespace("posts", "Posts related operations")
 
 post_fields = api.model(
@@ -58,9 +60,7 @@ post_page_fields = api.model("PostPage", fields.pager(post_fields))
 
 parser = api.page_parser()
 
-parser.add_argument(
-    "sort", type=str, default="-created_at", location="args", help="The sorting attribute"
-)
+parser.add_argument("sort", type=str, location="args", help="The sorting attribute")
 parser.add_argument(
     "with_drafts",
     type=bool,
@@ -68,6 +68,9 @@ parser.add_argument(
     location="args",
     help="`True` also returns the unpublished posts (only for super-admins)",
 )
+parser.add_argument(
+    "q", type=str, location="args", help="query string to search through resources titles"
+)
 
 
 @ns.route("/", endpoint="posts")
@@ -84,7 +87,12 @@ class PostsAPI(API):
         if not (AdminPermission().can() and args["with_drafts"]):
             posts = posts.published()
 
-        return posts.order_by(args["sort"]).paginate(args["page"], args["page_size"])
+        if args["q"]:
+            phrase_query = " ".join([f'"{elem}"' for elem in args["q"].split(" ")])
+            posts = posts.search_text(phrase_query)
+
+        sort = args["sort"] or ("$text_score" if args["q"] else None) or DEFAULT_SORTING
+        return posts.order_by(sort).paginate(args["page"], args["page_size"])
 
     @api.doc("create_post")
     @api.secure(admin_permission)

udata/core/post/models.py

@@ -42,6 +42,11 @@ class Post(db.Datetimed, db.Document):
         "indexes": [
             "-created_at",
             "-published",
+            {
+                "fields": ["$name", "$headline", "$content"],
+                "default_language": "french",
+                "weights": {"name": 10, "headline": 5, "content": 4},
+            },
         ],
         "queryset_class": PostQuerySet,
     }

udata/core/post/tests/test_api.py

@@ -1,4 +1,3 @@
-import pytest
 from flask import url_for
 
 from udata.core.dataset.factories import DatasetFactory
@@ -6,50 +5,68 @@ from udata.core.post.factories import PostFactory
 from udata.core.post.models import Post
 from udata.core.reuse.factories import ReuseFactory
 from udata.core.user.factories import AdminFactory
+from udata.tests.api import APITestCase
 from udata.tests.helpers import assert200, assert201, assert204
 
 
-@pytest.mark.usefixtures("clean_db")
-class PostsAPITest:
-    modules = []
-
-    def test_post_api_list(self, api):
+class PostsAPITest(APITestCase):
+    def test_post_api_list(self):
         """It should fetch a post list from the API"""
         PostFactory.create_batch(3)
         draft = PostFactory(published=None)
 
-        response = api.get(url_for("api.posts"))
+        response = self.get(url_for("api.posts"))
         assert200(response)
         # Response should not contain the unpublished post
         assert len(response.json["data"]) == 3
 
-        api.login(AdminFactory())
+        self.login(AdminFactory())
 
-        response = api.get(url_for("api.posts"))
+        response = self.get(url_for("api.posts"))
         assert200(response)
 
         assert len(response.json["data"]) == 3
         assert str(draft.id) not in [post["id"] for post in response.json["data"]]
 
-        response = api.get(url_for("api.posts", with_drafts=True))
+        response = self.get(url_for("api.posts", with_drafts=True))
         assert200(response)
 
         assert len(response.json["data"]) == 4
         assert str(draft.id) in [post["id"] for post in response.json["data"]]
 
-    def test_post_api_get(self, api):
+    def test_search_post(self):
+        """It should fetch a post list from the API"""
+        name_match = PostFactory(name="Foobar", published="2025-01-01")
+        content_match = PostFactory(content="Foobar", published="2025-01-02")
+        PostFactory(content="Something else")
+
+        response = self.get(url_for("api.posts", q="Foobar"))
+        assert200(response)
+        assert len(response.json["data"]) == 2
+
+        assert response.json["data"][0]["id"] == str(name_match.id)
+        assert response.json["data"][1]["id"] == str(content_match.id)
+
+        response = self.get(url_for("api.posts", q="Foobar", sort="-published"))
+        assert200(response)
+        assert len(response.json["data"]) == 2
+
+        assert response.json["data"][1]["id"] == str(name_match.id)
+        assert response.json["data"][0]["id"] == str(content_match.id)
+
+    def test_post_api_get(self):
         """It should fetch a post from the API"""
         post = PostFactory()
-        response = api.get(url_for("api.post", post=post))
+        response = self.get(url_for("api.post", post=post))
         assert200(response)
 
-    def test_post_api_create(self, api):
+    def test_post_api_create(self):
         """It should create a post from the API"""
         data = PostFactory.as_dict()
         data["datasets"] = [str(d.id) for d in data["datasets"]]
         data["reuses"] = [str(r.id) for r in data["reuses"]]
-        api.login(AdminFactory())
-        response = api.post(url_for("api.posts"), data)
+        self.login(AdminFactory())
+        response = self.post(url_for("api.posts"), data)
         assert201(response)
         assert Post.objects.count() == 1
         post = Post.objects.first()
@@ -58,62 +75,62 @@ class PostsAPITest:
         for reuse, expected in zip(post.reuses, data["reuses"]):
             assert str(reuse.id) == expected
 
-    def test_post_api_update(self, api):
+    def test_post_api_update(self):
         """It should update a post from the API"""
         post = PostFactory()
         data = post.to_dict()
         data["content"] = "new content"
-        api.login(AdminFactory())
-        response = api.put(url_for("api.post", post=post), data)
+        self.login(AdminFactory())
+        response = self.put(url_for("api.post", post=post), data)
         assert200(response)
         assert Post.objects.count() == 1
         assert Post.objects.first().content == "new content"
 
-    def test_post_api_update_with_related_dataset_and_reuse(self, api):
+    def test_post_api_update_with_related_dataset_and_reuse(self):
         """It should update a post from the API with related dataset and reuse"""
-        api.login(AdminFactory())
+        self.login(AdminFactory())
         post = PostFactory()
         data = post.to_dict()
         data["content"] = "new content"
 
         # Add datasets
         data["datasets"] = [DatasetFactory().to_dict()]
-        response = api.put(url_for("api.post", post=post), data)
+        response = self.put(url_for("api.post", post=post), data)
         assert200(response)
 
         # Add reuses to the post value returned by the previous api call
         data = response.json
         data["reuses"] = [ReuseFactory().to_dict()]
-        response = api.put(url_for("api.post", post=post), data)
+        response = self.put(url_for("api.post", post=post), data)
         assert200(response)
 
         assert len(response.json["datasets"]) == 1
         assert len(response.json["reuses"]) == 1
 
-    def test_post_api_delete(self, api):
+    def test_post_api_delete(self):
         """It should delete a post from the API"""
         post = PostFactory()
-        with api.user(AdminFactory()):
-            response = api.delete(url_for("api.post", post=post))
+        self.login(AdminFactory())
+        response = self.delete(url_for("api.post", post=post))
         assert204(response)
         assert Post.objects.count() == 0
 
-    def test_post_api_publish(self, api):
+    def test_post_api_publish(self):
         """It should update a post from the API"""
         post = PostFactory(published=None)
-        api.login(AdminFactory())
-        response = api.post(url_for("api.publish_post", post=post))
+        self.login(AdminFactory())
+        response = self.post(url_for("api.publish_post", post=post))
         assert200(response)
         assert Post.objects.count() == 1
 
         post.reload()
         assert post.published is not None
 
-    def test_post_api_unpublish(self, api):
+    def test_post_api_unpublish(self):
         """It should update a post from the API"""
         post = PostFactory()
-        api.login(AdminFactory())
-        response = api.delete(url_for("api.publish_post", post=post))
+        self.login(AdminFactory())
+        response = self.delete(url_for("api.publish_post", post=post))
         assert200(response)
         assert Post.objects.count() == 1
 

udata/mongo/document.py

@@ -19,6 +19,20 @@ def serialize(value):
         return value
 
 
+def get_all_models():
+    from udata import models as core_models
+    from udata.api import oauth2 as oauth2_models
+    from udata.harvest import models as harvest_models
+
+    all_models = set()
+    for models in core_models, harvest_models, oauth2_models:
+        for model in models.__dict__.values():
+            if isinstance(model, type) and issubclass(model, (UDataDocument)):
+                all_models.add(model)
+
+    return all_models
+
+
 class UDataDocument(Document):
     meta = {
         "abstract": True,