udata 10.4.1.dev35201__py2.py3-none-any.whl → 10.4.2__py2.py3-none-any.whl

udata/core/dataset/models.py

@@ -19,6 +19,7 @@ from werkzeug.utils import cached_property
 from udata.api_fields import field
 from udata.app import cache
 from udata.core import storages
+from udata.core.activity.models import Auditable
 from udata.core.owned import Owned, OwnedQuerySet
 from udata.frontend.markdown import mdstrip
 from udata.i18n import lazy_gettext as _
@@ -540,45 +541,57 @@ class DatasetBadgeMixin(BadgeMixin):
     __badges__ = BADGES
 
 
-class Dataset(WithMetrics, DatasetBadgeMixin, Owned, db.Document):
-    title = db.StringField(required=True)
-    acronym = db.StringField(max_length=128)
+class Dataset(Auditable, WithMetrics, DatasetBadgeMixin, Owned, db.Document):
+    title = field(db.StringField(required=True))
+    acronym = field(db.StringField(max_length=128))
     # /!\ do not set directly the slug when creating or updating a dataset
     # this will break the search indexation
-    slug = db.SlugField(
-        max_length=255, required=True, populate_from="title", update=True, follow=True
+    slug = field(
+        db.SlugField(
+            max_length=255, required=True, populate_from="title", update=True, follow=True
+        ),
+        auditable=False,
     )
-    description = db.StringField(required=True, default="")
-    license = db.ReferenceField("License")
+    description = field(db.StringField(required=True, default=""))
+    license = field(db.ReferenceField("License"))
 
-    tags = db.TagListField()
-    resources = db.ListField(db.EmbeddedDocumentField(Resource))
+    tags = field(db.TagListField())
+    resources = field(db.ListField(db.EmbeddedDocumentField(Resource)), auditable=False)
 
-    private = db.BooleanField(default=False)
-    frequency = db.StringField(choices=list(UPDATE_FREQUENCIES.keys()))
-    frequency_date = db.DateTimeField(verbose_name=_("Future date of update"))
-    temporal_coverage = db.EmbeddedDocumentField(db.DateRange)
-    spatial = db.EmbeddedDocumentField(SpatialCoverage)
-    schema = db.EmbeddedDocumentField(Schema)
+    private = field(db.BooleanField(default=False))
+    frequency = field(db.StringField(choices=list(UPDATE_FREQUENCIES.keys())))
+    frequency_date = field(db.DateTimeField(verbose_name=_("Future date of update")))
+    temporal_coverage = field(db.EmbeddedDocumentField(db.DateRange))
+    spatial = field(db.EmbeddedDocumentField(SpatialCoverage))
+    schema = field(db.EmbeddedDocumentField(Schema))
 
-    ext = db.MapField(db.GenericEmbeddedDocumentField())
-    extras = db.ExtrasField()
-    harvest = db.EmbeddedDocumentField(HarvestDatasetMetadata)
+    ext = field(db.MapField(db.GenericEmbeddedDocumentField()), auditable=False)
+    extras = field(db.ExtrasField(), auditable=False)
+    harvest = field(db.EmbeddedDocumentField(HarvestDatasetMetadata), auditable=False)
 
-    quality_cached = db.DictField()
+    quality_cached = field(db.DictField(), auditable=False)
 
-    featured = db.BooleanField(required=True, default=False)
+    featured = field(
+        db.BooleanField(required=True, default=False),
+        auditable=False,
+    )
 
-    contact_points = db.ListField(db.ReferenceField("ContactPoint", reverse_delete_rule=db.PULL))
+    contact_points = field(
+        db.ListField(db.ReferenceField("ContactPoint", reverse_delete_rule=db.PULL))
+    )
 
-    created_at_internal = DateTimeField(
-        verbose_name=_("Creation date"), default=datetime.utcnow, required=True
+    created_at_internal = field(
+        DateTimeField(verbose_name=_("Creation date"), default=datetime.utcnow, required=True),
+        auditable=False,
     )
-    last_modified_internal = DateTimeField(
-        verbose_name=_("Last modification date"), default=datetime.utcnow, required=True
+    last_modified_internal = field(
+        DateTimeField(
+            verbose_name=_("Last modification date"), default=datetime.utcnow, required=True
+        ),
+        auditable=False,
     )
-    deleted = db.DateTimeField()
-    archived = db.DateTimeField()
+    deleted = field(db.DateTimeField(), auditable=False)
+    archived = field(db.DateTimeField())
 
     def __str__(self):
         return self.title or ""
@@ -654,18 +667,6 @@ class Dataset(WithMetrics, DatasetBadgeMixin, Owned, db.Document):
     def pre_save(cls, sender, document, **kwargs):
         cls.before_save.send(document)
 
-    @classmethod
-    def post_save(cls, sender, document, **kwargs):
-        if "post_save" in kwargs.get("ignores", []):
-            return
-        cls.after_save.send(document)
-        if kwargs.get("created"):
-            cls.on_create.send(document)
-        else:
-            cls.on_update.send(document)
-        if document.deleted:
-            cls.on_delete.send(document)
-
     def clean(self):
         super(Dataset, self).clean()
         if self.frequency in LEGACY_FREQUENCIES:
@@ -897,10 +898,6 @@ class Dataset(WithMetrics, DatasetBadgeMixin, Owned, db.Document):
 
         return result
 
-    @property
-    def downloads(self):
-        return sum(resource.metrics.get("views", 0) for resource in self.resources)
-
     @staticmethod
     def normalize_score(score):
         """
@@ -977,7 +974,12 @@ class Dataset(WithMetrics, DatasetBadgeMixin, Owned, db.Document):
     def remove_resource(self, resource):
         # Deletes resource's file from file storage
         if resource.fs_filename is not None:
-            storages.resources.delete(resource.fs_filename)
+            try:
+                storages.resources.delete(resource.fs_filename)
+            except FileNotFoundError as e:
+                log.error(
+                    f"File not found while deleting resource #{resource.id} in dataset {self.id}: {e}"
+                )
 
         self.resources.remove(resource)
         self.on_resource_removed.send(self.__class__, document=self, resource_id=resource.id)
@@ -1045,19 +1047,19 @@ class Dataset(WithMetrics, DatasetBadgeMixin, Owned, db.Document):
         from udata.models import Discussion
 
         self.metrics["discussions"] = Discussion.objects(subject=self, closed=None).count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_reuses(self):
         from udata.models import Reuse
 
         self.metrics["reuses"] = Reuse.objects(datasets=self).visible().count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_followers(self):
         from udata.models import Follow
 
         self.metrics["followers"] = Follow.objects(until=None).followers(self).count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
 
 pre_init.connect(Dataset.pre_init, sender=Dataset)

udata/core/dataset/rdf.py

@@ -769,7 +769,7 @@ def dataset_from_rdf(graph: Graph, dataset=None, node=None, remote_url_prefix: s
     # Support dct:abstract if dct:description is missing (sometimes used instead)
     description = d.value(DCT.description) or d.value(DCT.abstract)
     dataset.description = sanitize_html(description)
-    dataset.frequency = frequency_from_rdf(d.value(DCT.accrualPeriodicity))
+    dataset.frequency = frequency_from_rdf(d.value(DCT.accrualPeriodicity)) or dataset.frequency
     roles = [  # Imbricated list of contact points for each role
         contact_points_from_rdf(d, rdf_entity, role, dataset)
         for rdf_entity, role in CONTACT_POINT_ENTITY_TO_ROLE.items()

udata/core/metrics/commands.py

@@ -60,6 +60,7 @@ def update(
             site.count_max_org_followers()
             site.count_max_org_reuses()
             site.count_max_org_datasets()
+            site.count_stock_metrics()
         except Exception as e:
             log.info(f"Error during update: {e}")
 

udata/core/metrics/helpers.py

@@ -0,0 +1,102 @@
+import logging
+from collections import OrderedDict
+from datetime import datetime, timedelta
+from typing import Dict, List, Union
+
+import requests
+from bson import ObjectId
+from dateutil.rrule import MONTHLY, rrule
+from flask import current_app
+from mongoengine import QuerySet
+from pymongo.command_cursor import CommandCursor
+
+log = logging.getLogger(__name__)
+
+
+def get_last_13_months() -> List[str]:
+    dstart = datetime.today().replace(day=1) - timedelta(days=365)
+    months = rrule(freq=MONTHLY, count=13, dtstart=dstart)
+    return [month.strftime("%Y-%m") for month in months]
+
+
+def compute_monthly_metrics(metrics_data: List[Dict], metrics_labels: List[str]) -> OrderedDict:
+    # Initialize default monthly_metrics
+    monthly_metrics = OrderedDict(
+        (month, {label: 0 for label in metrics_labels}) for month in get_last_13_months()
+    )
+    # Update monthly_metrics with metrics_data values
+    for entry in metrics_data:
+        entry_month = entry["metric_month"]
+        if entry_month in monthly_metrics:
+            for metric_label in metrics_labels:
+                label = f"monthly_{metric_label}"
+                monthly_metrics[entry_month][metric_label] = entry.get(label) or 0
+    return monthly_metrics
+
+
+def metrics_by_label(monthly_metrics: Dict, metrics_labels: List[str]) -> List[OrderedDict]:
+    metrics_by_label = []
+    for label in metrics_labels:
+        metrics_by_label.append(
+            OrderedDict((month, monthly_metrics[month][label]) for month in monthly_metrics)
+        )
+    return metrics_by_label
+
+
+def get_metrics_for_model(
+    model: str, id: Union[str, ObjectId, None], metrics_labels: List[str]
+) -> List[OrderedDict]:
+    """
+    Get distant metrics for a particular model object
+    """
+    if not current_app.config["METRICS_API"]:
+        # TODO: How to best deal with no METRICS_API, prevent calling or return empty?
+        # raise ValueError("missing config METRICS_API to use this function")
+        return [{} for _ in range(len(metrics_labels))]
+    models = model + "s" if id else model  # TODO: not clean of a hack
+    model_metrics_api = f"{current_app.config['METRICS_API']}/{models}/data/"
+    try:
+        params = {"metric_month__sort": "desc"}
+        if id:
+            params[f"{model}_id__exact"] = id
+        res = requests.get(model_metrics_api, params)
+        res.raise_for_status()
+        monthly_metrics = compute_monthly_metrics(res.json()["data"], metrics_labels)
+        return metrics_by_label(monthly_metrics, metrics_labels)
+    except requests.exceptions.RequestException as e:
+        log.exception(f"Error while getting metrics for {model}({id}): {e}")
+        return [{} for _ in range(len(metrics_labels))]
+
+
+def compute_monthly_aggregated_metrics(aggregation_res: CommandCursor) -> OrderedDict:
+    monthly_metrics = OrderedDict((month, 0) for month in get_last_13_months())
+    for monthly_count in aggregation_res:
+        year, month = monthly_count["_id"].split("-")
+        monthly_label = year + "-" + month.zfill(2)
+        if monthly_label in monthly_metrics:
+            monthly_metrics[monthly_label] = monthly_count["count"]
+    return monthly_metrics
+
+
+def get_stock_metrics(objects: QuerySet, date_label: str = "created_at") -> OrderedDict:
+    """
+    Get stock metrics for a particular model object
+    """
+    pipeline = [
+        {"$match": {date_label: {"$gte": datetime.now() - timedelta(days=365)}}},
+        {
+            "$group": {
+                "_id": {
+                    "$concat": [
+                        {"$substr": [{"$year": f"${date_label}"}, 0, 4]},
+                        "-",
+                        {"$substr": [{"$month": f"${date_label}"}, 0, 12]},
+                    ]
+                },
+                "count": {"$sum": 1},
+            }
+        },
+    ]
+    aggregation_res = objects.aggregate(*pipeline)
+
+    return compute_monthly_aggregated_metrics(aggregation_res)

udata/core/metrics/models.py

@@ -8,6 +8,7 @@ class WithMetrics(object):
     metrics = field(
         db.DictField(),
         readonly=True,
+        auditable=False,
     )
 
     __metrics_keys__ = []

udata/core/metrics/tasks.py

@@ -24,5 +24,6 @@ def compute_site_metrics(self):
     site.count_max_org_followers()
     site.count_max_org_reuses()
     site.count_max_org_datasets()
+    site.count_stock_metrics()
     # Sending signal
     on_site_metrics_computed.send(site)

udata/core/organization/activities.py

@@ -32,6 +32,7 @@ def on_user_created_organization(organization):
 
 
 @Organization.on_update.connect
-def on_user_updated_organization(organization):
+def on_user_updated_organization(organization, **kwargs):
+    changed_fields = kwargs.get("changed_fields", [])
     if current_user and current_user.is_authenticated:
-        UserUpdatedOrganization.emit(organization, organization)
+        UserUpdatedOrganization.emit(organization, organization, changed_fields)

udata/core/organization/api.py

@@ -12,6 +12,7 @@ from udata.core.badges import api as badges_api
 from udata.core.badges.fields import badge_fields
 from udata.core.contact_point.api import ContactPointApiParser
 from udata.core.contact_point.api_fields import contact_point_page_fields
+from udata.core.dataservices.csv import DataserviceCsvAdapter
 from udata.core.dataservices.models import Dataservice
 from udata.core.dataset.api import DatasetApiParser
 from udata.core.dataset.api_fields import dataset_page_fields
@@ -178,6 +179,16 @@ class DatasetsCsvAPI(API):
         return csv.stream(adapter, "{0}-datasets".format(org.slug))
 
 
+@ns.route("/<org:org>/dataservices.csv", endpoint="organization_dataservices_csv")
+@api.response(404, "Organization not found")
+@api.response(410, "Organization has been deleted")
+class DataservicesCsv(API):
+    def get(self, org):
+        dataservices = Dataservice.objects(organization=str(org.id)).visible()
+        adapter = DataserviceCsvAdapter(dataservices)
+        return csv.stream(adapter, "{0}-dataservices".format(org.slug))
+
+
 @ns.route("/<org:org>/discussions.csv", endpoint="organization_discussions_csv", doc=common_doc)
 @api.response(404, "Organization not found")
 @api.response(410, "Organization has been deleted")

udata/core/organization/api_fields.py

@@ -42,9 +42,6 @@ org_ref_fields = api.inherit(
     },
 )
 
-# This import is not at the top of the file to avoid circular imports
-from udata.core.user.api_fields import user_ref_fields  # noqa
-
 
 def check_can_access_user_private_info():
     # This endpoint is secure, only organization member has access.
@@ -64,14 +61,18 @@ def check_can_access_user_private_info():
 def member_email_with_visibility_check(email):
     if current_user_is_admin_or_self():
         return email
+    name, domain = email.split("@")
     if check_can_access_user_private_info():
         # Obfuscate email partially for other members
-        name, domain = email.split("@")
         name = name[:2] + "*" * (len(name) - 2)
         return f"{name}@{domain}"
-    return None
+    # Return only domain for other users
+    return f"***@{domain}"
 
 
+# This import is not at the top of the file to avoid circular imports
+from udata.core.user.api_fields import user_ref_fields  # noqa
+
 member_user_with_email_fields = api.inherit(
     "MemberUserWithEmail",
     user_ref_fields,

udata/core/organization/models.py

@@ -6,6 +6,7 @@ from mongoengine.signals import post_save, pre_save
 from werkzeug.utils import cached_property
 
 from udata.api_fields import field
+from udata.core.activity.models import Auditable
 from udata.core.badges.models import Badge, BadgeMixin, BadgesList
 from udata.core.metrics.models import WithMetrics
 from udata.core.storages import avatars, default_image_basename
@@ -110,29 +111,35 @@ class OrganizationBadgeMixin(BadgeMixin):
     __badges__ = BADGES
 
 
-class Organization(WithMetrics, OrganizationBadgeMixin, db.Datetimed, db.Document):
-    name = db.StringField(required=True)
-    acronym = db.StringField(max_length=128)
-    slug = db.SlugField(
-        max_length=255, required=True, populate_from="name", update=True, follow=True
+class Organization(Auditable, WithMetrics, OrganizationBadgeMixin, db.Datetimed, db.Document):
+    name = field(db.StringField(required=True))
+    acronym = field(db.StringField(max_length=128))
+    slug = field(
+        db.SlugField(max_length=255, required=True, populate_from="name", update=True, follow=True),
+        auditable=False,
     )
-    description = db.StringField(required=True)
-    url = db.URLField()
-    image_url = db.StringField()
-    logo = db.ImageField(
-        fs=avatars, basename=default_image_basename, max_size=LOGO_MAX_SIZE, thumbnails=LOGO_SIZES
+    description = field(db.StringField(required=True))
+    url = field(db.URLField())
+    image_url = field(db.StringField())
+    logo = field(
+        db.ImageField(
+            fs=avatars,
+            basename=default_image_basename,
+            max_size=LOGO_MAX_SIZE,
+            thumbnails=LOGO_SIZES,
+        )
     )
-    business_number_id = db.StringField(max_length=ORG_BID_SIZE_LIMIT)
+    business_number_id = field(db.StringField(max_length=ORG_BID_SIZE_LIMIT))
 
-    members = db.ListField(db.EmbeddedDocumentField(Member))
-    teams = db.ListField(db.EmbeddedDocumentField(Team))
-    requests = db.ListField(db.EmbeddedDocumentField(MembershipRequest))
+    members = field(db.ListField(db.EmbeddedDocumentField(Member)))
+    teams = field(db.ListField(db.EmbeddedDocumentField(Team)))
+    requests = field(db.ListField(db.EmbeddedDocumentField(MembershipRequest)))
 
-    ext = db.MapField(db.GenericEmbeddedDocumentField())
-    zone = db.StringField()
-    extras = db.OrganizationExtrasField()
+    ext = field(db.MapField(db.GenericEmbeddedDocumentField()))
+    zone = field(db.StringField())
+    extras = field(db.OrganizationExtrasField(), auditable=False)
 
-    deleted = db.DateTimeField()
+    deleted = field(db.DateTimeField())
 
     meta = {
         "indexes": [
@@ -168,19 +175,12 @@ class Organization(WithMetrics, OrganizationBadgeMixin, db.Datetimed, db.Documen
     on_update = Signal()
     before_delete = Signal()
     after_delete = Signal()
+    on_delete = Signal()
 
     @classmethod
     def pre_save(cls, sender, document, **kwargs):
         cls.before_save.send(document)
 
-    @classmethod
-    def post_save(cls, sender, document, **kwargs):
-        cls.after_save.send(document)
-        if kwargs.get("created"):
-            cls.on_create.send(document)
-        else:
-            cls.on_update.send(document)
-
     def url_for(self, *args, **kwargs):
         return endpoint_for("organizations.show", "api.organization", org=self, *args, **kwargs)
 
@@ -296,31 +296,31 @@ class Organization(WithMetrics, OrganizationBadgeMixin, db.Datetimed, db.Documen
 
     def count_members(self):
         self.metrics["members"] = len(self.members)
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_datasets(self):
         from udata.models import Dataset
 
         self.metrics["datasets"] = Dataset.objects(organization=self).visible().count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_reuses(self):
         from udata.models import Reuse
 
         self.metrics["reuses"] = Reuse.objects(organization=self).visible().count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_dataservices(self):
         from udata.models import Dataservice
 
         self.metrics["dataservices"] = Dataservice.objects(organization=self).visible().count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
     def count_followers(self):
         from udata.models import Follow
 
         self.metrics["followers"] = Follow.objects(until=None).followers(self).count()
-        self.save()
+        self.save(signal_kwargs={"ignores": ["post_save"]})
 
 
 pre_save.connect(Organization.pre_save, sender=Organization)

udata/core/owned.py

@@ -80,7 +80,7 @@ def check_organization_is_valid_for_current_user(organization, **_kwargs):
 
 class Owned(object):
     """
-    A mixin to factorize owning behvaior between users and organizations.
+    A mixin to factorize owning behavior between users and organizations.
     """
 
     owner = field(

udata/core/post/api.py

@@ -1,4 +1,8 @@
 from datetime import datetime
+from typing import List
+
+from feedgenerator.django.utils.feedgenerator import Atom1Feed
+from flask import make_response, request
 
 from udata.api import API, api, fields
 from udata.auth import Permission as AdminPermission
@@ -11,6 +15,8 @@ from udata.core.storages.api import (
     uploaded_image_fields,
 )
 from udata.core.user.api_fields import user_ref_fields
+from udata.frontend.markdown import md
+from udata.i18n import gettext as _
 
 from .forms import PostForm
 from .models import Post
@@ -105,6 +111,34 @@ class PostsAPI(API):
         return form.save(), 201
 
 
+@ns.route("/recent.atom", endpoint="recent_posts_atom_feed")
+class PostsAtomFeedAPI(API):
+    @api.doc("recent_posts_atom_feed")
+    def get(self):
+        feed = Atom1Feed(
+            _("Latests posts"),
+            description=None,
+            feed_url=request.url,
+            link=request.url_root,
+        )
+
+        posts: List[Post] = Post.objects().published().order_by("-published").limit(15)
+        for post in posts:
+            feed.add_item(
+                post.name,
+                unique_id=post.id,
+                description=post.headline,
+                content=md(post.content),
+                author_name="data.gouv.fr",
+                link=post.external_url,
+                updateddate=post.last_modified,
+                pubdate=post.published,
+            )
+        response = make_response(feed.writeString("utf-8"))
+        response.headers["Content-Type"] = "application/atom+xml"
+        return response
+
+
 @ns.route("/<post:post>/", endpoint="post")
 @api.response(404, "Object not found")
 @api.param("post", "The post ID or slug")

udata/core/reuse/activities.py

@@ -33,17 +33,18 @@ class UserDeletedReuse(ReuseRelatedActivity, Activity):
 
 @Reuse.on_create.connect
 def on_user_created_reuse(reuse):
-    if not reuse.private and current_user and current_user.is_authenticated:
+    if current_user and current_user.is_authenticated:
         UserCreatedReuse.emit(reuse, reuse.organization)
 
 
 @Reuse.on_update.connect
-def on_user_updated_reuse(reuse):
-    if not reuse.private and current_user and current_user.is_authenticated:
-        UserUpdatedReuse.emit(reuse, reuse.organization)
+def on_user_updated_reuse(reuse, **kwargs):
+    changed_fields = kwargs.get("changed_fields", [])
+    if current_user and current_user.is_authenticated:
+        UserUpdatedReuse.emit(reuse, reuse.organization, changed_fields)
 
 
 @Reuse.on_delete.connect
 def on_user_deleted_reuse(reuse):
-    if not reuse.private and current_user and current_user.is_authenticated:
+    if current_user and current_user.is_authenticated:
         UserDeletedReuse.emit(reuse, reuse.organization)

udata/core/reuse/api.py

@@ -1,8 +1,10 @@
 from datetime import datetime
+from typing import List
 
 import mongoengine
 from bson.objectid import ObjectId
-from flask import request
+from feedgenerator.django.utils.feedgenerator import Atom1Feed
+from flask import make_response, request
 from flask_login import current_user
 
 from udata.api import API, api, errors
@@ -20,6 +22,8 @@ from udata.core.storages.api import (
     parse_uploaded_image,
     uploaded_image_fields,
 )
+from udata.frontend.markdown import md
+from udata.i18n import gettext as _
 from udata.models import Dataset
 from udata.utils import id_or_404
 
@@ -130,6 +134,43 @@ class ReuseListAPI(API):
         return patch_and_save(reuse, request), 201
 
 
+@ns.route("/recent.atom", endpoint="recent_reuses_atom_feed")
+class ReusesAtomFeedAPI(API):
+    @api.doc("recent_reuses_atom_feed")
+    def get(self):
+        feed = Atom1Feed(
+            _("Latests reuses"),
+            description=None,
+            feed_url=request.url,
+            link=request.url_root,
+        )
+
+        reuses: List[Reuse] = Reuse.objects.visible().order_by("-created_at").limit(15)
+        for reuse in reuses:
+            author_name = None
+            author_uri = None
+            if reuse.organization:
+                author_name = reuse.organization.name
+                author_uri = reuse.organization.external_url
+            elif reuse.owner:
+                author_name = reuse.owner.fullname
+                author_uri = reuse.owner.external_url
+            feed.add_item(
+                reuse.title,
+                unique_id=reuse.id,
+                description=reuse.description,
+                content=md(reuse.description),
+                author_name=author_name,
+                author_link=author_uri,
+                link=reuse.external_url,
+                updateddate=reuse.last_modified,
+                pubdate=reuse.created_at,
+            )
+        response = make_response(feed.writeString("utf-8"))
+        response.headers["Content-Type"] = "application/atom+xml"
+        return response
+
+
 @ns.route("/<reuse:reuse>/", endpoint="reuse", doc=common_doc)
 @api.response(404, "Reuse not found")
 @api.response(410, "Reuse has been deleted")