#49 #50 Re-wrote the email sending module with a class and better organization of templates.

Author: jcaraballo17

src/cvinterface/email.py

@@ -1,4 +1,4 @@
-from typing import Type, Dict
+from typing import Dict
 
 from django.conf import settings
 from django.core.handlers.wsgi import WSGIRequest
@@ -9,47 +9,110 @@
 
 from odm2cvs.controlled_vocabularies import Vocabulary
 
-template_map: Dict[str, str] = {
-    'update_subject': 'cvinterface/email/update_request_subject.tpl',
-    'approved': 'cvinterface/email/update_approved_body.tpl',
-    'rejected': 'cvinterface/email/update_rejected_body.tpl'
+email_map: Dict[str, Dict[str, Dict[str, str]]] = {
+    'request_made': {
+        'admin': {
+            'subject': 'cvinterface/email/request_made/subject_admin.tpl',
+            'body': 'cvinterface/email/request_made/body_admin.tpl'
+        },
+        'user': {
+            'subject': 'cvinterface/email/request_made/subject_user.tpl',
+            'body': 'cvinterface/email/request_made/body_user.tpl'
+        }
+    },
+    'update_approved': {
+        'user': {
+            'subject': 'cvinterface/email/update_approved/subject.tpl',
+            'body': 'cvinterface/email/update_approved/body.tpl'
+        }
+    },
+    'update_rejected': {
+        'user': {
+            'subject': 'cvinterface/email/update_rejected/subject.tpl',
+            'body': 'cvinterface/email/update_rejected/body.tpl'
+        }
+    }
 }
 
 
-def get_email_context(web_form: Form, web_request: WSGIRequest, vocabulary: Vocabulary) -> Dict[str, str]:
-    return {
-        'submitter_name': web_form.instance.submitter_name,
-        'concept_name': web_form.instance.name,
-        'vocabulary_verbose_name': vocabulary.get('name'),
-        'vocabulary_list_url': web_request.build_absolute_uri(reverse(vocabulary.get('list_url_name')))
-    }
+class EmailHandler:
+    def __init__(self, web_form: Form, web_request: WSGIRequest, vocabulary: Vocabulary, email_type: str, receiver: str):
+        self.form = web_form
+        self.web_request = web_request
+        self.vocabulary = vocabulary
+        self.email_type = email_type
+        self.email_receiver = receiver
+        self.recipients = {
+            'user': [self.form.instance.submitter_email],
+            'admin': settings.EMAIL_RECIPIENTS
+        }
+
+    def get_email_context(self) -> Dict[str, str]:
+        return {
+            'submitter_name': self.form.instance.submitter_name,
+            'submitter_email': self.form.instance.submitter_email,
+            'concept_name': self.form.instance.name,
+            'concept_term': self.form.instance.term,
+            'concept_notes': self.form.instance.note,
+            'concept_definition': self.form.instance.definition,
+            'request_reason': self.form.instance.request_reason,
+            'vocabulary_verbose_name': self.vocabulary.get('name'),
+            'action': 'creation of a new ' if not self.form.instance.request_for_id else 'update of a ',
+            'vocabulary_list_url': self.web_request.build_absolute_uri(reverse(self.vocabulary.get('list_url_name'))),
+            'requests_list_url': self.web_request.build_absolute_uri(reverse('requests_list'))
+        }
+
+    def send_email(self):
+        context: Dict[str, str] = self.get_email_context()
+        email: Dict[str, str] = email_map.get(self.email_type).get(self.email_receiver)
+
+        subject: str = render_to_string(template_name=email.get('subject'))
+        message: str = render_to_string(template_name=email.get('body'), context=context)
+        send_mail(subject, message, settings.EMAIL_SENDER, self.recipients.get(self.email_receiver))
 
 
-def notify_approval(sender: Form, **kwargs) -> None:
+def notify_update_approved(sender: Form, **kwargs) -> None:
     """
     Handler to send email to users when their request has been approved by an administrator.
     :param sender: The signal sender, in this case the django form object.
-    :param kwargs: Dict with the vocabulary and vocabulary code of the request being approved.
+    :param kwargs: Dict with metadata for the request being approved.
     :return:
     """
+    email_handler = EmailHandler(sender, kwargs.get('web_request'), kwargs.get('vocabulary'), 'update_approved', 'user')
+    email_handler.send_email()
 
-    email_context: Dict[str, str] = get_email_context(sender, kwargs.get('web_request'), kwargs.get('vocabulary'))
-    email_message: str = render_to_string(template_name=template_map.get('approved'), context=email_context)
-    email_subject: str = render_to_string(template_name=template_map.get('update_subject'))
 
-    send_mail(email_subject, email_message, settings.EMAIL_SENDER, [sender.instance.submitter_email])
-
-
-def notify_refusal(sender: Form, **kwargs) -> None:
+def notify_update_rejected(sender: Form, **kwargs) -> None:
     """
     Handler to send email to users when their request has been refused by an administrator.
     :param sender: The signal sender, in this case the django form object.
     :param kwargs: Dict with the vocabulary and vocabulary code of the request being refused.
     :return:
     """
 
-    email_context: Dict[str, str] = get_email_context(sender, kwargs.get('web_request'), kwargs.get('vocabulary'))
-    email_message: str = render_to_string(template_name=template_map.get('refused'), context=email_context)
-    email_subject: str = render_to_string(template_name=template_map.get('update_subject'))
+    email_handler = EmailHandler(sender, kwargs.get('web_request'), kwargs.get('vocabulary'), 'update_rejected', 'user')
+    email_handler.send_email()
+
+
+def notify_admin_request_made(sender: Form, **kwargs) -> None:
+    """
+    Handler to send email to administrators when a request has been made by a user.
+    :param sender: The signal sender, in this case the django form object.
+    :param kwargs: Dict with the vocabulary and vocabulary code of the request being made.
+    :return:
+    """
+
+    email_handler = EmailHandler(sender, kwargs.get('web_request'), kwargs.get('vocabulary'), 'request_made', 'admin')
+    email_handler.send_email()
+
+
+def notify_user_request_made(sender: Form, **kwargs) -> None:
+    """
+    Handler to send a confirmation email to a user who just requested a new term.
+    :param sender: The signal sender, in this case the django form object.
+    :param kwargs: Dict with the vocabulary and vocabulary code of the request being made.
+    :return:
+    """
 
-    send_mail(email_subject, email_message, settings.EMAIL_SENDER, [sender.instance.submitter_email])
+    email_handler = EmailHandler(sender, kwargs.get('web_request'), kwargs.get('vocabulary'), 'request_made', 'user')
+    email_handler.send_email()

src/cvinterface/signals.py

@@ -1,9 +1,10 @@
 import django.dispatch
 
-from cvinterface.email import notify_approval, notify_refusal
+from cvinterface.email import notify_update_approved, notify_update_rejected, \
+    notify_user_request_made, notify_admin_request_made
 
 # signal for when a request is created
-request_submitted = django.dispatch.Signal()
+request_made = django.dispatch.Signal()
 
 # signal for when a request was rejected
 request_rejected = django.dispatch.Signal()
@@ -13,5 +14,7 @@
 
 
 # signal handlers
-request_approved.connect(notify_approval, dispatch_uid="cv_request_approved")
-request_rejected.connect(notify_refusal, dispatch_uid="cv_request_rejected")
+request_made.connect(notify_user_request_made, dispatch_uid='cv_request_made_user')
+request_made.connect(notify_admin_request_made, dispatch_uid='cv_request_made_admin')
+request_approved.connect(notify_update_approved, dispatch_uid='cv_request_approved')
+request_rejected.connect(notify_update_rejected, dispatch_uid='cv_request_rejected')

src/cvinterface/templates/cvinterface/email/request_made/body_admin.tpl

@@ -0,0 +1,7 @@
+User {{ submitter_name }} ( {{ submitter_email }} ) made a request for the {{ action }} {{ vocabulary_verbose_name }} vocabulary term.
+
+Term: {{ concept_term }}
+Definition: {{ concept_definition }}
+Notes: {{ concept_notes }}
+Reason given for request: {{ request_reason }}
+To review this submission go to {{ requests_list_url }}

src/cvinterface/templates/cvinterface/email/request_made/body_user.tpl

@@ -0,0 +1,7 @@
+Thank you for your submission to ODM2 Controlled Vocabularies.
+
+Vocabulary: {{ vocabulary_verbose_name }}
+Term: {{ concept_term }}
+Definition: {{ concept_definition }}
+Notes: {{ concept_notes }}
+Reason given for request: {{ request_reason }}

src/cvinterface/templates/cvinterface/email/request_made/subject_admin.tpl

@@ -0,0 +1 @@
+New request for an ODM2 Controlled Vocabulary Term

src/cvinterface/templates/cvinterface/email/request_made/subject_user.tpl

@@ -0,0 +1 @@
+ODM2 Controlled Vocabularies Submission

src/cvinterface/templates/cvinterface/email/update_approved_body.tpl src/cvinterface/templates/cvinterface/email/update_approved/body.tpl

@@ -0,0 +1 @@
+ODM2 Controlled Vocabularies - Submission Update