Allow future discontinued date

cms/data/notifications.yml

@@ -142,3 +142,8 @@ update_request:publisher:rejected:notify:
   short:
     Your update request was rejected
 
+journal:assed:discontinuing_soon:notify:
+  long: |
+    Journal "{title}" (id: {id}) will discontinue in {days} days.
+  short:
+     Journals discontinuing soon found

doajtest/testbook/public_site/ToC.yml

@@ -0,0 +1,15 @@
+suite: Public Site
+testset: ToC
+tests:
+- title: Test Correctly Displayed Discontinued Date
+  context:
+    role: anonymous
+  steps:
+  - step: To prepare to do this test make sure there are 3 journals publically available in DOAJ 
+        one with discontinued date in the past 
+        one with discontinued date in the future
+        one with discontinued date today
+  - step: Search for every journal from the list above
+    results:
+    - On the ToC of the journal with discontinued date in the past or today - the discontinued date is displayed
+    - On the ToC of the journal with discontinued date in the future - the discontinued date is not displayed

doajtest/unit/event_consumers/test_journal_discontinuing_soon_notify.py

@@ -0,0 +1,86 @@
+from portality import models
+from portality import constants
+from portality.bll import exceptions
+from doajtest.helpers import DoajTestCase
+from doajtest.fixtures import JournalFixtureFactory, ApplicationFixtureFactory
+from portality.events.consumers.journal_discontinuing_soon_notify import JournalDiscontinuingSoonNotify
+from doajtest.fixtures import BackgroundFixtureFactory
+import time
+
+# Mock required to make application lookup work
+@classmethod
+def pull_application(cls, id):
+    app = models.Application(**ApplicationFixtureFactory.make_application_source())
+    return app
+
+@classmethod
+def pull_by_key(cls, key, value):
+    ed = models.EditorGroup()
+    acc = models.Account()
+    acc.set_id('testuser')
+    acc.set_email("[email protected]")
+    acc.save(blocking=True)
+    ed.set_maned(acc.id)
+    ed.save(blocking=True)
+
+    return ed
+
+class TestJournalDiscontinuingSoonNotify(DoajTestCase):
+    def setUp(self):
+        super(TestJournalDiscontinuingSoonNotify, self).setUp()
+        self.pull_application = models.Application.pull
+        models.Application.pull = pull_application
+        self.pull_by_key = models.EditorGroup.pull_by_key
+        models.EditorGroup.pull_by_key = pull_by_key
+
+    def tearDown(self):
+        super(TestJournalDiscontinuingSoonNotify, self).tearDown()
+        models.Application.pull = self.pull_application
+        models.EditorGroup.pull_by_key = self.pull_by_key
+
+    def test_consumes(self):
+
+        event = models.Event("test:event", context={"data" : {"1234"}})
+        assert not JournalDiscontinuingSoonNotify.consumes(event)
+
+        event = models.Event("test:event", context={"data": {}})
+        assert not JournalDiscontinuingSoonNotify.consumes(event)
+
+        event = models.Event(constants.EVENT_JOURNAL_DISCONTINUING_SOON)
+        assert not JournalDiscontinuingSoonNotify.consumes(event)
+
+        event = models.Event(constants.EVENT_JOURNAL_DISCONTINUING_SOON, context = {"journal": {"1234"}, "discontinue_date": "2002-22-02"})
+        assert JournalDiscontinuingSoonNotify.consumes(event)
+
+    def test_consume_success(self):
+        self._make_and_push_test_context("/")
+
+        source = BackgroundFixtureFactory.example()
+        bj = models.BackgroundJob(**source)
+        # bj.save(blocking=True)
+
+        acc = models.Account()
+        acc.set_id('testuser')
+        acc.set_email("[email protected]")
+        acc.add_role('admin')
+        acc.save(blocking=True)
+
+        source = JournalFixtureFactory.make_journal_source()
+        journal = models.Journal(**source)
+        journal.save(blocking=True)
+
+        event = models.Event(constants.BACKGROUND_JOB_FINISHED, context={"job" : bj.data, "journal" : journal.id})
+        JournalDiscontinuingSoonNotify.consume(event)
+
+        time.sleep(2)
+        ns = models.Notification.all()
+        assert len(ns) == 1
+
+        n = ns[0]
+        assert n.who == acc.id
+        assert n.created_by == JournalDiscontinuingSoonNotify.ID
+        assert n.classification == constants.NOTIFICATION_CLASSIFICATION_STATUS
+        assert n.long is not None
+        assert n.short is not None
+        assert n.action is not None
+        assert not n.is_seen()

doajtest/unit/test_task_discontinued_soon.py

@@ -0,0 +1,77 @@
+import unittest
+import datetime
+
+from doajtest.helpers import DoajTestCase
+
+from portality.core import app
+from portality import models
+from portality.tasks import find_discontinued_soon
+from portality.ui.messages import Messages
+from doajtest.fixtures import JournalFixtureFactory
+
+DELTA = app.config.get('DISCONTINUED_DATE_DELTA',1)
+
+class TestDiscontinuedSoon(DoajTestCase):
+
+    def _date_to_found(self):
+        return (datetime.datetime.today() + datetime.timedelta(days=DELTA)).strftime('%Y-%m-%d')
+
+    def _date_too_late(self):
+        return (datetime.datetime.today() + datetime.timedelta(days=DELTA+1)).strftime('%Y-%m-%d')
+
+    def test_discontinued_soon_found(self):
+
+        # Both these should be found
+        journal_discontinued_to_found_1 = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
+        journal_discontinued_to_found_1.set_id("1")
+        jbib = journal_discontinued_to_found_1.bibjson()
+        jbib.title = "Discontinued Tomorrow 1"
+        jbib.discontinued_date = self._date_to_found()
+        journal_discontinued_to_found_1.save(blocking=True)
+
+        journal_discontinued_to_found_2 = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
+        journal_discontinued_to_found_2.set_id("2")
+        jbib = journal_discontinued_to_found_2.bibjson()
+        jbib.title = "Discontinued Tomorrow 2"
+        jbib.discontinued_date = self._date_to_found()
+        journal_discontinued_to_found_2.save(blocking=True)
+
+        # that shouldn't be found
+        journal_discontinued_too_late = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
+        journal_discontinued_too_late.set_id("3")
+        jbib = journal_discontinued_too_late.bibjson()
+        jbib.title = "Discontinued In 2 days"
+        jbib.discontinued_date = self._date_too_late()
+        journal_discontinued_too_late.save(blocking=True)
+
+        job = find_discontinued_soon.FindDiscontinuedSoonBackgroundTask.prepare("system")
+        task = find_discontinued_soon.FindDiscontinuedSoonBackgroundTask(job)
+        task.run()
+
+        assert len(job.audit) == 2
+        assert job.audit[0]["message"] == Messages.DISCONTINUED_JOURNAL_FOUND_LOG.format(id="1")
+        assert job.audit[1]["message"] == Messages.DISCONTINUED_JOURNAL_FOUND_LOG.format(id="2")
+
+    def test_discontinued_soon_not_found(self):
+
+        # None of these should be found - this one discontinues in 2 days
+        journal_discontinued_too_late = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
+        journal_discontinued_too_late.set_id("1")
+        jbib = journal_discontinued_too_late.bibjson()
+        jbib.title = "Discontinued In 2 days"
+        jbib.discontinued_date = self._date_too_late()
+        journal_discontinued_too_late.save(blocking=True)
+
+        # this one is not in doaj
+        journal_not_in_doaj = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=False))
+        journal_not_in_doaj.set_id("2")
+        jbib = journal_not_in_doaj.bibjson()
+        jbib.discontinued_date = self._date_to_found()
+        journal_not_in_doaj.save(blocking=True)
+
+        job = find_discontinued_soon.FindDiscontinuedSoonBackgroundTask.prepare("system")
+        task = find_discontinued_soon.FindDiscontinuedSoonBackgroundTask(job)
+        task.run()
+
+        assert len(job.audit) == 1
+        assert job.audit[0]["message"] == Messages.NO_DISCONTINUED_JOURNALS_FOUND_LOG

portality/app.py

@@ -279,6 +279,11 @@ def form_diff_table_subject_expand(val):
 
     return ", ".join(results)
 
+@app.template_filter("is_in_the_past")
+def is_in_the_past(dttm):
+    date = datetime.strptime(dttm, "%Y-%m-%d").date()
+    return date <= date.today()
+
 
 #######################################################
 

portality/bll/services/events.py

@@ -21,6 +21,7 @@
 from portality.events.consumers.journal_editor_group_assigned_notify import JournalEditorGroupAssignedNotify
 from portality.events.consumers.application_publisher_inprogress_notify import ApplicationPublisherInprogressNotify
 from portality.events.consumers.update_request_publisher_rejected_notify import UpdateRequestPublisherRejectedNotify
+from portality.events.consumers.journal_discontinuing_soon_notify import JournalDiscontinuingSoonNotify
 
 
 class EventsService(object):
@@ -44,7 +45,8 @@ class EventsService(object):
         JournalEditorGroupAssignedNotify,
         UpdateRequestPublisherAcceptedNotify,
         UpdateRequestPublisherAssignedNotify,
-        UpdateRequestPublisherRejectedNotify
+        UpdateRequestPublisherRejectedNotify,
+        JournalDiscontinuingSoonNotify
     ]
 
     def __init__(self):

portality/constants.py

@@ -53,7 +53,9 @@
 EVENT_APPLICATION_EDITOR_GROUP_ASSIGNED = "application:editor_group:assigned"
 EVENT_JOURNAL_ASSED_ASSIGNED = "journal:assed:assigned"
 EVENT_JOURNAL_EDITOR_GROUP_ASSIGNED = "journal:editor_group:assigned"
+EVENT_JOURNAL_DISCONTINUING_SOON = "journal:discontinuing_soon"
 
+NOTIFICATION_CLASSIFICATION_STATUS = "status"
 NOTIFICATION_CLASSIFICATION_STATUS_CHANGE = "status_change"
 NOTIFICATION_CLASSIFICATION_ASSIGN = "assign"
 NOTIFICATION_CLASSIFICATION_CREATE = "create"

portality/events/consumers/journal_discontinuing_soon_notify.py

@@ -0,0 +1,66 @@
+# ~~JournalDiscontinuingSoonNotify:Consumer~~
+import json
+import urllib.parse
+
+from portality.util import url_for
+from portality.events.consumer import EventConsumer
+from portality.core import app
+from portality import constants
+from portality import models
+from portality.bll import DOAJ, exceptions
+from portality.lib import edges
+from portality import dao
+
+
+from portality.models.v2.journal import JournalDiscontinuedDateQuery
+
+class JournalDiscontinuingSoonNotify(EventConsumer):
+    ID = "journal:assed:discontinuing_soon:notify"
+
+    @classmethod
+    def consumes(cls, event):
+        return event.id == constants.EVENT_JOURNAL_DISCONTINUING_SOON and \
+                event.context.get("journal") is not None and \
+                event.context.get("discontinue_date") is not None
+
+    @classmethod
+    def consume(cls, event):
+        journal_id = event.context.get("journal")
+        discontinued_date = event.context.get("discontinue_date")
+
+        journal = models.Journal.pull(journal_id)
+        if journal is None:
+            return
+
+        app_id = journal.current_application
+        if app_id is None:
+            app_id = journal.latest_related_application_id()
+            if app_id is None:
+                return
+
+        application = models.Application.pull(app_id)
+
+        if not application.editor_group:
+            return
+
+        eg = models.EditorGroup.pull_by_key("name", application.editor_group)
+        managing_editor = eg.maned
+        if not managing_editor:
+            return
+
+        # ~~-> Notifications:Service ~~
+        svc = DOAJ.notificationsService()
+
+        notification = models.Notification()
+        notification.who = managing_editor
+        notification.created_by = cls.ID
+        notification.classification = constants.NOTIFICATION_CLASSIFICATION_STATUS
+        notification.long = svc.long_notification(cls.ID).format(
+            days=app.config.get('DISCONTINUED_DATE_DELTA',1),
+            title=journal.bibjson().title,
+            id=journal.id
+        )
+        notification.short = svc.short_notification(cls.ID)
+        notification.action = url_for("admin.journal_page", journal_id=journal.id)
+
+        svc.notify(notification)

portality/models/v2/journal.py

@@ -1121,4 +1121,25 @@ def query(self):
             "sort" : [
                 {"created_date" : {"order" : "desc"}}
             ]
-        }
+        }
+
+class JournalDiscontinuedDateQuery(object):
+    base_query = {
+            "track_total_hits": True,
+            "query": {
+                "bool": {
+                    "must": [
+                        {"terms": {"bibjson.discontinued_date": "<date here>"}}
+                    ]
+                }
+            },
+            "size": 10000
+        }
+
+    def __init__(self, discontinued_date):
+        self.discontinued_date = discontinued_date
+
+    def query(self):
+        q = deepcopy(self.base_query)
+        q["query"]["bool"]["must"][0]["terms"]["bibjson.discontinued_date"] = [self.discontinued_date]
+        return q

portality/settings.py

@@ -417,6 +417,7 @@
     "anon_export": {"month": "*", "day": "10", "day_of_week": "*", "hour": "6", "minute": "30"},
     "old_data_cleanup": {"month": "*", "day": "12", "day_of_week": "*", "hour": "6", "minute": "30"},
     "monitor_bgjobs": {"month": "*", "day": "*/6", "day_of_week": "*", "hour": "10", "minute": "0"},
+    "find_discontinued_soon": {"month": "*", "day": "*", "day_of_week": "*", "hour": "7", "minute": "0"},
 }
 
 HUEY_TASKS = {
@@ -1354,3 +1355,5 @@
     }
 }
 
+# report journals that discontinue in ... days (eg. 1 = tomorrow)
+DISCONTINUED_DATE_DELTA = 0