Pesticide liaison workflow

api/app/models/bookings/exam.py

@@ -49,6 +49,8 @@ class Exam(Base):
     payee_email = db.Column(db.String(50), nullable=True)
     payee_name = db.Column(db.String(50), nullable=True)
     payee_phone = db.Column(db.String(50), nullable=True)
+    candidates_list = db.Column(db.JSON, nullable=True)
+    is_pesticide = db.Column(db.Integer, nullable=True, default=0)
 
     booking = db.relationship("Booking")
     exam_type = db.relationship("ExamType")

api/app/resources/bookings/booking/booking_post.py

@@ -55,11 +55,23 @@ def post(self):
                 db.session.add(booking)
                 db.session.commit()
 
-            else:
+            elif type(i_id) == int:
 
                 booking.invigilators.append(Invigilator.query.filter_by(invigilator_id=i_id).first_or_404())
                 db.session.add(booking)
                 db.session.commit()
+
+            elif type(i_id) == list:
+
+                if len(i_id) == 0:
+                    db.session.add(booking)
+                    db.session.commit()
+
+                else:
+                    for value in i_id:
+                        booking.invigilators.append(Invigilator.query.filter_by(invigilator_id=value).first_or_404())
+                        db.session.add(booking)
+                        db.session.commit()
 
             result = self.booking_schema.dump(booking)
 

api/app/resources/bookings/exam/exam_bcmp.py

@@ -0,0 +1,80 @@
+'''Copyright 2018 Province of British Columbia
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.'''
+
+import logging
+import copy
+import json
+from flask import request, g
+from flask_restx import Resource
+from app.models.theq import CSR, Office
+from app.models.bookings import ExamType, Invigilator
+from app.schemas.bookings import ExamSchema, CandidateSchema
+from qsystem import api, api_call_with_retry, db, oidc
+from app.utilities.bcmp_service import BCMPService
+
+from app.resources.bookings.exam.exam_post import ExamPost
+
+@api.route("/exams/bcmp/", methods=["POST"])
+class ExamBcmpPost(Resource):
+
+    exam_schema = ExamSchema()
+    bcmp_service = BCMPService()
+
+    @oidc.accept_token(require_token=True)
+    @api_call_with_retry
+    def post(self):
+
+        csr = CSR.find_by_username(g.oidc_token_info['username'])
+
+        json_data = request.get_json()
+
+        exam, warning = self.exam_schema.load(json_data)
+
+        print("json_data: ")
+        print(json_data)
+
+        if warning:
+            logging.warning("WARNING: %s", warning)
+            return {"message": warning}, 422
+
+        if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
+            return {"The Exam Office ID and CSR Office ID do not match!"}, 403   
+
+        formatted_data = ExamPost.format_data(self, json_data, exam)
+        exam = formatted_data["exam"]
+
+        invigilator = None
+        if exam.invigilator_id:
+            invigilator = Invigilator.query.filter_by(invigilator_id=exam.invigilator_id).first()
+
+        bcmp_response = None
+        if json_data["ind_or_group"] == "individual":
+
+            exam_fees = json_data["fees"]
+
+            logging.info("Creating individual pesticide exam")
+            bcmp_response = self.bcmp_service.create_individual_exam(exam, exam_fees, invigilator, formatted_data["pesticide_office"], g.oidc_token_info)
+
+        else:
+
+            logging.info("Creating Group pesticide exam")
+            bcmp_response = self.bcmp_service.create_group_exam_bcmp(exam, formatted_data["candidates_list_bcmp"], invigilator, formatted_data["pesticide_office"], g.oidc_token_info)
+
+
+        if bcmp_response:
+            return {"bcmp_job_id": bcmp_response['jobId'],
+                "errors": {}}, 201
+        else:
+            return {"message": "create_group_exam_bcmp failed",
+                "error": bcmp_response}, 403

api/app/resources/bookings/exam/exam_bulk_status.py

@@ -13,28 +13,54 @@
 limitations under the License.'''
 
 import logging
+import json
 from flask import g
-from flask_restplus import Resource
+from flask_restx import Resource
 from sqlalchemy import exc
 from app.models.bookings import Exam
+from app.schemas.bookings import ExamSchema
 from app.models.theq import CSR
 from app.utilities.bcmp_service import BCMPService
-from qsystem import api, oidc
+from qsystem import api, oidc, db
 
 
 @api.route("/exams/bcmp_status/", methods=["POST"])
 class ExamList(Resource):
     bcmp_service = BCMPService()
+    exam_schema = ExamSchema()
 
     @oidc.accept_token(require_token=True)
     def post(self):
         csr = CSR.find_by_username(g.oidc_token_info['username'])
 
         try:
             exams = Exam.query.filter_by(upload_received_ind=0).filter(Exam.bcmp_job_id.isnot(None))
-            self.bcmp_service.bulk_check_exam_status(exams)
+            bcmp_response = self.bcmp_service.bulk_check_exam_status(exams)
 
-            return {}, 200
+            job_ids = []
+            for job in bcmp_response["jobs"]:
+                if job["jobStatus"] == "RESPONSE_UPLOADED":
+                    job_ids.append(job["jobId"])
+
+            print("job_ids to update: ")
+            print(job_ids)
+
+            exams_tobe_updated = None
+
+            if len(job_ids) != 0:
+                exams_tobe_updated = Exam.query.filter(Exam.bcmp_job_id.in_(job_ids))
+
+                for exam in exams_tobe_updated:
+                    exam_upd, warn = self.exam_schema.load({'upload_received_ind': 1}, instance=exam, partial=True)
+                    db.session.add(exam_upd)
+
+                try:
+                    db.session.commit()
+                except:
+                    db.session.rollback()
+                    raise
+
+            return {"exams_updated": exams_tobe_updated}, 200
 
         except exc.SQLAlchemyError as error:
             logging.error(error, exc_info=True)

api/app/resources/bookings/exam/exam_download.py

@@ -13,7 +13,7 @@
 limitations under the License.'''
 
 from flask import g, Response
-from flask_restplus import Resource
+from flask_restx import Resource
 import io
 import logging
 import urllib
@@ -40,11 +40,11 @@ def get(self, exam_id):
             if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
                 return {"The Exam Office ID and CSR Office ID do not match!"}, 403
 
-            status = self.bcmp_service.check_exam_status(exam)
-            print(status)
+            job = self.bcmp_service.check_exam_status(exam)
+            print(job)
 
-            if status == 'PACKAGE_GENERATED':
-                package_url = status["jobProperties"]["EXAM_PACKAGE_URL"]
+            if job['jobStatus'] == 'PACKAGE_GENERATED':
+                package_url = job["jobProperties"]["EXAM_PACKAGE_URL"]
                 req = urllib.request.Request(package_url)
                 response = urllib.request.urlopen(req).read()
                 exam_file = io.BytesIO(response)
@@ -58,7 +58,7 @@ def get(self, exam_id):
                                     "Content-Type": "application/pdf"
                                 })
             else:
-                return {'message': 'API is down'}, 400
+                return {'message': 'Package not yet generated', 'status': job['jobStatus']}, 400
                 # test_url = 'http://www.pdf995.com/samples/pdf.pdf'
                 # req = urllib.request.Request(test_url)
                 # response = urllib.request.urlopen(req).read()

api/app/resources/bookings/exam/exam_email_invigilator.py

@@ -13,7 +13,7 @@
 limitations under the License.'''
 
 from flask import g, request
-from flask_restplus import Resource
+from flask_restx import Resource
 import logging
 from sqlalchemy import exc
 from app.models.theq import CSR

api/app/resources/bookings/exam/exam_post.py

@@ -13,16 +13,17 @@
 limitations under the License.'''
 
 import logging
+import copy
+import json
 from flask import request, g
 from flask_restx import Resource
 from app.models.theq import CSR, Office
-from flask_restplus import Resource
-from app.models.bookings import ExamType
-from app.schemas.bookings import ExamSchema
+from flask_restx import Resource
+from app.models.bookings import ExamType, Invigilator
+from app.schemas.bookings import ExamSchema, CandidateSchema
 from qsystem import api, api_call_with_retry, db, oidc
 from app.utilities.bcmp_service import BCMPService
 
-
 @api.route("/exams/", methods=["POST"])
 class ExamPost(Resource):
 
@@ -33,46 +34,34 @@ class ExamPost(Resource):
     @api_call_with_retry
     def post(self):
 
+        is_bcmp_req = True if request.args.get('bcmp_pesticide') else False
+
+        print("is_bcmp_req: ")
+        print(is_bcmp_req)
+
         csr = CSR.find_by_username(g.oidc_token_info['username'])
 
         json_data = request.get_json()
 
         exam, warning = self.exam_schema.load(json_data)
 
+        print("json_data: ")
+        print(json_data)
+
         if warning:
             logging.warning("WARNING: %s", warning)
             return {"message": warning}, 422
-        print("+=+=+=+= NAME: %s +=+=+=+=" % exam.examinee_name)
-
-        exam_type = ExamType.query.filter_by(exam_type_id=exam.exam_type_id).first()
-
-        if not exam_type:
-            exam_type = ExamType.query.filter_by(pesticide_exam_ind=1, group_exam_ind=1).first()
-            exam.exam_type = exam_type
-
-        if exam_type.pesticide_exam_ind:
-            if not exam_type.group_exam_ind:
-                logging.info("Create BCMP exam since this is a pesticide exam")
-
-                if json_data["sbc_managed"] != "sbc":
-                    print("Setting non-SBC shit")
-                    pesticide_office = Office.query.filter_by(office_name="Pesticide Offsite").first()
-                    exam.office_id = pesticide_office.office_id
-
-                if exam_type.group_exam_ind:
-                    logging.info("Creating group pesticide exam")
-                    bcmp_response = self.bcmp_service.create_group_exam(exam)
-                else:
-                    logging.info("Creating individual pesticide exam")
-                    bcmp_response = self.bcmp_service.create_individual_exam(exam, exam_type)
-
-                if bcmp_response:
-                    exam.bcmp_job_id = bcmp_response['jobId']
-            else:
-                print("Do the group exam shit here")
-        else:
-            if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
-                return {"The Exam Office ID and CSR Office ID do not match!"}, 403
+
+        if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
+            return {"The Exam Office ID and CSR Office ID do not match!"}, 403   
+
+        if exam.is_pesticide:
+            formatted_data = self.format_data(json_data, exam)
+            exam = formatted_data["exam"]
+            job = self.bcmp_service.check_exam_status(exam)
+            print(job)
+            if job and job['jobProperties'] and job['jobProperties']['JOB_ID']:
+                exam.event_id = job['jobProperties']['JOB_ID']
 
         db.session.add(exam)
         db.session.commit()
@@ -81,3 +70,64 @@ def post(self):
 
         return {"exam": result.data,
                 "errors": result.errors}, 201
+
+
+
+    ## formating data to save on bcmp
+    def format_data(self, json_data, exam):
+
+        candidates_list_bcmp = []
+
+        pesticide_office = None
+        if json_data["sbc_managed"] == "sbc":
+            pesticide_office = Office.query.filter_by(office_id=exam.office_id).first()
+        else:
+            pesticide_office = Office.query.filter_by(office_name="Pesticide Offsite").first()
+            exam.office_id = pesticide_office.office_id
+
+        if json_data["ind_or_group"] == "individual":
+
+            exam_type = ExamType.query.filter_by(exam_type_id=exam.exam_type_id).first()
+
+            if not exam_type:
+                exam_type = ExamType.query.filter_by(pesticide_exam_ind=1, group_exam_ind=1).first()
+            exam.exam_type = exam_type
+
+        else:
+            logging.info("For Group Exams")
+
+            exam_type = ExamType.query.filter_by(exam_type_name="Group Pesticide Exam").first()
+            if exam_type:
+                exam.exam_type_id = exam_type.exam_type_id
+                exam.exam_type = exam_type
+
+            if json_data["candidates"]:
+                candidates = json_data["candidates"]
+                candidates_list = []
+                for candidate in candidates:
+                    candidate_temp = {}
+                    candidate_temp["examinee_name"] = candidate["name"]
+                    candidate_temp["examinee_email"] = candidate["email"]
+                    candidate_temp["exam_type_id"] = candidate["exam_type_id"]
+                    candidate_temp["fees"] = candidate["fees"]
+                    candidate_temp["payee_ind"] = 1 if (candidate["billTo"] == "candidate") else 0
+                    candidate_temp["receipt"] = candidate["receipt"]
+                    candidate_temp["receipt_number"] = candidate["receipt"]
+                    candidate_temp["payee_name"] = candidate["payeeName"]
+                    candidate_temp["payee_email"] = candidate["payeeEmail"]
+                    candidates_list.append(candidate_temp)
+                    # for bcmp service
+                    candidates_bcmp = copy.deepcopy(candidate_temp)
+                    exam_type = ExamType.query.filter_by(exam_type_id=candidate["exam_type_id"]).first()
+                    if exam_type.exam_type_name:
+                        candidates_bcmp["exam_type"] = exam_type.exam_type_name
+                    candidates_list_bcmp.append(candidates_bcmp)
+
+                exam.candidates_list = candidates_list
+
+        return { 
+            'exam': exam, 
+            'candidates_list_bcmp': candidates_list_bcmp, 
+            'pesticide_office': pesticide_office,
+        }
+

api/app/resources/bookings/exam/exam_transfer.py

@@ -13,7 +13,7 @@
 limitations under the License.'''
 
 from flask import g
-from flask_restplus import Resource
+from flask_restx import Resource
 import logging
 from sqlalchemy import exc
 from app.models.theq import CSR
@@ -37,8 +37,14 @@ def post(self, exam_id):
             if not (exam.office_id == csr.office_id or csr.liaison_designate == 1):
                 return {"The Exam Office ID and CSR Office ID do not match!"}, 403
 
-            self.bcmp_service.send_exam_to_bcmp(exam)
-            return {}
+            bcmp_response = self.bcmp_service.send_exam_to_bcmp(exam)
+
+            if bcmp_response:
+                return {"bcmp": bcmp_response,
+                "errors": {}}, 202
+            else:
+                return {"message": "create_group_exam_bcmp failed",
+                    "error": bcmp_response}, 403
 
         except exc.SQLAlchemyError as error:
             logging.error(error, exc_info=True)