def post(self):
my_print("==> In AppointmentDraftPost, POST /appointments/draft")
json_data = request.get_json()
office_id = json_data.get('office_id')
service_id = json_data.get('service_id')
start_time = parse(json_data.get('start_time'))
end_time = parse(json_data.get('end_time'))
office = Office.find_by_id(office_id)
service = Service.query.get(int(service_id)) if service_id else None
# end_time can be null for CSRs when they click; whereas citizens know end-time.
if not end_time:
end_time = add_delta_to_time(start_time, minutes=office.appointment_duration, timezone=office.timezone.timezone_name)
# Unauthenticated requests from citizens won't have name, so we set a fallback
if (hasattr(g, 'oidc_token_info') and hasattr(g.oidc_token_info, 'username')):
user = PublicUser.find_by_username(g.oidc_token_info['username'])
citizen_name = user.display_name
else:
citizen_name = 'Draft'
# Delete all expired drafts before checking availability
Appointment.delete_expired_drafts()
csr = None
if (hasattr(g, 'oidc_token_info')):
csr = CSR.find_by_username(g.oidc_token_info['username'])
# CSRs are not limited by drafts, can always see other CSRs drafts
# This mitigates two CSRs in office creating at same time for same meeting
# Ensure there's no race condition when submitting a draft
if not csr and not AvailabilityService.has_available_slots(
office=office,
start_time=start_time,
end_time=end_time,
service=service):
return {"code": "CONFLICT_APPOINTMENT",
"message": "Cannot create appointment due to scheduling conflict. Please pick another time."}, 400
# Set draft specific data
json_data['is_draft'] = True
json_data['citizen_name'] = citizen_name
appointment, warning = self.appointment_schema.load(json_data)
if warning:
logging.warning("WARNING: %s", warning)
return {"message": warning}, 422
db.session.add(appointment)
db.session.commit()
result = self.appointment_schema.dump(appointment)
socketio.emit('appointment_create', result.data)
return {"appointment": result.data, "warning" : warning}, 201
def post(self, id):
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
citizen = Citizen.query\
.options(joinedload(Citizen.service_reqs).joinedload(ServiceReq.periods).options(raiseload(Period.sr),joinedload(Period.csr).raiseload('*')),joinedload(Citizen.office),raiseload(Citizen.user)) \
.filter_by(citizen_id=id, office_id=csr.office_id)
citizen = citizen.first()
my_print("==> POST /citizens/" + str(citizen.citizen_id) + '/place_on_hold/, Ticket: ' + citizen.ticket_number)
active_service_request = citizen.get_active_service_request()
if active_service_request is None:
return {"message": "Citizen has no active service requests"}
active_service_request.place_on_hold(csr)
pending_service_state = SRState.get_state_by_name("Active")
active_service_request.sr_state_id = pending_service_state.sr_state_id
db.session.add(citizen)
db.session.commit()
socketio.emit('update_customer_list', {}, room=csr.office.office_name)
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen', result, room=csr.office.office_name)
return {'citizen': result,
'errors': self.citizen_schema.validate(citizen)}, 200
def put(self, id):
json_data = request.get_json()
if 'counter_id' not in json_data:
json_data['counter_id'] = counter_id
if not json_data:
return {'message': 'No input data received for updating citizen'}, 400
csr = CSR.find_by_username(g.oidc_token_info['username'])
citizen = Citizen.query.filter_by(citizen_id=id).first()
my_print("==> PUT /citizens/" + str(citizen.citizen_id) + '/, Ticket: ' + str(citizen.ticket_number))
try:
citizen = self.citizen_schema.load(json_data, instance=citizen, partial=True).data
except ValidationError as err:
return {'message': err.messages}, 422
db.session.add(citizen)
db.session.commit()
# If this put request is the result of an appointment checkin, make a Snowplow call.
if ('snowplow_addcitizen' in json_data) and (json_data['snowplow_addcitizen'] == True):
SnowPlow.add_citizen(citizen, csr)
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen', result.data, room=csr.office_id)
return {'citizen': result.data,
'errors': result.errors}, 200
def put(self, id):
json_data = request.get_json()
counter = Counter.query.filter(Counter.counter_name == "Counter")[0]
if 'counter_id' not in json_data:
json_data['counter_id'] = counter.counter_id
if not json_data:
return {
'message': 'No input data received for updating citizen'
}, 400
csr = CSR.find_by_username(g.oidc_token_info['username'])
citizen = Citizen.query.filter_by(citizen_id=id,
office_id=csr.office_id).first()
my_print("==> PUT /citizens/" + str(citizen.citizen_id) +
'/, Ticket: ' + str(citizen.ticket_number))
try:
citizen = self.citizen_schema.load(json_data,
instance=citizen,
partial=True).data
except ValidationError as err:
return {'message': err.messages}, 422
db.session.add(citizen)
db.session.commit()
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen', result.data, room=csr.office_id)
return {'citizen': result.data, 'errors': result.errors}, 200
def on_join(message):
cookie = request.cookies.get("oidc-jwt", None)
if cookie is None:
emit('joinRoomFail', {"sucess": False})
return
if not oidc.validate_token(cookie):
print("Cookie failed validation")
emit('joinRoomFail', {"sucess": False})
return
claims = jwt.get_unverified_claims(cookie)
if claims["preferred_username"]:
my_print("==> In Python, @socketio.on('joinRoom'): claims['preferred_username'] is: " + str(claims["preferred_username"]))
csr = CSR.find_by_username(claims["preferred_username"])
if csr:
join_room(csr.office_id)
print("==> In websocket.py, CSR joinroom, CSR: " + csr.username + "; request sid: " + str(request.sid))
emit('joinRoomSuccess', {"sucess": True})
emit('get_Csr_State_IDs', {"success": True})
emit('update_customer_list', {"success": True})
else:
print("Fail")
emit('joinRoomFail', {"success": False})
else:
print("No preferred_username on request")
emit('joinRoomFail', {"success": False})
def post(self, id):
csr = CSR.find_by_username(g.oidc_token_info['username'])
citizen = Citizen.query.filter_by(citizen_id=id).first()
active_service_request = citizen.get_active_service_request()
my_print("==> POST /citizens/" + str(citizen.citizen_id) +
'/remove_from_queue, Ticket: ' + citizen.ticket_number)
if active_service_request is None:
return {"message": "Citizen has no active service requests"}
appointment = Appointment.query.filter_by(citizen_id=id) \
.filter_by(office_id=csr.office_id) \
.filter(Appointment.checked_in_time.isnot(None)) \
.first_or_404()
# This "un-check-in"s the appointment, returning it to calendar and removing from the queue.
appointment.checked_in_time = None
db.session.commit()
# ARC - Is below necessary? Think not. Causes issue when re-checking in a removed one.
# It DOES remove from queue, but stops it from being re-added?
# active_service_request.remove_from_queue()
# appointment, warning = self.appointment_schema.load(json_data, instance=appointment, partial=True)
# if warning:
# logging.warning("WARNING: %s", warning)
# return {"message": warning}, 422
result = self.appointment_schema.dump(appointment)
return {"appointment": result.data, "errors": result.errors}, 200
def post(self, id):
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
citizen = Citizen.query.filter_by(citizen_id=id).first()
my_print("==> POST /citizens/" + str(citizen.citizen_id) +
'/finish_service/, Ticket: ' + citizen.ticket_number)
active_service_request = citizen.get_active_service_request()
inaccurate = request.args.get('inaccurate')
if active_service_request is None:
return {"message": "Citizen has no active service requests"}
# If citizen here overnight, or inaccurate time flag set, update accurate time flag.
if citizen.start_time.date() != datetime.now().date(
) or inaccurate == 'true':
citizen.accurate_time_ind = 0
SnowPlow.snowplow_event(
citizen.citizen_id,
csr,
"finish",
quantity=active_service_request.quantity,
current_sr_number=active_service_request.sr_number)
active_sr_id = active_service_request.sr_id
active_service_request.finish_service(csr, self.clear_comments_flag)
citizen_state = CitizenState.query.filter_by(
cs_state_name="Received Services").first()
citizen.cs_id = citizen_state.cs_id
pending_service_state = SRState.get_state_by_name("Complete")
active_service_request.sr_state_id = pending_service_state.sr_state_id
# remove walkin unique id when service is finished
citizen.walkin_unique_id = None
db.session.add(citizen)
db.session.commit()
# Loop to stop all services in the service stopped state (which are all except the active service)
if len(citizen.service_reqs) != 1:
for sr in citizen.service_reqs:
if sr.sr_id != active_sr_id:
SnowPlow.snowplow_event(citizen.citizen_id,
csr,
"finishstopped",
quantity=sr.quantity,
current_sr_number=sr.sr_number)
socketio.emit('citizen_invited', {},
room='sb-%s' % csr.office.office_number)
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen', result, room=csr.office_id)
return {
'citizen': result,
'errors': self.citizen_schema.validate(citizen)
}, 200
def post(self, id):
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
lock = FileLock("lock/begin_citizen_{}.lock".format(csr.office_id))
with lock:
citizen = Citizen.query\
.options(joinedload(Citizen.service_reqs).options(joinedload(ServiceReq.periods).options(joinedload(Period.ps).options(raiseload('*')),joinedload(Period.csr).options(raiseload('*')),raiseload('*')), joinedload(ServiceReq.service).options(joinedload(Service.parent).options(raiseload(Service.parent).options(raiseload('*'))),raiseload('*'))), joinedload(Citizen.office).options(joinedload(Office.sb),raiseload('*')), raiseload(Citizen.user)) \
.filter_by(citizen_id=id)
citizen = citizen.first()
pending_service_state = SRState.get_state_by_name("Active")
if citizen is None:
print(
"==> POST /citizen/<id>/begin_service/ error. No citizen with id "
+ str(id))
return {"message": "No citizen found with id " + str(id)}
else:
my_print("==> POST /citizens/" + str(citizen.citizen_id) +
'/begin_service/, Ticket: ' + citizen.ticket_number)
active_service_request = citizen.get_active_service_request()
if active_service_request is None:
return {"message": "Citizen has no active service requests"}
try:
# Get Snowplow call.
active_period = active_service_request.get_active_period()
snowplow_event = "beginservice"
if active_period.ps.ps_name == "On hold":
snowplow_event = "invitefromhold"
if active_period.ps.ps_name == "Ticket Creation":
snowplow_event = "servecitizen"
active_service_request.begin_service(csr, snowplow_event)
except TypeError:
return {"message": "Citizen has already been invited"}, 400
active_service_request.sr_state_id = pending_service_state.sr_state_id
db.session.add(citizen)
db.session.commit()
if snowplow_event != "beginservice":
socketio.emit('update_customer_list', {},
room=csr.office.office_name)
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen',
result,
room=csr.office.office_name)
return {
'citizen': result,
'errors': self.citizen_schema.validate(citizen)
}, 200
def get(self, exam_id):
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
try:
exam = Exam.query.filter_by(exam_id=exam_id).first()
if not (exam.office_id == csr.office_id
or csr.ita2_designate == 1):
return {"The Exam Office ID and CSR Office ID do not match!"
}, 403
job = self.bcmp_service.check_exam_status(exam)
my_print(job)
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)
file_wrapper = FileWrapper(exam_file)
return Response(file_wrapper,
mimetype="application/pdf",
direct_passthrough=True,
headers={
"Content-Disposition":
'attachment; filename="%s.csv"' %
exam.exam_id,
"Content-Type":
"application/pdf"
})
else:
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()
# exam_file = io.BytesIO(response)
# file_wrapper = FileWrapper(exam_file)
#
# return Response(file_wrapper,
# mimetype="application/pdf",
# direct_passthrough=True,
# headers={
# "Content-Disposition": 'attachment; filename="%s.csv"' % exam.exam_id,
# "Content-Type": "application/pdf"
# })
except exc.SQLAlchemyError as error:
logging.error(error, exc_info=True)
return {'message': 'API is down'}, 500
def create_group_exam(self, exam):
url = "%s/auth=%s;%s/JSON/create:BCMD-EXAM" % (
self.base_url, self.bcmp_user, self.auth_token)
my_print(" ==> create_group_exam url: %s" % url)
bcmp_exam = {"students": []}
for s in exam.students:
bcmp_exam["students"].append({"name": s.name})
response = self.send_request(url, 'POST', bcmp_exam)
return response
def bulk_check_exam_status(self, exams):
url = "%s/auth=env_exam;%s/JSON/status" % (self.base_url,
self.auth_token)
data = {"jobs": []}
for exam in exams:
data["jobs"].append(exam.bcmp_job_id)
response = self.send_request(url, 'POST', data)
my_print(response)
return response
def post(self):
y = 0
key = "DR->" + get_key()
y = y + 1
csr = csr_find_by_user()
lock = FileLock("lock/invite_citizen_{}.lock".format(csr.office_id))
with lock:
active_citizen_state = citizen_state
waiting_period_state = find_wait()
citizen = None
json_data = request.get_json()
if json_data and 'counter_id' in json_data:
counter_id = int(json_data.get('counter_id'))
else:
counter_id = int(csr.counter_id)
citizen = find_citizen(counter_id,active_citizen_state, csr, waiting_period_state)
# If no matching citizen with the same counter type, get next one
if citizen is None:
citizen = find_citizen2(active_citizen_state, csr, waiting_period_state)
if citizen is None:
return {"message": "There is no citizen to invite"}, 400
my_print("==> POST /citizens/invite/ Citizen: " + str(citizen.citizen_id) + ', Ticket: ' + citizen.ticket_number)
db.session.refresh(citizen)
active_service_request = find_active_sr(citizen)
try:
invite_active_sr(active_service_request,csr,citizen)
except TypeError:
return {"message": "Error inviting citizen. Please try again."}, 400
active_service_state = find_active_ss()
active_service_request.sr_state_id = active_service_state.sr_state_id
db.session.add(citizen)
db.session.commit()
socketio.emit('update_customer_list', {}, room=csr.office.office_name)
socketio.emit('citizen_invited', {}, room='sb-%s' % csr.office.office_number)
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen', result, room=csr.office.office_name)
return {'citizen': result,
'errors': self.citizen_schema.validate(citizen)}, 200
def check_exam_status(self, exam):
url = "%s/auth=env_exam;%s/JSON/status" % (self.base_url,
self.auth_token)
data = {"jobs": [exam.bcmp_job_id]}
response = self.send_request(url, 'POST', data)
if response and response['jobs']:
for job in response['jobs']:
my_print(job)
if job['jobId'] == exam.bcmp_job_id:
return job
return False
def get(self, id):
try:
csr = CSR.find_by_username(g.oidc_token_info['username'])
citizen = Citizen.query.filter_by(citizen_id=id,
office_id=csr.office_id).first()
my_print("==> GET /citizens/" + str(citizen.citizen_id) +
'/, Ticket: ' + citizen.ticket_number)
result = self.citizen_schema.dump(citizen)
return {'citizen': result.data, 'errors': result.errors}
except exc.SQLAlchemyError as e:
print(e)
return {'message': 'API is down'}, 500
def get(self, id):
try:
citizen = Citizen.query.filter_by(citizen_id=id).first()
citizen_ticket = "None"
if hasattr(citizen, 'ticket_number'):
citizen_ticket = str(citizen.ticket_number)
my_print("==> GET /citizens/" + str(citizen.citizen_id) + '/, Ticket: ' + citizen_ticket)
result = self.citizen_schema.dump(citizen)
return {'citizen': result,
'errors': self.citizen_schema.validate(citizen)}
except exc.SQLAlchemyError as e:
print(e)
return {'message': 'API is down'}, 500
def on_join_smartboard(message):
try:
office_id = int(message['office_id'])
room = "sb-%s" % office_id
my_print("Joining room: %s" % room)
join_room(room)
emit('joinSmartboardRoomSuccess')
except KeyError as e:
print(e)
emit('joinSmartboardRoomFail', {"sucess": False, "message": "office_id must be passed to this method"})
except ValueError as e:
print(e)
emit('joinSmartboardRoomFail', {"sucess": False, "message": "office_id must be an integer"})
def find_by_username(cls, username):
# Possible keycloak->TheQ id values are user@idir->user, idir/user->user or user@bceid->user@bceid
idir_id = username.split("idir/")[-1].lower()
if "@idir" in username:
idir_id = username.split("@idir")[0].lower()
key = CSR.format_string % idir_id
if cache.get(key):
return cache.get(key)
my_print("==> In Python, csr.py, find_by_username: username="******"; idir_id=" + str(idir_id))
csr = CSR.query.filter(
CSR.deleted.is_(None)).filter(CSR.username == idir_id).first()
cache.set(key, csr)
return csr
def on_join_smartboard(message):
try:
office_id = int(message['office_id'])
room = "sb-%s" % office_id
my_print("Joining room: %s" % room)
join_room(room)
print("==> In websocket.py, Smartboard joinroom, Office id: " + str(office_id) + "; request sid: " + str(request.sid))
emit('joinSmartboardRoomSuccess')
except KeyError as e:
print(e)
emit('joinSmartboardRoomFail', {"sucess": False, "message": "office_id must be passed to this method"})
except ValueError as e:
print(e)
emit('joinSmartboardRoomFail', {"sucess": False, "message": "office_id must be an integer"})
def post(self, id):
csr = CSR.find_by_username(g.oidc_token_info['username'])
lock = FileLock("lock/begin_citizen_{}.lock".format(csr.office_id))
with lock:
citizen = Citizen.query.filter_by(citizen_id=id,
office_id=csr.office_id).first()
pending_service_state = SRState.get_state_by_name("Active")
my_print("==> POST /citizens/" + str(citizen.citizen_id) +
'/begin_service, Ticket: ' + citizen.ticket_number)
active_service_request = citizen.get_active_service_request()
if active_service_request is None:
return {"message": "Citizen has no active service requests"}
try:
# Get Snowplow call.
active_period = active_service_request.get_active_period()
snowplow_event = "beginservice"
if active_period.ps.ps_name == "On hold":
snowplow_event = "invitefromhold"
if active_period.ps.ps_name == "Ticket Creation":
snowplow_event = "servecitizen"
active_service_request.begin_service(csr, snowplow_event)
except TypeError:
return {"message": "Citizen has already been invited"}, 400
active_service_request.sr_state_id = pending_service_state.sr_state_id
db.session.add(citizen)
db.session.commit()
if snowplow_event != "beginservice":
socketio.emit('update_customer_list', {}, room=csr.office_id)
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen',
result.data,
room=csr.office_id)
return {'citizen': result.data, 'errors': result.errors}, 200
def post(self, id):
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
lock = FileLock("lock/invite_citizen_{}.lock".format(csr.office_id))
with lock:
citizen = db.session.query(Citizen).filter_by(
citizen_id=id).first()
my_print("==> POST /citizens/" + str(citizen.citizen_id) +
'/invite/, Ticket: ' + citizen.ticket_number)
active_service_state = SRState.get_state_by_name("Active")
active_service_request = citizen.get_active_service_request()
if active_service_request is None:
return {
"message": "Citizen has no active service requests"
}, 400
try:
active_service_request.invite(csr,
invite_type="specific",
sr_count=len(
citizen.service_reqs))
except TypeError:
return {"message": "Citizen has already been invited"}, 400
active_service_request.sr_state_id = active_service_state.sr_state_id
db.session.add(citizen)
db.session.commit()
socketio.emit('update_customer_list', {},
room=csr.office.office_name)
socketio.emit('citizen_invited', {},
room='sb-%s' % csr.office.office_number)
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen',
result,
room=csr.office.office_name)
return {
'citizen': result,
'errors': self.citizen_schema.validate(citizen)
}, 200
def email_exam_invigilator(self, exam, invigilator_name, invigilator_email,
invigilator_phone):
url = "%s/auth=%s;%s/JSON/create:BCMD-EXAM-API-ACTION" % (
self.base_url, self.bcmp_user, self.auth_token)
my_print(" ==> email_exam_invigilator url: %s" % url)
json_data = {
"action": {
"jobId": exam.bcmp_job_id,
"actionName": "SEND_TO_INVIGILATOR",
"invigilatorName": invigilator_name,
"invigilatorEmailAddress": invigilator_email,
"invigilatorPhoneNumber": invigilator_phone
}
}
response = self.send_request(url, "POST", json_data)
return response
def which_non_exam_key(booking, row, key):
if key == 'exam_name':
write_non_exam_name(booking, row)
elif key == 'notes':
write_contact_info(booking, row)
elif key == 'start_time':
value = getattr(booking.start_time, key)
my_print("==> which_non_exam_key of '" + key + "', type is: " +
str(type(value)))
row.append(getattr(booking.start_time, key))
elif key == 'end_time':
row.append(getattr(booking.end_time, key))
elif key == 'fees':
if booking.fees == 'false':
row.append("N")
elif booking.fees == 'true':
row.append("Y")
elif booking.fees == 'HQFin':
row.append("Finance to Invoice")
def get(self, id):
try:
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
citizen = Citizen.query.filter_by(citizen_id=id,
office_id=csr.office_id).first()
my_print("==> GET /citizens/" + str(citizen.citizen_id) +
'/service_requests/, Ticket: ' + citizen.ticket_number)
result = self.service_requests_schema.dump(citizen.service_reqs)
return {
'service_requests':
result,
'errors':
self.service_requests_schema.validate(citizen.service_reqs)
}
except exc.SQLAlchemyError as e:
print(e)
return {'message': 'API is down'}, 500
def post(self, id):
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
citizen = Citizen.query.filter_by(citizen_id=id).first()
active_service_request = citizen.get_active_service_request()
my_print("==> POST /citizens/" + str(citizen.citizen_id) +
'/add_to_queue, Ticket: ' + citizen.ticket_number)
if active_service_request is None:
return {"message": "Citizen has no active service requests"}
# Figure out what Snowplow call to make. Default is addtoqueue
snowplow_call = "addtoqueue"
if len(citizen.service_reqs) != 1 or len(
active_service_request.periods) != 1:
active_period = active_service_request.get_active_period()
if active_period.ps.ps_name == "Invited":
snowplow_call = "queuefromprep"
elif active_period.ps.ps_name == "Being Served":
snowplow_call = "returntoqueue"
else:
# TODO: Put in a Feedback Slack/Service now call here.
return {"message": "Invalid citizen/period state. "}
active_service_request.add_to_queue(csr, snowplow_call)
pending_service_state = SRState.get_state_by_name("Pending")
active_service_request.sr_state_id = pending_service_state.sr_state_id
db.session.add(citizen)
db.session.commit()
socketio.emit('update_customer_list', {}, room=csr.office_id)
socketio.emit('citizen_invited', {},
room='sb-%s' % csr.office.office_number)
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen', result, room=csr.office_id)
return {
'citizen': result,
'errors': self.citizen_schema.validate(citizen)
}, 200
def post(self, id):
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
citizen = Citizen.query.filter_by(citizen_id=id).first()
active_service_request = citizen.get_active_service_request()
my_print("==> POST /citizens/" + str(citizen.citizen_id) +
'/remove_from_queue, Ticket: ' + citizen.ticket_number)
if active_service_request is None:
return {"message": "Citizen has no active service requests"}
appointment = Appointment.query.filter_by(citizen_id=id) \
.filter_by(office_id=csr.office_id) \
.filter(Appointment.checked_in_time.isnot(None)) \
.first_or_404()
# This "un-check-in"s the appointment, returning it to calendar and removing from the queue.
appointment.checked_in_time = None
# Delete all "periods", FKs on service req
active_service_request.remove_from_queue()
# Delete the service req.
db.session.delete(active_service_request)
db.session.commit()
# appointment, warning = self.appointment_schema.load(json_data, instance=appointment, partial=True)
# if warning:
# logging.warning("WARNING: %s", warning)
# return {"message": warning}, 422
socketio.emit('update_customer_list', {}, room=csr.office_id)
socketio.emit('citizen_invited', {},
room='sb-%s' % csr.office.office_number)
result = self.appointment_schema.dump(appointment)
if not application.config['DISABLE_AUTO_REFRESH']:
socketio.emit('appointment_create', result)
return {
"appointment": result,
"errors": self.appointment_schema.validate(appointment)
}, 200
def create_individual_exam(self, exam, exam_fees, invigilator,
pesticide_office, oidc_token_info):
my_print(" ==> create_individual_exam self base_url: %s" %
self.base_url)
my_print(" ==> create_individual_exam self bcmp_user: %s" %
self.bcmp_user)
my_print(" ==> create_individual_exam self auth_token: %s" %
self.auth_token)
url = "%s/auth=%s;%s/JSON/create:BCMD-EXAM" % (
self.base_url, self.bcmp_user, self.auth_token)
my_print(" ==> create_individual_exam url: %s" % url)
office_name = None
if pesticide_office:
office_name = pesticide_office.office_name
receipt_number = "%s fees" % exam_fees
if exam.receipt:
receipt_number = exam.receipt
exam_type_name = None
if exam.exam_type:
exam_type_name = exam.exam_type.exam_type_name
invigilator_name = None
if invigilator:
invigilator_name = invigilator.invigilator_name
bcmp_exam = {
"EXAM_SESSION_LOCATION":
office_name,
"REGISTRAR_name":
oidc_token_info['preferred_username'],
"RECIPIENT_EMAIL_ADDRESS":
oidc_token_info['email'],
"REGISTRAR_phoneNumber":
"",
"students": [{
"REGISTRAR_name": invigilator_name,
"EXAM_CATEGORY": exam_type_name,
"STUDENT_LEGAL_NAME_first": exam.examinee_name,
"STUDENT_LEGAL_NAME_last": exam.examinee_name,
"STUDENT_emailAddress": exam.examinee_email,
"STUDENT_phoneNumber": exam.examinee_phone,
"REGISTRATION_NOTES": exam.notes,
"RECEIPT_RMS_NUMBER": receipt_number
}]
}
response = self.send_request(url, 'POST', bcmp_exam)
return response
def on_join(message):
claims = g.jwt_oidc_token_info
if claims["preferred_username"]:
my_print(
"==> In Python, @socketio.on('joinRoom'): claims['preferred_username'] is: "
+ str(claims["preferred_username"]))
csr = CSR.find_by_username(claims["preferred_username"])
if csr:
join_room(csr.office.office_name)
print("==> In websocket.py, CSR joinroom, CSR: " + csr.username +
"; request sid: " + str(request.sid))
emit('joinRoomSuccess', {"sucess": True})
emit('get_Csr_State_IDs', {"success": True})
emit('update_customer_list', {"success": True})
else:
print("Fail")
emit('joinRoomFail', {"success": False})
else:
print("No preferred_username on request")
emit('joinRoomFail', {"success": False})
def post(self):
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
try:
exams = Exam.query.filter_by(upload_received_ind=0).filter(
Exam.bcmp_job_id.isnot(None))
bcmp_response = self.bcmp_service.bulk_check_exam_status(exams)
job_ids = []
for job in bcmp_response["jobs"]:
if job["jobStatus"] == "RESPONSE_UPLOADED":
job_ids.append(job["jobId"])
my_print("job_ids to update: ")
my_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 = 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)
return {'message': 'API is down'}, 500
def post(self):
is_bcmp_req = True if request.args.get('bcmp_pesticide') else False
my_print("is_bcmp_req: ")
my_print(is_bcmp_req)
csr = CSR.find_by_username(g.jwt_oidc_token_info['username'])
json_data = request.get_json()
exam = self.exam_schema.load(json_data)
warning = self.exam_schema.validate(json_data)
my_print("json_data: ")
my_print(json_data)
if warning:
logging.warning("WARNING: %s", warning)
return {"message": warning}, 422
if not (exam.office_id == csr.office_id or csr.ita2_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)
my_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()
result = self.exam_schema.dump(exam)
return {"exam": result,
"errors": self.exam_schema.validate(exam)}, 201
def post(self, id):
csr = CSR.find_by_username(g.oidc_token_info['username'])
citizen = Citizen.query.filter_by(citizen_id=id,
office_id=csr.office_id).first()
my_print("==> POST /citizens/" + str(citizen.citizen_id) +
'/place_on_hold/, Ticket: ' + citizen.ticket_number)
active_service_request = citizen.get_active_service_request()
if active_service_request is None:
return {"message": "Citizen has no active service requests"}
active_service_request.place_on_hold(csr)
pending_service_state = SRState.get_state_by_name("Active")
active_service_request.sr_state_id = pending_service_state.sr_state_id
db.session.add(citizen)
db.session.commit()
socketio.emit('update_customer_list', {}, room=csr.office_id)
result = self.citizen_schema.dump(citizen)
socketio.emit('update_active_citizen', result.data, room=csr.office_id)
return {'citizen': result.data, 'errors': result.errors}, 200
