Automatically join a room

cdci_data_analysis/analysis/matrix_helper.py

@@ -129,24 +129,39 @@
     #     open("debug_email_lines_too_long.text", "w").write(email_text)
     #     raise MatrixMessageNotSent(f"message not sent on matrix, lines too long!")
     res_content = {
-        'res_content_incident_reports': []
+        'res_content_incident_reports': [],
+        'res_content_incident_reports_failed': []
     }
 
     message_data = {
         'message_data_incident_reports': []
     }
 
     for incident_report_receiver_room_id in incident_report_receivers_room_ids:
-        res_data_message_receiver = send_message(
-            logger,
-            url_server=matrix_server_url,
-            sender_access_token=incident_report_sender_personal_access_token,
-            room_id=incident_report_receiver_room_id,
-            message_text=message_text,
-            message_body_html=message_body_html
-        )
-        message_data['message_data_incident_reports'].append(res_data_message_receiver['message_data'])
-        res_content['res_content_incident_reports'].append(res_data_message_receiver['res_content'])
+        if incident_report_receiver_room_id is not None and incident_report_receiver_room_id != "":
+            try:
+                join_room(
+                    logger,
+                    url_server=matrix_server_url,
+                    sender_access_token=incident_report_sender_personal_access_token,
+                    room_id=incident_report_receiver_room_id
+                )
+                res_data_message_receiver = send_message(
+                    logger,
+                    url_server=matrix_server_url,
+                    sender_access_token=incident_report_sender_personal_access_token,
+                    room_id=incident_report_receiver_room_id,
+                    message_text=message_text,
+                    message_body_html=message_body_html
+                )
+                message_data['message_data_incident_reports'].append(res_data_message_receiver['message_data'])
+                res_content['res_content_incident_reports'].append(res_data_message_receiver['res_content'])
+            except MatrixMessageNotSent as e:
+                sentry.capture_message(f'message sending via matrix failed {e}')
+                logger.warning(f"Issue in sending a message in the room {incident_report_receiver_room_id} using matrix: {e.message}")
+                res_content['res_content_incident_reports_failed'].append(f"Issue in sending a message in the room {incident_report_receiver_room_id} using matrix: {e.message}")
+        else:
+            logger.warning('a incident report matrix message could not be sent as an invalid room id was provided')
 
     store_incident_report_matrix_message(message_data, scratch_dir, sending_time=sending_time)
 
@@ -233,50 +248,108 @@
     message_body_html = template.render(**matrix_message_data)
     message_text = textify_matrix_message(message_body_html)
     res_content = {
-        'res_content_bcc_users': []
+        'res_content_bcc_users': [],
+        'res_content_bcc_users_failed': []
     }
 
     message_data = {
         'message_data_bcc_users': []
     }
     if receiver_room_id is not None and receiver_room_id != "":
-        res_data_message_token_user = send_message(
-            logger,
-            url_server=matrix_server_url,
-            sender_access_token=matrix_sender_access_token,
-            room_id=receiver_room_id,
-            message_text=message_text,
-            message_body_html=message_body_html
-        )
-        message_data_token_user = res_data_message_token_user['message_data']
-        res_content_token_user = res_data_message_token_user['res_content']
-        message_data['message_data_token_user'] = message_data_token_user
-        res_content['res_content_token_user'] = res_content_token_user
-    else:
-        logger.warning('a matrix message could not be sent to the token user as no personal room id was '
-                       'provided within the token')
-
-    for bcc_receiver_room_id in bcc_receivers_room_ids:
-        if bcc_receiver_room_id is not None and bcc_receiver_room_id != "":
-            res_data_message_cc_user = send_message(
+        try:
+            join_room(
+                logger,
+                url_server=matrix_server_url,
+                sender_access_token=matrix_sender_access_token,
+                room_id=receiver_room_id
+            )
+            res_data_message_token_user = send_message(
                 logger,
                 url_server=matrix_server_url,
                 sender_access_token=matrix_sender_access_token,
-                room_id=bcc_receiver_room_id,
+                room_id=receiver_room_id,
                 message_text=message_text,
                 message_body_html=message_body_html
             )
-            message_data_cc_user = res_data_message_cc_user['message_data']
-            message_data['message_data_bcc_users'].append(message_data_cc_user)
-            res_content_cc_user = res_data_message_cc_user['res_content']
-            res_content['res_content_bcc_users'].append(res_content_cc_user)
+            message_data_token_user = res_data_message_token_user['message_data']
+            res_content_token_user = res_data_message_token_user['res_content']
+            message_data['message_data_token_user'] = message_data_token_user
+            res_content['res_content_token_user'] = res_content_token_user
+        except MatrixMessageNotSent as e:
+            logger.warning(f"Issue in sending a message in the room {receiver_room_id} using matrix: {e.message}")
+            res_content['res_content_token_user_failure'] = f"Issue in sending a message in the room {receiver_room_id} using matrix: {e.message}"
+    else:
+        logger.warning('a matrix message could not be sent to the token user as no personal room id was '
+                       'provided within the token')
 
+    for bcc_receiver_room_id in bcc_receivers_room_ids:
+        if bcc_receiver_room_id is not None and bcc_receiver_room_id != "":
+            try:
+                join_room(
+                    logger,
+                    url_server=matrix_server_url,
+                    sender_access_token=matrix_sender_access_token,
+                    room_id=bcc_receiver_room_id
+                )
+                res_data_message_cc_user = send_message(
+                    logger,
+                    url_server=matrix_server_url,
+                    sender_access_token=matrix_sender_access_token,
+                    room_id=bcc_receiver_room_id,
+                    message_text=message_text,
+                    message_body_html=message_body_html
+                )
+                message_data_cc_user = res_data_message_cc_user['message_data']
+                message_data['message_data_bcc_users'].append(message_data_cc_user)
+                res_content_cc_user = res_data_message_cc_user['res_content']
+                res_content['res_content_bcc_users'].append(res_content_cc_user)
+            except MatrixMessageNotSent as e:
+                logger.warning(f"Issue in sending a message in the room {bcc_receiver_room_id} using matrix: {e.message}")
+                res_content['res_content_bcc_users_failed'].append(f"Issue in sending a message in the room {bcc_receiver_room_id} using matrix: {e.message}")
 
     store_status_matrix_message_info(message_data, status, scratch_dir, logger, sending_time=sending_time, first_submitted_time=time_request)
 
     return res_content
 
 
+def join_room(
+        logger,
+        url_server=None,
+        sender_access_token=None,
+        room_id=None,
+):
+    logger.info(f"Joining room wth id: {room_id}")
+    url = os.path.join(url_server, f'_matrix/client/v3/rooms/{room_id}/join')
+
+    headers = {
+        'Authorization': ' '.join(['Bearer', sender_access_token]),
+        'Content-type': 'application/json'
+    }
+
+    res = requests.post(url, headers=headers)
+
+    msg_response_data = None
+    if res.status_code in [403, 429]:
+        msg_response_data = res.json()
+        error_code = ""
+        if "errcode" in msg_response_data:
+            error_code = msg_response_data["errcode"]
+        error = ""
+        if "error" in msg_response_data:
+            error = msg_response_data["error"]
+        logger.info(f"Could not join the room: {room_id}, for the following reason: {error_code} - {error}")
+
+        sentry.capture_message(f"Could not join the room: {room_id}, for the following reason: {error_code}: {error}")
+        raise MatrixMessageNotSent(f"Could not join the room: {room_id}, for the following reason: {error_code}: {error}",
+                                   status_code=res.status_code,
+                                   payload={'matrix_error_message': f"{error_code} - {error}"})
+
+    elif res.status_code == 200:
+        logger.info(f"Successfully joined the room: {room_id}")
+
+    return msg_response_data
+
+
 def send_message(
         logger,
         url_server=None,

cdci_data_analysis/flask_app/app.py

@@ -1054,21 +1054,19 @@
             scratch_dir=scratch_dir
         )
 
-        report_incident_status['martix_message_report_status'] = 'incident report message successfully sent via matrix'
+        matrix_message_report_status = 'incident report message successfully sent via matrix'
+        if len(res_content['res_content_incident_reports_failed']) >= 1:
+            matrix_message_report_status = 'sending of an incident report message via matrix failed'
+
+        report_incident_status['martix_message_report_status'] = matrix_message_report_status
         report_incident_status['martix_message_report_status_details'] = {
             "res_content": res_content
         }
-    except matrix_helper.MatrixMessageNotSent as e:
-        report_incident_status['martix_message_report_status'] = 'sending message via matrix failed'
-        logging.warning(f'message sending via matrix failed: {e}')
-        sentry.capture_message(f'message sending via matrix failed {e}')
 
     except MissingRequestParameter as e:
         report_incident_status['martix_message_report_status'] = 'sending message via matrix failed'
         logging.warning(f'parameter missing during call back: {e}')
 
-    # response = jsonify({'report_incident_status': report_incident_status})
-
     return report_incident_status
 
 

cdci_data_analysis/flask_app/dispatcher_query.py

@@ -1151,49 +1151,44 @@
             logging.warning(f'issue when {step}: {e}')
             sentry.capture_message(f'issue when {step}: {e}')
 
-        try:
-            if is_message_to_send:
-                time_request = time_original_request
-                time_request_first_submitted = matrix_helper.get_first_submitted_matrix_message_time(self.scratch_dir)
-                if time_request_first_submitted is not None:
-                    time_request = time_request_first_submitted
-
-                res_content = matrix_helper.send_job_message(
-                    config=self.app.config['conf'],
-                    logger=self.logger,
-                    decoded_token=self.decoded_token,
-                    token=self.token,
-                    job_id=self.job_id,
-                    session_id=self.par_dic['session_id'],
-                    status=status,
-                    instrument=self.instrument_name,
-                    status_details=status_details,
-                    product_type=product_type,
-                    time_request=time_request,
-                    request_url=products_url,
-                    api_code=email_api_code,
-                    scratch_dir=self.scratch_dir)
-
-                matrix_message_status_details = {
-                    "res_content": res_content
-                }
-                if status_details is not None:
-                    matrix_message_status_details['status_details'] = status_details
+        if is_message_to_send:
+            time_request = time_original_request
+            time_request_first_submitted = matrix_helper.get_first_submitted_matrix_message_time(self.scratch_dir)
+            if time_request_first_submitted is not None:
+                time_request = time_request_first_submitted
+
+            res_content = matrix_helper.send_job_message(
+                config=self.app.config['conf'],
+                logger=self.logger,
+                decoded_token=self.decoded_token,
+                token=self.token,
+                job_id=self.job_id,
+                session_id=self.par_dic['session_id'],
+                status=status,
+                instrument=self.instrument_name,
+                status_details=status_details,
+                product_type=product_type,
+                time_request=time_request,
+                request_url=products_url,
+                api_code=email_api_code,
+                scratch_dir=self.scratch_dir)
+
+            matrix_message_status_details = {
+                "res_content": res_content
+            }
+            if status_details is not None:
+                matrix_message_status_details['status_details'] = status_details
 
-                job.write_dataserver_status(status_dictionary_value=status,
-                                            full_dict=self.par_dic,
-                                            matrix_message_status='matrix message sent',
-                                            matrix_message_status_details=json.dumps(matrix_message_status_details))
-            else:
-                job.write_dataserver_status(status_dictionary_value=status, full_dict=self.par_dic)
+            matrix_message_status = 'matrix message sent'
+            if 'res_content_token_user_failure' in res_content or len(res_content['res_content_bcc_users_failed']) >= 1:
+                matrix_message_status = 'sending message via matrix failed'
 
-        except matrix_helper.MatrixMessageNotSent as e:
             job.write_dataserver_status(status_dictionary_value=status,
                                         full_dict=self.par_dic,
-                                        matrix_message_status='sending message via matrix failed',
-                                        matrix_message_status_details=e.payload)
-            logging.warning(f'matrix message sending failed: {e}')
-            sentry.capture_message(f'sending matrix message failed {e.message}')
+                                        matrix_message_status=matrix_message_status,
+                                        matrix_message_status_details=json.dumps(matrix_message_status_details))
+        else:
+            job.write_dataserver_status(status_dictionary_value=status, full_dict=self.par_dic)
 
         try:
             # TODO for a future implementation
@@ -1973,37 +1968,37 @@
                             self.job_id,
                             self.app.config['conf'],
                             decoded_token=self.decoded_token):
-                        try:
-                            time_request = self.time_request
-                            time_request_first_submitted = matrix_helper.get_first_submitted_matrix_message_time(self.scratch_dir)
-                            if time_request_first_submitted is not None:
-                                time_request = time_request_first_submitted
-
-                            res_content = matrix_helper.send_job_message(
-                                config=self.app.config['conf'],
-                                logger=self.logger,
-                                decoded_token=self.decoded_token,
-                                token=self.token,
-                                job_id=self.job_id,
-                                session_id=self.par_dic['session_id'],
-                                status=query_new_status,
-                                instrument=self.instrument.name,
-                                product_type=product_type,
-                                time_request=time_request,
-                                request_url=products_url,
-                                api_code=email_api_code,
-                                scratch_dir=self.scratch_dir)
 
-                            matrix_message_status_details =  json.dumps({
-                                "res_content": res_content
-                            })
-                            query_out.set_status_field('matrix_message_status', 'matrix message sent')
-                            query_out.set_status_field('matrix_message_status_details', matrix_message_status_details)
-                        except matrix_helper.MatrixMessageNotSent as e:
-                            query_out.set_status_field('matrix_message_status', 'sending matrix message failed')
-                            query_out.set_status_field('matrix_message_status_details', e.payload)
-                            logging.warning(f'matrix message sending failed: {e}')
-                            sentry.capture_message(f'sending matrix message failed {e.message}')
+                        time_request = self.time_request
+                        time_request_first_submitted = matrix_helper.get_first_submitted_matrix_message_time(self.scratch_dir)
+                        if time_request_first_submitted is not None:
+                            time_request = time_request_first_submitted
+
+                        res_content = matrix_helper.send_job_message(
+                            config=self.app.config['conf'],
+                            logger=self.logger,
+                            decoded_token=self.decoded_token,
+                            token=self.token,
+                            job_id=self.job_id,
+                            session_id=self.par_dic['session_id'],
+                            status=query_new_status,
+                            instrument=self.instrument.name,
+                            product_type=product_type,
+                            time_request=time_request,
+                            request_url=products_url,
+                            api_code=email_api_code,
+                            scratch_dir=self.scratch_dir)
+
+                        matrix_message_status_details =  json.dumps({
+                            "res_content": res_content
+                        })
+
+                        matrix_message_status = 'matrix message sent'
+                        if 'res_content_token_user_failure' in res_content or len(res_content['res_content_bcc_users_failed']) >= 1:
+                            matrix_message_status = 'sending message via matrix failed'
+
+                        query_out.set_status_field('matrix_message_status', matrix_message_status)
+                        query_out.set_status_field('matrix_message_status_details', matrix_message_status_details)
 
                     if email_helper.is_email_to_send_run_query(self.logger,
                                                                query_new_status,