Feature/support multiple internal users

.pylintrc

@@ -193,7 +193,7 @@ max-nested-blocks=5
 [FORMAT]
 
 # Maximum number of characters on a single line.
-max-line-length=150
+max-line-length=160
 
 # Regexp for a line that is allowed to be longer than the limit.
 ignore-long-lines=^\s*(# )?<?https?://\S+>?$

run_tests.py

@@ -7,7 +7,7 @@
     os.environ['APP_SETTINGS'] = 'TestConfig'
 
     from behave import __main__ as behave_executable
-    behave = behave_executable.main()
+    behave_errors = behave_executable.main()
 
     test_dirs = os.listdir('./tests')
     suites_list = []
@@ -18,6 +18,6 @@
             suite = loader.discover(test_path)
             suites_list.append(suite)
             result = unittest.TextTestRunner(verbosity=2).run(suite)
-            i = len(result.failures) + len(result.errors)
-            if i != 0 or behave == 1:
+            if result.failures or result.errors or behave_errors:
                 sys.exit(1)
+

secure_message/api_mocks/internal_user_service_mock.py

@@ -7,14 +7,50 @@
 
 class InternalUserServiceMock:
     def __init__(self):
-        self.internal_user_dict = {"Someuuid": {"id": "Someuuid",
-                                                "firstName": "fred",
-                                                "lastName": "flinstone",
-                                                "emailAddress": "mock@email.com"}}
+        self.internal_user_dict = {
+            "Someuuid": {
+                "id": "Someuuid",
+                "firstName": "fred",
+                "lastName": "flinstone",
+                "emailAddress": "mock@email.com"
+            },
+            "01b51fcc-ed43-4cdb-ad1c-450f9986859b": {
+                "id": "01b51fcc-ed43-4cdb-ad1c-450f9986859b",
+                "firstName": "fred",
+                "lastName": "flinstone",
+                "emailAddress": "mock@email.com"
+            },
+            "f62dfda8-73b0-4e0e-97cf-1b06327a6712": {
+                "id": "01b51fcc-ed43-4cdb-ad1c-450f9986859b",
+                "firstName": "fred",
+                "lastName": "flinstone",
+                "emailAddress": "mock@email.com"
+            },
+            "Tej": {
+                "id": "Tej",
+                "firstName": "Tejas",
+                "lastName": "patel",
+                "emailAddress": "mock@email.com"
+            },
+            "BRES": {
+                "id": "TRES",
+                "firstName": "BRES",
+                "lastName": "",
+                "emailAddress": "mock@email.com"
+            },
+            "SomeStringUntilWeGetIds": {
+                "id": "SomeStringUntilWeGetIds",
+                "firstName": "MadeUpUser",
+                "lastName": "",
+                "emailAddress": "mock@email.com"
+            }
+        }
 
     def get_user_details(self, uuid):
         """gets the user details from the internal user service"""
         logger.debug("getting mock user details for uaa")
         if uuid:
-            return self.internal_user_dict[uuid], 200
-        return "error retrieving details"
+            found = self.internal_user_dict.get(uuid)
+            if found:
+                return found, 200
+        return "error retrieving details", 404

secure_message/application.py

@@ -10,15 +10,9 @@
 
 from secure_message.exception.exceptions import MissingEnvironmentVariable
 from secure_message.repository import database
-from secure_message.resources.health import Health, DatabaseHealth, HealthDetails
-from secure_message.resources.info import Info
-from secure_message.resources.labels import Labels
-from secure_message.resources.messages import MessageList, MessageSend, MessageById, MessageModifyById
 from secure_message.authentication.authenticator import authenticate
-from secure_message.resources.drafts import DraftSave, DraftById, DraftModifyById, DraftList
-from secure_message.resources.threads import ThreadById, ThreadList
 from secure_message.logger_config import logger_initial_config
-
+from secure_message.v1.application import set_v1_resources
 
 logger_initial_config(service_name='ras-secure-message')
 logger = wrap_logger(logging.getLogger(__name__))
@@ -48,21 +42,7 @@ def create_app(config=None):
         database.db.create_all()
         database.db.session.commit()  # NOQA pylint:disable=no-member
 
-    api.add_resource(Health, '/health')
-    api.add_resource(DatabaseHealth, '/health/db')
-    api.add_resource(HealthDetails, '/health/details')
-    api.add_resource(Info, '/info')
-    api.add_resource(MessageList, '/messages')
-    api.add_resource(MessageSend, '/message/send')
-    api.add_resource(MessageById, '/message/<message_id>')
-    api.add_resource(MessageModifyById, '/message/<message_id>/modify')
-    api.add_resource(DraftSave, '/draft/save')
-    api.add_resource(DraftModifyById, '/draft/<draft_id>/modify')
-    api.add_resource(DraftById, '/draft/<draft_id>')
-    api.add_resource(ThreadById, '/thread/<thread_id>')
-    api.add_resource(DraftList, '/drafts')
-    api.add_resource(ThreadList, '/threads')
-    api.add_resource(Labels, '/labels')
+    set_v1_resources(api)
 
     @app.before_request
     def before_request():  # NOQA pylint:disable=unused-variable

secure_message/repository/database.py

@@ -74,12 +74,7 @@ def serialize(self, user, body_summary=False):
                    '_links': '',
                    'labels': []}
 
-        if user.is_internal:
-            actor = constants.BRES_USER
-        else:
-            actor = user.user_uuid
-
-        self._populate_to_and_from(actor, message)
+        self._populate_to_and_from(user, message)
 
         self._populate_events(message)
 
@@ -100,11 +95,10 @@ def _populate_events(self, message):
             elif row.event == EventsApi.READ.value:
                 message['read_date'] = str(row.date_time)
 
-    def _populate_to_and_from(self, actor, message):
+    def _populate_to_and_from(self, user, message):
         for row in self.statuses:
-            if row.actor == actor:
+            if row.actor == user.user_uuid or (user.is_internal and (row.actor == constants.NON_SPECIFIC_INTERNAL_USER or row.actor == constants.BRES_USER)):
                 message['labels'].append(row.label)
-
             if row.label == Labels.INBOX.value:
                 message['msg_to'].append(row.actor)
             elif row.label == Labels.SENT.value:

secure_message/repository/modifier.py

@@ -91,12 +91,14 @@ def del_draft(draft_id):
         del_draft_status = "DELETE FROM securemessage.status WHERE msg_id='{0}' AND label='{1}'".format(draft_id, Labels.DRAFT.value)
         del_draft_event = "DELETE FROM securemessage.events WHERE msg_id='{0}'".format(draft_id)
         del_draft_inbox_status = "DELETE FROM securemessage.status WHERE msg_id='{0}' AND label='{1}'".format(draft_id, Labels.DRAFT_INBOX.value)
+        del_actors = "DELETE FROM securemessage.actors where msg_id='{0}'".format(draft_id)
         del_draft_msg = "DELETE FROM securemessage.secure_message WHERE msg_id='{0}'".format(draft_id)
 
         try:
             db.get_engine(app=db.get_app()).execute(del_draft_status)
             db.get_engine(app=db.get_app()).execute(del_draft_inbox_status)
             db.get_engine(app=db.get_app()).execute(del_draft_event)
+            db.get_engine(app=db.get_app()).execute(del_actors)
             db.get_engine(app=db.get_app()).execute(del_draft_msg)
 
         except Exception as e:

secure_message/repository/retriever.py

@@ -16,16 +16,22 @@
 
 class Retriever:
     """Created when retrieving messages"""
+
     @staticmethod
     def retrieve_message_list(page, limit, user, ru_id=None, survey=None, cc=None, ce=None, label=None, descend=True):
         """returns list of messages from db"""
-        conditions = []
-        status_conditions = []
 
         if user.is_respondent:
-            status_conditions.append(Status.actor == str(user.user_uuid))
-        else:
-            status_conditions.append(Status.actor == constants.BRES_USER)
+            return Retriever._retrieve_message_list_respondent(page, limit, user=user, ru_id=ru_id, survey=survey,
+                                                               cc=cc, ce=ce, label=label, descend=descend)
+        return Retriever._retrieve_message_list_internal(page, limit, ru_id=ru_id, survey=survey,
+                                                         cc=cc, ce=ce, label=label, descend=descend)
+
+    @staticmethod
+    def _retrieve_message_list_respondent(page, limit, user, ru_id, survey, cc, ce, label, descend):
+        """returns list of messages from db"""
+        conditions = []
+        status_conditions = [Status.actor == str(user.user_uuid)]
 
         if label is not None:
             status_conditions.append(Status.label == str(label))
@@ -46,15 +52,73 @@ def retrieve_message_list(page, limit, user, ru_id=None, survey=None, cc=None, c
 
         try:
             t = db.session.query(SecureMessage.msg_id, func.max(Events.date_time)  # pylint:disable=no-member
-                                 .label('max_date'))\
+                                 .label('max_date')) \
                 .join(Events).join(Status).outerjoin(Actors) \
                 .filter(and_(*conditions)) \
                 .filter(and_(*status_conditions)) \
                 .filter(or_(Events.event == EventsApi.SENT.value, Events.event == EventsApi.DRAFT_SAVED.value)) \
                 .group_by(SecureMessage.msg_id).subquery('t')
 
             if descend:
-                result = SecureMessage.query\
+                result = SecureMessage.query \
+                    .filter(SecureMessage.msg_id == t.c.msg_id) \
+                    .order_by(t.c.max_date.desc()).paginate(page, limit, False)
+
+            else:
+                result = SecureMessage.query \
+                    .filter(SecureMessage.msg_id == t.c.msg_id) \
+                    .order_by(t.c.max_date.asc()).paginate(page, limit, False)
+
+        except Exception as e:
+            logger.error('Error retrieving messages from database', error=e)
+            raise InternalServerError(description="Error retrieving messages from database")
+
+        return True, result
+
+    @staticmethod
+    def _retrieve_message_list_internal(page, limit, ru_id, survey, cc, ce, label, descend):
+        """returns list of messages from db"""
+        conditions = []
+        status_reject_conditions = []
+        valid_statuses = []
+        actor_conditions = []
+
+        if label is not None:
+            valid_statuses.append(label)
+            if label in [Labels.INBOX.value, Labels.ARCHIVE.value, Labels.UNREAD.value]:
+                actor_conditions.append(Actors.sent_from_internal == False)  # NOQA pylint:disable=singleton-comparison
+            if label in [Labels.DRAFT.value, Labels.SENT.value]:
+                actor_conditions.append(Actors.sent_from_internal == True)  # NOQA pylint:disable=singleton-comparison
+        else:
+            status_reject_conditions.append(Labels.DRAFT_INBOX.value)
+            valid_statuses = [Labels.INBOX.value, Labels.DRAFT.value]
+            actor_conditions.append(True)
+
+        if ru_id is not None:
+            conditions.append(SecureMessage.ru_id == str(ru_id))
+
+        if survey is not None:
+            conditions.append(SecureMessage.survey == str(survey))
+
+        if cc is not None:
+            conditions.append(SecureMessage.collection_case == str(cc))
+
+        if ce is not None:
+            conditions.append(SecureMessage.collection_exercise == str(ce))
+
+        try:
+            t = db.session.query(SecureMessage.msg_id, func.max(Events.date_time)  # pylint:disable=no-member
+                                 .label('max_date')) \
+                .join(Events).join(Status).outerjoin(Actors) \
+                .filter(and_(*conditions)) \
+                .filter(or_(*actor_conditions)) \
+                .filter(~Status.label.in_(status_reject_conditions)) \
+                .filter(Status.label.in_(valid_statuses)) \
+                .filter(or_(Events.event == EventsApi.SENT.value, Events.event == EventsApi.DRAFT_SAVED.value)) \
+                .group_by(SecureMessage.msg_id).subquery('t')
+
+            if descend:
+                result = SecureMessage.query \
                     .filter(SecureMessage.msg_id == t.c.msg_id) \
                     .order_by(t.c.max_date.desc()).paginate(page, limit, False)
 
@@ -75,7 +139,8 @@ def unread_message_count(user):
         status_conditions = []
         status_conditions.append(Status.actor == str(user.user_uuid))
         try:
-            result = SecureMessage.query.join(Status).filter(and_(*status_conditions)).filter(Status.label == 'UNREAD').count()
+            result = SecureMessage.query.join(Status).filter(and_(*status_conditions)).filter(
+                Status.label == 'UNREAD').count()
         except Exception as e:
             logger.error('Error retrieving count of unread messages from database', error=e)
             raise InternalServerError(description="Error retrieving count of unread messages from database")
@@ -86,30 +151,34 @@ def retrieve_thread_list(page, limit, user):
         """returns list of threads from db"""
         status_conditions = []
         conditions = []
+        actor_conditions = []
 
         if user.is_respondent:
-            status_conditions.append(Status.actor == str(user.user_uuid))
+            actor_conditions.append(Status.actor == str(user.user_uuid))
         else:
-            status_conditions.append(Status.actor == constants.BRES_USER)
+            actor_conditions.append(Status.actor == str(user.user_uuid))
+            actor_conditions.append(Status.actor == constants.BRES_USER)
+            actor_conditions.append(Status.actor == constants.NON_SPECIFIC_INTERNAL_USER)
 
         status_conditions.append(Status.label != Labels.DRAFT_INBOX.value)
 
         try:
-            t = db.session.query(SecureMessage.thread_id, func.max(Events.date_time)  # pylint:disable=no-member
-                                 .label('max_date')) \
+            t = db.session.query(SecureMessage.thread_id, func.max(Events.id)  # pylint:disable=no-member
+                                 .label('max_id')) \
                 .join(Events).join(Status) \
                 .filter(and_(*status_conditions)) \
+                .filter(or_(*actor_conditions)) \
                 .filter(or_(Events.event == EventsApi.SENT.value, Events.event == EventsApi.DRAFT_SAVED.value)) \
                 .group_by(SecureMessage.thread_id).subquery('t')
 
             conditions.append(SecureMessage.thread_id == t.c.thread_id)
-            conditions.append(Events.date_time == t.c.max_date)
+            conditions.append(Events.id == t.c.max_id)
 
             result = SecureMessage.query.join(Events).join(Status) \
                 .filter(or_(Events.event == EventsApi.SENT.value, Events.event == EventsApi.DRAFT_SAVED.value)) \
                 .filter(and_(*conditions)) \
                 .filter(and_(*status_conditions)) \
-                .order_by(t.c.max_date.desc()).paginate(page, limit, False)
+                .order_by(t.c.max_id.desc()).paginate(page, limit, False)
 
         except Exception as e:
             logger.error('Error retrieving messages from database', error=e)
@@ -137,11 +206,14 @@ def retrieve_message(message_id, user):
     def retrieve_thread(thread_id, user, page, limit):
         """returns paginated list of messages for thread id"""
         status_conditions = []
+        actor_conditions = []
 
         if user.is_respondent:
-            status_conditions.append(Status.actor == str(user.user_uuid))
+            actor_conditions.append(Status.actor == str(user.user_uuid))
         else:
-            status_conditions.append(Status.actor == constants.BRES_USER)
+            actor_conditions.append(Status.actor == str(user.user_uuid))
+            actor_conditions.append(Status.actor == constants.BRES_USER)
+            actor_conditions.append(Status.actor == constants.NON_SPECIFIC_INTERNAL_USER)
 
         status_conditions.append(Status.label != Labels.DRAFT_INBOX.value)
 
@@ -150,6 +222,7 @@ def retrieve_thread(thread_id, user, page, limit):
             result = SecureMessage.query.join(Events).join(Status) \
                 .filter(SecureMessage.thread_id == thread_id) \
                 .filter(and_(*status_conditions)) \
+                .filter(or_(*actor_conditions)) \
                 .filter(or_(Events.event == EventsApi.SENT.value, Events.event == EventsApi.DRAFT_SAVED.value)) \
                 .order_by(Events.date_time.desc()).paginate(page, limit, False)
 
@@ -168,7 +241,7 @@ def retrieve_draft(message_id, user):
         """returns single draft from db"""
 
         try:
-            result = SecureMessage.query.filter(SecureMessage.msg_id == message_id)\
+            result = SecureMessage.query.filter(SecureMessage.msg_id == message_id) \
                 .filter(SecureMessage.statuses.any(Status.label == Labels.DRAFT.value)).first()
             if result is None:
                 logger.error('Draft does not exist', message_id=message_id)
@@ -203,7 +276,7 @@ def check_db_connection():
     def check_msg_id_is_a_draft(draft_id, user):
         """Check msg_id is that of a valid draft and return true/false if no ID is present"""
         try:
-            result = SecureMessage.query.filter(SecureMessage.msg_id == draft_id)\
+            result = SecureMessage.query.filter(SecureMessage.msg_id == draft_id) \
                 .filter(SecureMessage.statuses.any(Status.label == Labels.DRAFT.value)).first()
         except Exception as e:
             logger.error('Error retrieving message from database', error=e)

secure_message/resources/drafts.py

@@ -47,14 +47,14 @@ def post(self):
     @staticmethod
     def _save_draft(draft, saver=Saver()):
         saver.save_message(draft.data)
-
+        uuid_to = ''
         if draft.data.msg_to is not None and draft.data.msg_to:
             uuid_to = draft.data.msg_to[0]
             saver.save_msg_status(uuid_to, draft.data.msg_id, Labels.DRAFT_INBOX.value)
 
         uuid_from = draft.data.msg_from
         saver.save_msg_status(uuid_from, draft.data.msg_id, Labels.DRAFT.value)
-
+        saver.save_msg_actors(draft.data.msg_id, uuid_from, uuid_to, g.user.is_internal)
         saver.save_msg_event(draft.data.msg_id, EventsApi.DRAFT_SAVED.value)
 
 

secure_message/services/service_toggles.py

@@ -80,4 +80,4 @@ def get_user_details(self, user_details):
 case_service = Case(False)
 
 
-internal_user = InternalUser(False)
+internal_user_service = InternalUser(False)