Amélioration de la détection des événements déjà importés

Fix #401

src/agenda_culturel/celery.py

@@ -471,7 +471,7 @@ def import_events_from_url(
             )
 
             # clean url
-            url = Extractor.clean_url(url)
+            url = Extractor.clean_url_default_extractors(url)
 
             # we check if the url is known
             existing = None if force else Event.objects.filter(uuids__contains=[url])

src/agenda_culturel/import_tasks/extractor.py

@@ -296,17 +296,6 @@ class Extractor(ABC):
         else:
             return {"header": self.header, "events": self.events}
 
-    def clean_url(url):
-        from .generic_extractors.fbevent import (
-            CExtractor as FacebookEventExtractor,
-        )
-        from .generic_extractors.ical import ICALExtractor
-
-        result = url
-        for e in [ICALExtractor, FacebookEventExtractor]:
-            result = e.clean_url(result)
-        return result
-
     def get_default_extractors(single_event=False):
         from .generic_extractors.fbevent import (
             CExtractor as FacebookEventExtractor,
@@ -341,6 +330,12 @@ class Extractor(ABC):
                 return True
         return False
 
+    def clean_url_default_extractors(url):
+        for e in Extractor.get_default_extractors(True):
+            if e.is_known_url(url):
+                return e.clean_url(url)
+        return url
+
 
 # A class that only produce a not found event
 class EventNotFoundExtractor(Extractor):

src/agenda_culturel/import_tasks/generic_extractors/fbevent.py

@@ -227,7 +227,7 @@ class FacebookEvent:
 
 
 class CExtractor(Extractor):
-    pattern = r'^https?://(?:www\.|m\.)?facebook\.com/events/(\d+)(?:/(\d+))?(?:/([a-zA-Z0-9\-]+))?/?$'
+
     def __init__(self):
         super().__init__()
         self.has_2nd_method = True
@@ -300,7 +300,9 @@ class CExtractor(Extractor):
 
     def is_known_url(url, include_links=True):
 
-        if re.match(CExtractor.pattern, url):
+        u = urlparse(url)
+
+        if "/events/" in u.path and u.netloc.endswith("facebook.com"):
             return True
 
         if include_links:

src/agenda_culturel/models.py

@@ -1487,6 +1487,30 @@ class Event(models.Model):
         ]
         return [nb_not_moderated[x : x + 7] for x in range(0, len(nb_not_moderated), 7)]
 
+    def is_know_url_get_visible_event(url, auth):
+        evs = Event.objects.filter(uuids__contains=[url])
+        if auth:
+            e = evs.first()
+            if e is not None:
+                if e.is_representative():
+                    return e
+                else:
+                    return e.other_versions.representative
+            else:
+                return False
+        else:
+            e_all = evs.exists()
+            if not e_all:
+                return False
+            else:
+                e = evs.first()
+                if e is not None:
+                    if not e.is_representative():
+                        e = e.other_versions.representative
+                    return e if e.status == Event.STATUS.PUBLISHED else True
+                else:
+                    return False
+
     def nb_draft_events():
         return Event.objects.filter(status=Event.STATUS.DRAFT).count()
 

src/agenda_culturel/views.py

@@ -869,6 +869,39 @@ def import_event_proxy(request):
         if form.is_valid():
             url = form.cleaned_data["url"]
             if Extractor.is_known_url_default_extractors(url):
+                c_url = Extractor.clean_url_default_extractors(url)
+
+                ex = Event.is_know_url_get_visible_event(
+                    c_url, request.user.is_authenticated
+                )
+                if ex is True:
+                    messages.info(
+                        request,
+                        _(
+                            "{} has not been submitted since it"
+                            "s already known and currently into moderation process."
+                        ).format(c_url),
+                    )
+                    return HttpResponseRedirect(reverse_lazy("home"))
+                elif isinstance(ex, Event):
+                    messages.info(
+                        request,
+                        mark_safe(
+                            _(
+                                "{} has not been submitted since it"
+                                "s already known: {}."
+                            ).format(
+                                c_url,
+                                '<a href="'
+                                + ex.get_absolute_url()
+                                + '">'
+                                + escape(ex.title)
+                                + "</a>",
+                            )
+                        ),
+                    )
+                    return HttpResponseRedirect(ex.get_absolute_url())
+                else:
                     messages.info(
                         request,
                         _(
@@ -876,7 +909,7 @@ def import_event_proxy(request):
                         ),
                     )
                     return HttpResponseRedirect(
-                    reverse_lazy("add_event_url") + "?url=" + quote(url)
+                        reverse_lazy("add_event_url") + "?url=" + quote(c_url)
                     )
             else:
                 manual = reverse_lazy("add_event_details") + "?url=" + quote(url)
@@ -995,43 +1028,32 @@ class URLEventEvaluation:
         self.url = form.cleaned_data.get("url")
         self.event = None
         if self.url is not None:
-            self.url = Extractor.clean_url(self.url)
+            self.url = Extractor.clean_url_default_extractors(self.url)
+            print(self.url)
             # we check if the url is known
-            self.existing = Event.objects.filter(uuids__contains=[self.url])
+            self.existing = Event.is_know_url_get_visible_event(
-            # if it's unknown
+                self.url, is_authenticated
-            if len(self.existing) == 0:
+            )
-                self.existing = None
+            if self.existing is False:
                 self.cat = form.cleaned_data.get("category")
                 if self.cat is not None:
                     self.cat = self.cat.name
                 self.tags = form.cleaned_data.get("tags")
 
-            else:
-                published = [
-                    e for e in self.existing if e.status == Event.STATUS.PUBLISHED
-                ]
-
-                if self.is_authenticated or len(published) > 1:
-                    self.event = (
-                        published[0] if len(published) > 1 else self.existing[0]
-                    )
-                else:
-                    self.event = None
-
     def exists(self):
         return self.url is not None
 
     def is_new(self):
-        return self.exists() and self.existing is None
+        return self.exists() and self.existing is False
 
     def is_event_visible(self):
-        return self.event is not None
+        return isinstance(self.existing, Event)
 
     def get_event(self):
-        if self.event is None:
+        if isinstance(self.existing, Event):
-            return None
+            return self.existing
         else:
-            return self.event
+            return None
 
     def get_link(self):
         e = self.get_event()
@@ -1130,7 +1152,7 @@ def import_from_url(request):
         # if the form is valid
         if form.is_valid():
             uc = URLEventEvaluation(form, request.user.is_authenticated)
-
+            print(uc.exists(), uc.is_new(), uc.event)
             if uc.exists() and not uc.is_new():
                 if uc.is_event_visible():
                     messages.info(