Reverting recent merge to analyze the issue

docker-compose.yml

@@ -110,10 +110,6 @@ services:
       - EVENT_QUEUE_PDFSTITCH_LARGE_FILE_STREAMKEY=${EVENT_QUEUE_PDFSTITCH_LARGE_FILE_STREAMKEY}
       - STREAM_SEPARATION_FILE_SIZE_LIMIT=${STREAM_SEPARATION_FILE_SIZE_LIMIT}
       - MUTE_NOTIFICATION=${MUTE_NOTIFICATION}
-      - UNOPENED_REPORT_CUTOFF_DAYS=${UNOPENED_REPORT_CUTOFF_DAYS}
-      - UNOPENED_REPORT_WAIT_DAYS=${UNOPENED_REPORT_WAIT_DAYS}
-      - UNOPENED_REPORT_JARO_CUTOFF=${UNOPENED_REPORT_JARO_CUTOFF}
-      - UNOPENED_REPORT_EMAIL_RECIPIENT=${UNOPENED_REPORT_EMAIL_RECIPIENT}
       #- LOG_ROOT=${LOG_ROOT}
       #- LOG_BASIC=${LOG_BASIC}
       #- LOG_TRACING=${LOG_TRACING}

request-management-api/request_api/models/FOIMinistryRequests.py

@@ -9,6 +9,7 @@
 from sqlalchemy import or_, and_, text, func, literal, cast, case, nullslast, nullsfirst, desc, asc
 from sqlalchemy.sql.sqltypes import String
 from sqlalchemy.dialects.postgresql import JSON
+
 from .FOIRequestApplicantMappings import FOIRequestApplicantMapping
 from .FOIRequestApplicants import FOIRequestApplicant
 from .FOIRequestStatus import FOIRequestStatus
@@ -583,8 +584,7 @@ def getrequestssubquery(cls, groups, filterfields, keyword, additionalfilter, us
                                     *joincondition_oipc
                                     ),
                                 isouter=True
-                            ).filter(or_(FOIMinistryRequest.requeststatuslabel != StateName.closed.name, 
-                                         and_(FOIMinistryRequest.isoipcreview == True, FOIMinistryRequest.requeststatusid == 3, subquery_with_oipc.c.outcomeid == None)))
+                            ).filter(or_(FOIMinistryRequest.requeststatuslabel != StateName.closed.name, and_(FOIMinistryRequest.isoipcreview == True, FOIMinistryRequest.requeststatusid == 3, subquery_with_oipc.c.outcomeid == None)))
 
         if(additionalfilter == 'watchingRequests'):
             #watchby
@@ -701,35 +701,42 @@ def getgroupfilters(cls, groups):
             ministryfilter = FOIMinistryRequest.isactive == True
         else:
             groupfilter = []
-            statusfilter = None
-            processinggroups = list(set(groups).intersection(ProcessingTeamWithKeycloackGroup.list())) 
-            if IAOTeamWithKeycloackGroup.intake.value in groups or len(processinggroups) > 0:
-                groupfilter.append(
+            for group in groups:
+                if (group == IAOTeamWithKeycloackGroup.flex.value or group in ProcessingTeamWithKeycloackGroup.list()):
+                    groupfilter.append(
+                        and_(
+                            FOIMinistryRequest.assignedgroup == group
+                        )
+                    )
+                elif (group == IAOTeamWithKeycloackGroup.intake.value):
+                    groupfilter.append(
+                        or_(
+                            FOIMinistryRequest.assignedgroup == group,
                             and_(
-                                FOIMinistryRequest.assignedgroup.in_(tuple(groups))
+                                FOIMinistryRequest.assignedgroup == IAOTeamWithKeycloackGroup.flex.value,
+                                FOIMinistryRequest.requeststatuslabel.in_([StateName.open.name])
                             )
                         )
-                statusfilter = FOIMinistryRequest.requeststatuslabel != StateName.closed.name
-            else:
-                groupfilter.append(
+                    )
+                else:
+                    groupfilter.append(
                         or_(
-                            FOIMinistryRequest.assignedgroup.in_(tuple(groups)),
+                            FOIMinistryRequest.assignedgroup == group,
                             and_(
-                                FOIMinistryRequest.assignedministrygroup.in_(tuple(groups))
+                                FOIMinistryRequest.assignedministrygroup == group,
+                                FOIMinistryRequest.requeststatuslabel.in_([StateName.callforrecords.name,StateName.recordsreview.name,StateName.feeestimate.name,StateName.consult.name,StateName.ministrysignoff.name,StateName.onhold.name,StateName.deduplication.name,StateName.harmsassessment.name,StateName.response.name,StateName.peerreview.name,StateName.tagging.name,StateName.readytoscan.name])
                             )
                         )
                     )
-                statusfilter = FOIMinistryRequest.requeststatuslabel.in_([StateName.callforrecords.name,StateName.recordsreview.name,StateName.feeestimate.name,StateName.consult.name,StateName.ministrysignoff.name,StateName.onhold.name,StateName.deduplication.name,StateName.harmsassessment.name,StateName.response.name,StateName.peerreview.name,StateName.tagging.name,StateName.readytoscan.name])
+
             ministryfilter = and_(
                                 FOIMinistryRequest.isactive == True,
                                 FOIRequestStatus.isactive == True,
                                 or_(*groupfilter)
                             )
-        ministryfilterwithclosedoipc = and_(ministryfilter, 
-                                            or_(statusfilter, 
-                                                and_(FOIMinistryRequest.isoipcreview == True, FOIMinistryRequest.requeststatuslabel == StateName.closed.name)
-                                                )
-                                            )
+
+        ministryfilterwithclosedoipc = or_(ministryfilter, and_(FOIMinistryRequest.isoipcreview == True, FOIMinistryRequest.requeststatuslabel == StateName.closed.name))
+
         return ministryfilterwithclosedoipc
 
     @classmethod

request-management-api/request_api/models/FOIRawRequests.py

@@ -1073,82 +1073,6 @@ def getlatestsection5pendings(cls):
         finally:
             db.session.close()
         return section5pendings
-
-    @classmethod
-    def getunopenedunactionedrequests(cls, startdate, enddate):
-        try:
-            requests = []
-            sql = '''select rr.created_at, rr.requestrawdata, rr.requestid, coalesce(p.status, '') as status,
-                         coalesce(p.transaction_number, '') as txnno,
-                         coalesce(p.total::text, '') as fee
-                    from public."FOIRawRequests" rr
-                    join (
-                        select max(version) as version, requestid from public."FOIRawRequests"
-                        group by requestid
-                    ) mv on mv.requestid = rr.requestid and mv.version = rr.version
-                    left join (
-                        select request_id, max(payment_id) from public."Payments"
-                        where fee_code_id = 1
-                        group by request_id
-                        order by request_id
-                    ) mp on mp.request_id = rr.requestid
-                    left join public."Payments" p on p.payment_id = mp.max
-                    where rr.status = 'Unopened' and rr.version = 1 and created_at > :startdate and created_at < :enddate
-                    order by rr.requestid '''
-            rs = db.session.execute(text(sql), {'startdate': startdate, 'enddate': enddate})
-            for row in rs:
-                requests.append({
-                    "requestid": row["requestid"],
-                    "created_at": row["created_at"],
-                    "requestrawdata": row["requestrawdata"],
-                    "paymentstatus": row["status"],
-                    "fee": row["fee"],
-                    "txnno": row["txnno"]
-                })
-        except Exception as ex:
-            logging.error(ex)
-            raise ex
-        finally:
-            db.session.close()
-        return requests
-
-    @classmethod
-    def getpotentialactionedmatches(cls, request):
-        try:
-            requests = []
-            sql = '''select rr.created_at, rr.* from public."FOIRawRequests" rr
-                    join (
-                        select max(version) as version, requestid from public."FOIRawRequests"
-                        group by requestid
-                    ) mv on mv.requestid = rr.requestid and mv.version = rr.version
-                    where status = 'Intake in Progress' and (
-                        requestrawdata->>'lastName' ilike :lastName
-                        or requestrawdata->>'firstName' ilike :firstName
-                        or requestrawdata->>'email' ilike :email
-                        or requestrawdata->>'address' ilike :address
-                        or requestrawdata->>'phonePrimary' ilike :phonePrimary
-                        or requestrawdata->>'postal' ilike :postal
-                    ) and substring(rr.requestrawdata->>'receivedDateUF', 1, 10) = :receiveddate
-                    order by requestid desc, version desc '''
-            rs = db.session.execute(text(sql), {
-                'lastName': request['requestrawdata']['contactInfo']['lastName'],
-                'firstName': request['requestrawdata']['contactInfo']['firstName'],
-                'email': request['requestrawdata']['contactInfoOptions']['email'],
-                'address': request['requestrawdata']['contactInfoOptions']['address'],
-                'phonePrimary': request['requestrawdata']['contactInfoOptions']['phonePrimary'],
-                'postal': request['requestrawdata']['contactInfoOptions']['postal'],
-                'receiveddate': request['requestrawdata']['receivedDateUF'][0:10],
-            })
-            for row in rs:
-                requests.append({"requestid": row["requestid"], "created_at": row["created_at"], "requestrawdata": row["requestrawdata"]})
-        except Exception as ex:
-            logging.error(ex)
-            raise ex
-        finally:
-            db.session.close()
-        return requests
-
-
 
 class FOIRawRequestSchema(ma.Schema):
     class Meta:

request-management-api/request_api/resources/request.py

@@ -25,7 +25,6 @@
 from request_api.services.rawrequestservice import rawrequestservice
 from request_api.services.documentservice import documentservice
 from request_api.services.eventservice import eventservice
-from request_api.services.unopenedreportservice import unopenedreportservice
 from request_api.utils.enums import StateName
 import json
 import asyncio
@@ -324,22 +323,4 @@ def post(requestid=None):
         except ValueError:
             return {'status': 500, 'message':"Invalid Request"}, 400    
         except BusinessException as exception:            
-            return {'status': exception.status_code, 'message':exception.message}, 500  
-
-@cors_preflight('POST,OPTIONS')
-@API.route('/foirawrequest/unopenedreport')
-class FOIRawRequestReport(Resource):
-    """Generates report of unopened requests that have not been actioned in over X amount of days"""
-
-
-    @staticmethod
-    @TRACER.trace()
-    @cross_origin(origins=allowedorigins())
-    @auth.require
-    def post():
-        try:
-            result = unopenedreportservice().generateunopenedreport()
-            # responsecode = 200 if result.success == True else 500
-            return {'status': True, 'message': result} , 200
-        except BusinessException as exception:
-            return {'status': exception.status_code, 'message':exception.message}, 500
+            return {'status': exception.status_code, 'message':exception.message}, 500  

request-management-api/request_api/services/email/senderservice.py

@@ -30,12 +30,12 @@ class senderservice:
 
     """
 
-    def send(self, subject, content, _messageattachmentlist, requestjson):
+    def send(self, servicekey, content, _messageattachmentlist, requestjson):
         logging.debug("Begin: Send email for request = "+json.dumps(requestjson))
         msg = MIMEMultipart()
         msg['From'] = MAIL_FROM_ADDRESS
         msg['To'] = requestjson["email"]
-        msg['Subject'] = subject
+        msg['Subject'] = templateconfig().getsubject(servicekey, requestjson)
         part = MIMEText(content, "html")
         msg.attach(part)
         # Add Attachment and Set mail headers

request-management-api/request_api/services/emailservice.py

@@ -34,8 +34,7 @@ def send(self, servicename, requestid, ministryrequestid, emailschema):
                 servicename = _templatename.upper() if _templatename else ""
             _messageattachmentlist = self.__get_attachments(ministryrequestid, emailschema, servicename)
             self.__pre_send_correspondence_audit(requestid, ministryrequestid,emailschema, content, templateconfig().isnotreceipt(servicename), _messageattachmentlist)
-            subject = templateconfig().getsubject(servicename, requestjson)
-            return senderservice().send(subject, _messagepart, _messageattachmentlist, requestjson)
+            return senderservice().send(servicename, _messagepart, _messageattachmentlist, requestjson)
         except Exception as ex:
             logging.exception(ex)