Allow future discontinued date

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/test_task_discontinued_soon.py

@@ -0,0 +1,66 @@
+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
+
+class TestDiscontinuedSoon(DoajTestCase):
+
+    def _date_tomorrow(self):
+        return (datetime.datetime.today() + datetime.timedelta(days=1)).strftime('%Y-%m-%d')
+
+    def _date_in_2_days(self):
+        return (datetime.datetime.today() + datetime.timedelta(days=2)).strftime('%Y-%m-%d')
+
+    def test_discontinued_soon_found(self):
+
+        journal_discontinued_tommorow_1 = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
+        journal_discontinued_tommorow_1.set_id("1")
+        jbib = journal_discontinued_tommorow_1.bibjson()
+        jbib.title = "Discontinued Tomorrow 1"
+        jbib.discontinued_date = self._date_tomorrow()
+        journal_discontinued_tommorow_1.save(blocking=True)
+
+        journal_discontinued_tommorow_2 = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
+        journal_discontinued_tommorow_2.set_id("2")
+        jbib = journal_discontinued_tommorow_2.bibjson()
+        jbib.title = "Discontinued Tomorrow 2"
+        jbib.discontinued_date = self._date_tomorrow()
+        journal_discontinued_tommorow_2.save(blocking=True)
+
+        journal_discontinued_in_2_days = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
+        journal_discontinued_in_2_days.set_id("3")
+        jbib = journal_discontinued_in_2_days.bibjson()
+        jbib.title = "Discontinued In 2 days"
+        jbib.discontinued_date = self._date_in_2_days()
+        journal_discontinued_in_2_days.save(blocking=True)
+
+        job = find_discontinued_soon.FindDiscontinuedSoonBackgroundTask.prepare("system")
+        task = find_discontinued_soon.FindDiscontinuedSoonBackgroundTask(job)
+        task.run()
+
+        assert len(job.audit) == 3
+        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")
+        assert job.audit[2]["message"] == Messages.DISCONTINUED_JOURNALS_FOUND_EMAIL_SENT_LOG
+
+    def test_discontinued_soon_not_found(self):
+
+        journal_discontinued_in_2_days = models.Journal(**JournalFixtureFactory.make_journal_source(in_doaj=True))
+        journal_discontinued_in_2_days.set_id("3")
+        jbib = journal_discontinued_in_2_days.bibjson()
+        jbib.title = "Discontinued In 2 days"
+        jbib.discontinued_date = self._date_in_2_days()
+        journal_discontinued_in_2_days.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

@@ -17,7 +17,7 @@
 from flask import request, abort, render_template, redirect, send_file, url_for, jsonify, send_from_directory
 from flask_login import login_user, current_user
 
-from datetime import datetime
+from datetime import datetime, date
 
 import portality.models as models
 from portality.core import app, es_connection, initialise_index
@@ -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/settings.py

@@ -341,6 +341,7 @@
 MANAGING_EDITOR_EMAIL = "[email protected]"
 CONTACT_FORM_ADDRESS = "[email protected]"
 SCRIPT_TAG_DETECTED_EMAIL_RECIPIENTS = ["[email protected]"]
+DISCONTINUED_JOURNALS_FOUND_RECEIPIENTS = ["[email protected]"]
 
 SYSTEM_EMAIL_FROM = '[email protected]'
 CC_ALL_EMAILS_TO = SYSTEM_EMAIL_FROM  # DOAJ may get a dedicated inbox in the future
@@ -417,6 +418,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 +1356,5 @@
     }
 }
 
+# report journals that discontinue in ... days (eg. 1 = tomorrow)
+DISCONTINUED_DATE_DELTA = 1

portality/tasks/find_discontinued_soon.py

@@ -0,0 +1,133 @@
+import datetime
+import csv
+import json
+
+from portality.core import app
+from portality import models,app_email
+
+from portality.tasks.redis_huey import main_queue
+
+from portality.background import BackgroundTask, BackgroundSummary
+from portality.tasks.helpers import background_helper
+from portality.ui.messages import Messages
+
+
+def _date():
+    return (datetime.datetime.today() + datetime.timedelta(days=app.config.get('DISCONTINUED_DATE_DELTA', 1))).strftime(
+        '%Y-%m-%d')
+class DiscontinuedSoonQuery:
+    @classmethod
+    def query(cls):
+        return {
+            "query": {
+                "bool": {
+                    "filter": {
+                        "bool" : {
+                            "must": [
+                                {"term" : {"bibjson.discontinued_date": _date()}}
+                            ]
+                        }
+                    }
+                }
+            }
+        }
+
+# ~~FindDiscontinuedSoonBackgroundTask:Task~~
+
+class FindDiscontinuedSoonBackgroundTask(BackgroundTask):
+    __action__ = "find_discontinued_soon"
+
+    def find_journals_discontinuing_soon(self, job):
+        jdata = []
+
+        for journal in models.Journal.iterate(q=DiscontinuedSoonQuery.query(), keepalive='5m', wrap=True):
+            # ~~->Journal:Model~~
+            bibjson = journal.bibjson()
+            owner = journal.owner
+            account = models.Account.pull(owner)
+
+            jdata.append({"id": journal.id,
+                          "title":bibjson.title,
+                          "eissn": bibjson.get_one_identifier(bibjson.E_ISSN),
+                          "pissn": bibjson.get_one_identifier(bibjson.P_ISSN),
+                          "account_email": account.email if account else "Not Found",
+                          "publisher": bibjson.publisher,
+                          "discontinued date": bibjson.discontinued_date})
+            job.add_audit_message(Messages.DISCONTINUED_JOURNAL_FOUND_LOG.format(id=journal.id))
+
+        return jdata
+
+
+    def send_email(self, data, job):
+        # ~~->Email:ExternalService~~
+        try:
+            # send warning email about the service tag in article metadata detected
+            to = app.config.get('DISCONTINUED_JOURNALS_FOUND_RECEIPIENTS')
+            fro = app.config.get("SYSTEM_EMAIL_FROM", "[email protected]")
+            subject = app.config.get("SERVICE_NAME", "") + " - journals discontinuing soon found"
+            app_email.send_mail(to=to,
+                                fro=fro,
+                                subject=subject,
+                                template_name="email/discontinue_soon.jinja2",
+                                days=app.config.get('DISCONTINUED_DATE_DELTA',1),
+                                data=json.dumps({"data": data}, indent=4, separators=(',', ': ')))
+        except app_email.EmailException:
+            app.logger.exception(Messages.DISCONTINUED_JOURNALS_FOUND_EMAIL_ERROR_LOG)
+
+        job.add_audit_message(Messages.DISCONTINUED_JOURNALS_FOUND_EMAIL_SENT_LOG)
+
+    def run(self):
+        job = self.background_job
+        journals = self.find_journals_discontinuing_soon(job=job)
+        if len(journals):
+            self.send_email(job=job, data=journals)
+        else:
+            job.add_audit_message(Messages.NO_DISCONTINUED_JOURNALS_FOUND_LOG)
+
+    def cleanup(self):
+        """
+        Cleanup after a successful OR failed run of the task
+        :return:
+        """
+        pass
+
+    @classmethod
+    def prepare(cls, username, **kwargs):
+        """
+        Take an arbitrary set of keyword arguments and return an instance of a BackgroundJob,
+        or fail with a suitable exception
+
+        :param kwargs: arbitrary keyword arguments pertaining to this task type
+        :return: a BackgroundJob instance representing this task
+        """
+
+        # first prepare a job record
+        job = background_helper.create_job(username, cls.__action__,
+                                           queue_id=huey_helper.queue_id, )
+        return job
+
+    @classmethod
+    def submit(cls, background_job):
+        """
+        Submit the specified BackgroundJob to the background queue
+
+        :param background_job: the BackgroundJob instance
+        :return:
+        """
+        background_job.save()
+        find_discontinued_soon.schedule(args=(background_job.id,), delay=10)
+
+huey_helper = FindDiscontinuedSoonBackgroundTask.create_huey_helper(main_queue)
+
+@huey_helper.register_schedule
+def scheduled_find_discontinued_soon():
+    user = app.config.get("SYSTEM_USERNAME")
+    job = FindDiscontinuedSoonBackgroundTask.prepare(user)
+    FindDiscontinuedSoonBackgroundTask.submit(job)
+
+
+@huey_helper.register_execute(is_load_config=False)
+def find_discontinued_soon(job_id):
+    job = models.BackgroundJob.pull(job_id)
+    task = FindDiscontinuedSoonBackgroundTask(job)
+    BackgroundApi.execute(task)

portality/templates/doaj/toc.html

@@ -84,7 +84,7 @@ <h1 class="row">
                 </span>
             </p>
 
-            {% if bibjson.discontinued_date %}
+            {% if bibjson.discontinued_date | is_in_the_past %}
                 <p>Ceased publication on <strong>{{ bibjson.discontinued_datestamp.strftime("%d %B %Y") }}</strong></p>
             {% endif %}
 

portality/templates/email/discontinue_soon.jinja2

@@ -0,0 +1,7 @@
+{#
+~~FindDiscontinuedSoonBackgroundTask:Email~~
+#}
+
+Following journals will discontinue in {{ days }} days.
+
+{{ data }}

portality/ui/messages.py

@@ -109,6 +109,12 @@ class Messages(object):
 
     NOTIFY__DEFAULT_SHORT_NOTIFICATION = "You have a new notification"
 
+    DISCONTINUED_JOURNAL_FOUND_LOG = "Journal discontinuing soon found: {id}"
+    DISCONTINUED_JOURNALS_FOUND_EMAIL_SENT_LOG = "Email with journals discontinuing soon sent"
+    DISCONTINUED_JOURNALS_FOUND_EMAIL_ERROR_LOG = "Error sending email with journals discountinuing soon."
+    NO_DISCONTINUED_JOURNALS_FOUND_LOG = "No journals discontinuing soon found"
+
+
     @classmethod
     def flash(cls, tup):
         if isinstance(tup, tuple):