Review summary backend

api/app/events/repository.py

@@ -36,6 +36,17 @@ def get_event_by_response_id(response_id):
                          .join(Event, Event.id == ApplicationForm.event_id)\
                          .first()
         return result.Event if result else None
+
+    @staticmethod
+    def get_event_by_application_form_id(application_form_id):
+        result = (
+            db.session.query(ApplicationForm.event_id, Event)
+            .filter(ApplicationForm.id == application_form_id)
+            .join(Event, Event.id == ApplicationForm.event_id)
+            .first()
+        )
+        return result.Event if result else None
+
 
     @staticmethod
     def get_upcoming_for_organisation(organisation_id):

api/app/outcome/api.py

@@ -4,17 +4,24 @@
 from flask import g, request
 from sqlalchemy.exc import SQLAlchemyError
 
+
 from app.outcome.models import Outcome, Status
 from app.outcome.repository import OutcomeRepository as outcome_repository
 from app.events.repository import EventRepository as event_repository
 from app.users.repository import UserRepository as user_repository
 from app.utils.emailer import email_user
 
+from app.responses.repository import ResponseRepository as response_repository
+from app.utils import errors, strings
+from app.reviews.repository import ReviewRepository as review_repository
+from app.events.models import EventType
+
 from app.utils.auth import auth_required, event_admin_required
 from app import LOGGER
 from app import db
 from app.utils import errors
 from app.utils import misc
+from app.reviews.api import ReviewResponseDetailListAPI
 
 
 def _extract_status(outcome):
@@ -26,6 +33,7 @@ def _extract_status(outcome):
     'id': fields.Integer,
     'status': fields.String(attribute=_extract_status),
     'timestamp': fields.DateTime(dt_format='iso8601'),
+    'review_summary': fields.String,
 }
 
 user_fields = {
@@ -36,27 +44,50 @@ def _extract_status(outcome):
     'user_title': fields.String
 }
 
+
+answer_fields = {
+    'id': fields.Integer,
+    'question_id': fields.Integer,
+    'question': fields.String(attribute='question.headline'),
+    'value': fields.String(attribute='value_display'),
+    'question_type': fields.String(attribute='question.type')
+}
+
+response_fields = {
+    'id': fields.Integer,
+    'application_form_id': fields.Integer,
+    'user_id': fields.Integer,
+    'is_submitted': fields.Boolean,
+    'submitted_timestamp': fields.DateTime(dt_format='iso8601'),
+    'is_withdrawn': fields.Boolean,
+    'withdrawn_timestamp': fields.DateTime(dt_format='iso8601'),
+    'started_timestamp': fields.DateTime(dt_format='iso8601'),
+    'answers': fields.List(fields.Nested(answer_fields))
+}
+
 outcome_list_fields = {
     'id': fields.Integer,
     'status': fields.String(attribute=_extract_status),
     'timestamp': fields.DateTime(dt_format='iso8601'),
     'user': fields.Nested(user_fields),
-    'updated_by_user': fields.Nested(user_fields)
+    'updated_by_user': fields.Nested(user_fields),
+    'response': fields.Nested(response_fields)
 }
 
-
 class OutcomeAPI(restful.Resource):
     @event_admin_required
     @marshal_with(outcome_fields)
     def get(self, event_id):
         req_parser = reqparse.RequestParser()
         req_parser.add_argument('user_id', type=int, required=True)
+        req_parser.add_argument('response_id', type=int, required=True)
         args = req_parser.parse_args()
 
         user_id = args['user_id']
+        response_id=args['response_id']
 
         try:
-            outcome = outcome_repository.get_latest_by_user_for_event(user_id, event_id)
+            outcome = outcome_repository.get_latest_by_user_for_event(user_id, event_id, response_id)
             if not outcome:
                 return errors.OUTCOME_NOT_FOUND
 
@@ -68,22 +99,28 @@ def get(self, event_id):
         except: 
             LOGGER.error("Encountered unknown error: {}".format(traceback.format_exc()))
             return errors.DB_NOT_AVAILABLE
+
+
 
     @event_admin_required
     @marshal_with(outcome_fields)
     def post(self, event_id):
         req_parser = reqparse.RequestParser()
         req_parser.add_argument('user_id', type=int, required=True)
         req_parser.add_argument('outcome', type=str, required=True)
+        req_parser.add_argument('response_id', type=int, required=True)
+        req_parser.add_argument('review_summary', type=str, required=False)
         args = req_parser.parse_args()
 
         event = event_repository.get_by_id(event_id)
+
         if not event:
             return errors.EVENT_NOT_FOUND
 
         user = user_repository.get_by_id(args['user_id'])
         if not user:
             return errors.USER_NOT_FOUND
+
 
         try:
             status = Status[args['outcome']]
@@ -92,7 +129,7 @@ def post(self, event_id):
 
         try:
             # Set existing outcomes to no longer be the latest outcome
-            existing_outcomes = outcome_repository.get_all_by_user_for_event(args['user_id'], event_id)
+            existing_outcomes = outcome_repository.get_all_by_user_for_event(args['user_id'], event_id, args['response_id'])
             for existing_outcome in existing_outcomes:
                 existing_outcome.reset_latest()
 
@@ -101,21 +138,58 @@ def post(self, event_id):
                     event_id,
                     args['user_id'],
                     status,
-                    g.current_user['id'])
+                    g.current_user['id'],
+                    args['response_id'],
+                    args.get('review_summary')) 
 
             outcome_repository.add(outcome)
             db.session.commit()
 
-            if (status == Status.REJECTED or status == Status.WAITLIST):  # Email will be sent with offer for accepted candidates  
-                email_user(
-                    'outcome-rejected' if status == Status.REJECTED else 'outcome-waitlist',
-                    template_parameters=dict(
-                        host=misc.get_baobab_host()
-                    ),
-                    event=event,
-                    user=user,
-                )
+            if (event.event_type==EventType.JOURNAL):
+                response = response_repository.get_by_id_and_user_id(outcome.response_id, outcome.user_id)
+                submission_title = response_repository.get_answer_by_question_key_and_response_id('submission_title', response.id)
+
+                if not submission_title:
+                    raise errors.SUBMISSION_TITLE_NOT_FOUND
+
+                review_form = review_repository.get_review_form(outcome.event_id)
+
+                if review_form is not None:
+                    response_reviews = review_repository.get_all_review_responses_by_response(review_form.id, outcome.response_id)
+                else:
+
+                    raise errors.REVIEW_FORM_NOT_FOUND
+
+                serialized_reviews =  [ReviewResponseDetailListAPI._serialise_review_response(response, user.user_primaryLanguage) for response in response_reviews]
 
+                question_answer_summary = strings.build_review_email_body(serialized_reviews, user.user_primaryLanguage, review_form)
+                email_user(
+                        'response-journal',
+                        template_parameters=dict(
+                            summary=outcome.review_summary,
+                            outcome=outcome.status.value,
+                            submission_title=submission_title,
+                            reviewers_contents=question_answer_summary,
+                        ), 
+                        subject_parameters=dict(
+                            submission_title=submission_title,
+                        ),
+                        event=event,
+                        user=user,
+                    )
+
+            else:
+                if (status == Status.REJECTED or status == Status.WAITLIST):  # Email will be sent with offer for accepted candidates  
+                    email_user(
+                        'outcome-rejected' if status == Status.REJECTED else 'outcome-waitlist',
+                        template_parameters=dict(
+                            host=misc.get_baobab_host()
+                        ),
+                        event=event,
+                        user=user,
+                    )
+
+
             return outcome, 201
 
         except SQLAlchemyError as e:
@@ -124,6 +198,7 @@ def post(self, event_id):
         except: 
             LOGGER.error("Encountered unknown error: {}".format(traceback.format_exc()))
             return errors.DB_NOT_AVAILABLE
+
 
 
 class OutcomeListAPI(restful.Resource):

api/app/outcome/models.py

@@ -23,18 +23,28 @@ class Outcome(db.Model):
     user = db.relationship('AppUser', foreign_keys=[user_id])
     updated_by_user = db.relationship('AppUser', foreign_keys=[updated_by_user_id])
 
+    response_id = db.Column(db.Integer(), db.ForeignKey('response.id'), nullable=True)
+    response = db.relationship('Response', foreign_keys=[response_id])
+
+    review_summary = db.Column(db.String(), nullable=True)
+
+
     def __init__(self,
                  event_id,
                  user_id,
                  status,
-                 updated_by_user_id
+                 updated_by_user_id,
+                 response_id,
+                 review_summary
                  ):
         self.event_id = event_id
         self.user_id = user_id
         self.status = status
         self.timestamp = datetime.now()
         self.latest = True
         self.updated_by_user_id = updated_by_user_id
+        self.response_id = response_id
+        self.review_summary = review_summary
 
     def reset_latest(self):
         self.latest = False

api/app/outcome/repository.py

@@ -5,16 +5,16 @@
 class OutcomeRepository():
 
     @staticmethod
-    def get_latest_by_user_for_event(user_id, event_id):
+    def get_latest_by_user_for_event(user_id, event_id, response_id=None):
         outcome = (db.session.query(Outcome)
-                        .filter_by(user_id=user_id, event_id=event_id, latest=True)
+                        .filter_by(user_id=user_id, event_id=event_id, latest=True, response_id=response_id)
                         .first())
         return outcome
 
     @staticmethod
-    def get_all_by_user_for_event(user_id, event_id):
+    def get_all_by_user_for_event(user_id, event_id, response_id=None):
         outcomes = (db.session.query(Outcome)
-                        .filter_by(user_id=user_id, event_id=event_id)
+                        .filter_by(user_id=user_id, event_id=event_id, response_id=response_id)
                         .all())
         return outcomes
 

api/app/responses/api.py

@@ -29,6 +29,11 @@ def _extract_outcome_status(response):
         return None
     return response.outcome.status.name
 
+def _extract_review_summary(response):
+    if not hasattr(response, "review_summary") or not isinstance(response.outcome, Outcome):
+        return None
+    return response.outcome.review_summary
+
 
 class ResponseAPI(ResponseMixin, restful.Resource):
 
@@ -50,7 +55,8 @@ class ResponseAPI(ResponseMixin, restful.Resource):
         'answers': fields.List(fields.Nested(answer_fields)),
         'language': fields.String,
         'parent_id': fields.Integer(default=None),
-        'outcome': fields.String(attribute=_extract_outcome_status)
+        'outcome': fields.String(attribute=_extract_outcome_status),
+        'review_summary': fields.String(attribute=_extract_review_summary)
     }
 
     def find_answer(self, question_id: int, answers: Sequence[Answer]) -> Optional[Answer]:
@@ -122,10 +128,11 @@ def get(self):
         form = event.get_application_form()
         responses = response_repository.get_all_for_user_application(current_user_id, form.id)
 
-        # TODO: Link outcomes to responses rather than events to cater for multiple submissions.
-        outcome = outcome_repository.get_latest_by_user_for_event(current_user_id, event_id)
         for response in responses:
+            outcome = outcome_repository.get_latest_by_user_for_event(current_user_id, event_id, response.id)
+            print('outcome', outcome)
             response.outcome = outcome
+            response.review_summary = outcome
 
         return marshal(responses, ResponseAPI.response_fields), 200
 
@@ -136,20 +143,32 @@ def post(self):
         is_submitted = args['is_submitted']
         application_form_id = args['application_form_id']
         language = args['language']
+        parent_id = args.get('parent_id')
+
+
         if len(language) != 2:
             language = 'en'  # Fallback to English if language doesn't look like an ISO 639-1 code
 
         application_form = application_form_repository.get_by_id(application_form_id)
+
         if application_form is None:
             return errors.FORM_NOT_FOUND_BY_ID
-
-        user = user_repository.get_by_id(user_id)
-        responses = response_repository.get_all_for_user_application(user_id, application_form_id)
 
-        if not application_form.nominations and len(responses) > 0:
-            return errors.RESPONSE_ALREADY_SUBMITTED
+        event = event_repository.get_event_by_application_form_id(application_form_id)
+        if event is None:
+            return errors.EVENT_NOT_FOUND
+
+        allow_multiple_submissions = False
+        if event.event_type == EventType.JOURNAL:
+            allow_multiple_submissions = True
+
+        if not allow_multiple_submissions:
+            responses = response_repository.get_all_for_user_application(user_id, application_form_id)
+            if len(responses) > 0:
+                return errors.RESPONSE_ALREADY_SUBMITTED
+
 
-        response = Response(application_form_id, user_id, language)
+        response = Response(application_form_id, user_id, language, parent_id)
         response_repository.save(response)
 
         answers = []
@@ -300,16 +319,37 @@ def send_confirmation(self, user, response):
                 event_description = event.get_description(user.user_primaryLanguage)
             else:
                 event_description = event.get_description('en')
+
+            if (event.event_type==EventType.JOURNAL):
+                submission_title= response_repository.get_answer_by_question_key_and_response_id('submission_title', response.id)
+                if not submission_title:
+                    raise errors.SUBMISSION_TITLE_NOT_FOUND
+
+                emailer.email_user(
+                    'submitting-article-journal',
+                    template_parameters=dict(
+                        event_description=event_description,
+                        question_answer_summary=question_answer_summary,
+                    ),
+                     subject_parameters=dict(
+                            submission_title=submission_title.value,
+                        ),
+                    event=event,
+                    user=user
+                )
+
 
-            emailer.email_user(
-                'confirmation-response-call' if event.event_type == EventType.CALL else 'confirmation-response',
-                template_parameters=dict(
-                    event_description=event_description,
-                    question_answer_summary=question_answer_summary,
-                ),
-                event=event,
-                user=user
-            )
+            else:
+
+                emailer.email_user(
+                    'confirmation-response-call' if event.event_type == EventType.CALL else 'confirmation-response',
+                    template_parameters=dict(
+                        event_description=event_description,
+                        question_answer_summary=question_answer_summary,
+                    ),
+                    event=event,
+                    user=user
+                )
 
         except Exception as e:
             LOGGER.error('Could not send confirmation email for response with id : {response_id} due to: {e}'.format(response_id=response.id, e=e))