class CreateFOIRawRequestComment(Resource):
"""Creates comment for raw(unopened) request."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def post():
try:
requestjson = request.get_json()
rawrqcommentschema = FOIRawRequestCommentSchema().load(requestjson)
result = commentservice().createrawrequestcomment(
rawrqcommentschema, AuthHelper.getuserid())
if result.success == True:
asyncio.create_task(eventservice().postcommentevent(
result.identifier, "rawrequest", AuthHelper.getuserid()))
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 200
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIRequests(Resource):
"""Creates foi request"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def post():
""" POST Method for capturing FOI requests before processing"""
try:
request_json = request.get_json()
foirequestschema = FOIRequestWrapperSchema().load(request_json)
assignedgroup = request_json[
'assignedGroup'] if 'assignedGroup' in foirequestschema else None
assignedto = request_json[
'assignedTo'] if 'assignedTo' in foirequestschema else None
assignedtofirstname = request_json[
"assignedToFirstName"] if request_json.get(
"assignedToFirstName") != None else None
assignedtomiddlename = request_json[
"assignedToMiddleName"] if request_json.get(
"assignedToMiddleName") != None else None
assignedtolastname = request_json[
"assignedToLastName"] if request_json.get(
"assignedToLastName") != None else None
rawresult = rawrequestservice().saverawrequestversion(
request_json, request_json['id'], assignedgroup, assignedto,
"Archived", AuthHelper.getuserid(), AuthHelper.getusername(),
AuthHelper.isministrymember(), assignedtofirstname,
assignedtomiddlename, assignedtolastname)
if rawresult.success == True:
result = requestservice().saverequest(foirequestschema,
AuthHelper.getuserid())
if result.success == True:
requestservice().copywatchers(request_json['id'],
result.args[0],
AuthHelper.getuserid())
requestservice().copycomments(request_json['id'],
result.args[0],
AuthHelper.getuserid())
requestservice().copydocuments(request_json['id'],
result.args[0],
AuthHelper.getuserid())
requestservice().postopeneventtoworkflow(
result.identifier, rawresult.args[0], request_json,
result.args[0])
return {
'status': result.success,
'message': result.message,
'id': result.identifier,
'ministryRequests': result.args[0]
}, 200
except ValidationError as err:
return {'status': False, 'message': err.messages}, 400
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class DashboardPagination(Resource):
""" Retrives the foi request based on the queue type.
"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
@cors_preflight('GET,POST,OPTIONS')
@auth.ismemberofgroups(getrequiredmemberships())
def get():
try:
DEFAULT_PAGE = 1
DEFAULT_SIZE = 10
DEFAULT_SORT_ITEMS = ['currentState']
DEFAULT_SORT_ORDERS = ['desc']
params = {
'groups': AuthHelper.getusergroups(),
'page': flask.request.args.get('page', DEFAULT_PAGE, type=int),
'size': flask.request.args.get('size', DEFAULT_SIZE, type=int),
'sortingitems': flask.request.args.getlist('sortingitems[]'),
'sortingorders': flask.request.args.getlist('sortingorders[]'),
'requeststate': flask.request.args.getlist('requestState[]'),
'requeststatus': flask.request.args.getlist('requestStatus[]'),
'requesttype': flask.request.args.getlist('requestType[]'),
'publicbody': flask.request.args.getlist('publicBodies[]'),
'fromdate': flask.request.args.get('fromDate', None, type=str),
'todate': flask.request.args.get('toDate', None, type=str),
'search': flask.request.args.get('search', None, type=str),
'keywords': flask.request.args.getlist('keywords[]'),
'userid': flask.request.args.get('userid', None, type=str)
}
if len(params['sortingitems']) == 0:
params['sortingitems'] = DEFAULT_SORT_ITEMS
if len(params['sortingorders']) == 0:
params['sortingorders'] = DEFAULT_SORT_ORDERS
if params['requeststate'] is None:
params['requeststate'] = []
if params['requeststatus'] is None:
params['requeststatus'] = []
if params['requesttype'] is None:
params['requesttype'] = []
if params['publicbody'] is None:
params['publicbody'] = []
if params['keywords'] is None:
params['keywords'] = []
statuscode = 200
if (AuthHelper.getusertype() == "iao"):
requests = dashboardservice().advancedsearch(params)
else:
statuscode = 401
return requests, statuscode
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIComment(Resource):
"""Retrieves comment based on type: ministry(opened) and raw(unopened)."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get(requesttype, requestid):
if requesttype != "ministryrequest" and requesttype != "rawrequest":
return {
'status': False,
'message': EXCEPTION_MESSAGE_BAD_REQUEST
}, 400
try:
if requesttype == "ministryrequest":
result = commentservice().getministryrequestcomments(requestid)
else:
result = commentservice().getrawrequestcomments(requestid)
return json.dumps(result), 200
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIDisableComment(Resource):
"""Disable comment based on type: ministry(opened) and raw(unopened)."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def put(requesttype, commentid):
if requesttype != "ministryrequest" and requesttype != "rawrequest":
return {
'status': False,
'message': EXCEPTION_MESSAGE_BAD_REQUEST
}, 400
try:
if requesttype == "ministryrequest":
result = commentservice().disableministryrequestcomment(
commentid, AuthHelper.getuserid())
else:
result = commentservice().disablerawrequestcomment(
commentid, AuthHelper.getuserid())
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 200
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIRawRequestLoadTest(Resource):
"""Consolidates create and retrival of raw request"""
@staticmethod
#@Tracer.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def post(requestid=None):
try:
updaterequest = request.get_json()
userid = updaterequest['assignedTo']
username = '******'
if int(requestid) and str(requestid) == "-1":
result = rawrequestservice().saverawrequest(
updaterequest,
"intake",
userid,
notes="Request submitted from FOI Flow")
asyncio.create_task(eventservice().postevent(
result.identifier, "rawrequest", userid, username, False))
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 200
except ValueError:
return {'status': 500, 'message': INVALID_REQUEST_ID}, 500
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class CreateFOIRequestExtension(Resource):
"""Creates extension for ministry(opened) request."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def post(requestid, ministryrequestid):
try:
requestjson = request.get_json()
rquesextensionschema = FOIRequestExtensionSchema().load(
requestjson)
if (AuthHelper.isministrymember() == False):
result = extensionservice().createrequestextension(
requestid, ministryrequestid, rquesextensionschema,
AuthHelper.getuserid())
if result.success == True:
asyncio.create_task(eventservice().posteventforextension(
ministryrequestid, result.identifier,
AuthHelper.getuserid(), AuthHelper.getusername(),
"add"))
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 200
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class EditFOIRequestExtension(Resource):
"""Edits extension for ministry(opened) request."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def post(requestid, ministryrequestid, extensionid):
try:
requestjson = request.get_json()
rquesextensionschema = FOIRequestExtensionSchema().load(
requestjson)
if (AuthHelper.isministrymember() == False):
result = extensionservice().createrequestextensionversion(
requestid, ministryrequestid, extensionid,
rquesextensionschema, AuthHelper.getuserid(),
AuthHelper.getusername())
if result.success == True:
# posteventforextension moved to createrequestextensionversion to generate the comments before updating the ministry table with new due date
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 200
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIRequestUpdateById(Resource):
"""Updates an foi request"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def put(foirequestid):
""" PUT Method for capturing FOI requests before processing"""
try:
request_json = request.get_json()
foirequestschema = EditableFOIRequestWrapperSchema().load(
request_json)
result = requestservice().updaterequest(foirequestschema,
foirequestid,
AuthHelper.getuserid())
if result != {}:
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 200
else:
return {
'status': False,
'message': EXCEPTION_MESSAGE_NOTFOUND_REQUEST,
'id': foirequestid
}, 404
except ValidationError as err:
return {'status': False, 'message': err.messages}, 40
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIRequest(Resource):
"""Retrieve foi request for opened request"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
@auth.ismemberofgroups(getrequiredmemberships())
def get(foirequestid, foiministryrequestid, usertype=None):
try:
jsondata = {}
statuscode = 200
if (AuthHelper.getusertype() == "iao") and (usertype is None or
(usertype == "iao")):
jsondata = requestservice().getrequest(foirequestid,
foiministryrequestid)
elif usertype is not None and usertype == "ministry" and AuthHelper.getusertype(
) == "ministry":
jsondata = requestservice().getrequestdetailsforministry(
foirequestid, foiministryrequestid,
AuthHelper.getministrygroups())
else:
statuscode = 401
return jsondata, statuscode
except ValueError:
return {'status': 500, 'message': "Invalid Request Id"}, 500
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIDismissNotification(Resource):
"""Resource for managing FOI requests."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def delete(type=None, idnumber=None, notficationid=None):
try:
result = notificationservice().dismissnotification(
AuthHelper.getuserid(), type, idnumber, notficationid)
if result.success == True:
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 200
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 500
except ValueError:
return {'status': 500, 'message': "Invalid Request Id"}, 500
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIAuditByField(Resource):
"""Resource for managing audit of FOI data."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get(type, id, field):
""" GET Method for auditing of FOI request field"""
if (type is None or id is None or field is None) or (
(type is not None and type != "rawrequest"
and type != "ministryrequest") or
(field is not None and field != "description")):
return {'status': False, 'message': 'Bad Request'}, 400
try:
isall = False if request.url.endswith('summary') else True
result = auditservice().getauditforfield(
type, id, field, AuthHelper.getusergroups(), isall)
if result is not None:
return {"audit": result}, 200
else:
return {'status': False, 'message': 'Not Found'}, 404
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class Fee(Resource):
@staticmethod
@cross_origin(origins=allowedorigins())
def get(code):
try:
date = request.args.get('date', datetime.today().strftime('%Y-%m-%d'))
quantity = int(request.args.get('quantity', 1))
return FeeService.get_fee(code=code, quantity=quantity, valid_date=date), 200
except BusinessException as e:
return {'status': e.code, 'message': e.message}, e.status_code
class Payment(Resource):
@staticmethod
@cross_origin(origins=allowedorigins())
def put(request_id: int, payment_id: int):
try:
request_json = request.get_json()
fee_service: FeeService = FeeService(request_id=request_id, payment_id=payment_id)
pay_response = fee_service.complete_payment(request_json)
return pay_response, 201
except BusinessException as e:
return {'status': e.code, 'message': e.message}, e.status_code
class FOIFlowDivisions(Resource):
"""Retrieves all active divisions for the passed in gov code .
"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get(bcgovcode):
try:
data = divisionstageservice().getdivisionandstages(bcgovcode)
jsondata = json.dumps(data)
return jsondata, 200
except BusinessException:
return "Error happened while accessing divisions", 500
class FOIRequestsByIdAndType(Resource):
"""Creates a new version of foi request for ministry updates"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def post(foirequestid, foiministryrequestid, usertype):
""" POST Method for capturing FOI requests before processing"""
try:
if usertype != "ministry":
return {'status': False, 'message': 'Bad Request'}, 400
request_json = request.get_json()
ministryrequestschema = FOIRequestMinistrySchema().load(
request_json)
result = requestservice().saveministryrequestversion(
ministryrequestschema, foirequestid, foiministryrequestid,
AuthHelper.getuserid())
if result.success == True:
metadata = json.dumps({
"id": result.identifier,
"ministries": result.args[0]
})
asyncio.create_task(requestservice().posteventtoworkflow(
foiministryrequestid, result.args[1],
ministryrequestschema, json.loads(metadata), "ministry"))
asyncio.create_task(eventservice().postevent(
foiministryrequestid, "ministryrequest",
AuthHelper.getuserid(), AuthHelper.getusername(),
AuthHelper.isministrymember()))
return {
'status': result.success,
'message': result.message,
'id': result.identifier,
'ministryRequests': result.args[0]
}, 200
else:
return {
'status': False,
'message': EXCEPTION_MESSAGE_NOTFOUND_REQUEST,
'id': foirequestid
}, 404
except ValidationError as err:
return {'status': False, 'message': err.messages}, 400
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIFlowProgramAreas(Resource):
"""Retrieves all active program areas.
"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
#@request_api.cache.cached(key_prefix="programareas")
def get():
try:
data = programareaservice().getprogramareas()
jsondata = json.dumps(data)
return jsondata, 200
except BusinessException:
return "Error happened while accessing applicant categories", 500
class FOIFlowDeliveryModes(Resource):
"""Retrieves all active delivery modes.
"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
#@request_api.cache.cached(key_prefix="deliverymodes")
def get():
try:
data = deliverymodeservice().getdeliverymodes()
jsondata = json.dumps(data)
return jsondata, 200
except BusinessException:
return "Error happened while accessing delivery modes", 500
class DeleteFOIDocument(Resource):
"""Resource for managing FOI requests."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def post(requestid, documentid, requesttype):
try:
result = documentservice().deleterequestdocument(requestid, documentid, AuthHelper.getuserid(), requesttype)
return {'status': result.success, 'message':result.message,'id':result.identifier} , 200
except KeyError as err:
return {'status': False, 'message':err.messages}, 400
except BusinessException as exception:
return {'status': exception.status_code, 'message':exception.message}, 500
class FOIAssigneesByTypeAndStatus(Resource):
"""esource for retriving FOI assignees based on group."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get(groupname):
""" POST Method for capturing FOI requests before processing"""
try:
result = assigneeservice().getmembersbygroupname(groupname)
if result is not None:
return json.dumps(result), 200
else:
return {'status': False, 'message':EXCEPTION_MESSAGE_NOT_FOUND}, 404
except BusinessException as exception:
return {'status': exception.status_code, 'message':exception.message}, 500
class GetFOIDocument(Resource):
"""Resource for managing FOI requests."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get(requestid, requesttype):
if requesttype != "ministryrequest" and requesttype != "rawrequest":
return {'status': False, 'message':'Bad Request'}, 400
try:
result = documentservice().getrequestdocumentsbyrole(requestid, requesttype, AuthHelper.isministrymember())
return json.dumps(result), 200
except KeyError as err:
return {'status': False, 'message':err.messages}, 400
except BusinessException as exception:
return {'status': exception.status_code, 'message':exception.message}, 500
class GetFOIExtension(Resource):
"""Resource for managing Extension."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get(extensionid):
try:
extensionrecord = extensionservice().getrequestextension(
extensionid)
return json.dumps(extensionrecord), 200
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIFlowExtensionReasons(Resource):
"""Retrieves all active extension reasons.
"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
#@request_api.cache.cached(key_prefix="extensionreasons")
def get():
try:
data = extensionreasonservice().getextensionreasons()
jsondata = json.dumps(data)
return jsondata, 200
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIAssigneesByTypeAndStatus(Resource):
"""Resource for retriving FOI assignees based on status."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get(requestype=None, status=None, bcgovcode=None):
if requestype is not None and (requestype != "personal" and requestype != "general"):
return {'status': False, 'message':EXCEPTION_MESSAGE_BAD_REQUEST}, 400
try:
result = assigneeservice().getgroupsandmembersbytypeandstatus(requestype, status, bcgovcode)
if result is not None:
return json.dumps(result), 200
else:
return {'status': False, 'message':EXCEPTION_MESSAGE_NOT_FOUND}, 404
except BusinessException as exception:
return {'status': exception.status_code, 'message':exception.message}, 500
class FOIRequestWatcher(Resource):
"""Retrieve watchers for opened request"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get(ministryrequestid):
try:
result = watcherservice().getministryrequestwatchers(
ministryrequestid, AuthHelper.isministrymember())
return json.dumps(result), 200
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class RenameFOIDocument(Resource):
"""Resource for managing FOI requests."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def post(requestid, documentid, requesttype):
try:
requestjson = request.get_json()
documentschema = RenameDocumentSchema().load(requestjson)
result = documentservice().createrequestdocumentversion(requestid, documentid, documentschema, AuthHelper.getuserid(), requesttype)
return {'status': result.success, 'message':result.message,'id':result.identifier} , 200
except ValidationError as err:
return {'status': False, 'message':err.messages}, 400
except KeyError as err:
return {'status': False, 'message':err.messages}, 400
except BusinessException as exception:
return {'status': exception.status_code, 'message':exception.message}, 500
class FOIRawRequestFields(Resource):
"""Consolidates create and retrival of raw request"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get(requestid):
try:
# here we want to get the value of names (i.e. ?names=ministries)
if request.args['names'] == "ministries":
baserequestinfo = rawrequestservice().getrawrequestfields(
requestid, ["ministries"])
return json.dumps(baserequestinfo), 200
except ValueError:
return {'status': 500, 'message': "Invalid Request"}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOINotification(Resource):
"""Resource for managing FOI requests."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def get():
try:
result = notificationservice().getnotifications(
AuthHelper.getuserid())
return json.dumps(result), 200
except ValueError:
return {'status': 500, 'message': "Invalid Request Id"}, 500
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class FOIRawRequests(Resource):
"""Resource for retriving all raw requests."""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@expects_json(schema)
def post():
""" POST Method for capturing RAW FOI requests before processing"""
try:
request_json = request.get_json()
requestdatajson = request_json['requestData']
#get attachments
attachments = requestdatajson[
'Attachments'] if 'Attachments' in requestdatajson else None
notes = 'Request submission from FOI WebForm'
#save request
if attachments is not None:
requestdatajson.pop('Attachments')
result = rawrequestservice().saverawrequest(
requestdatajson=requestdatajson,
sourceofsubmission="onlineform",
userid=None,
notes=notes)
if result.success:
documentservice().uploadpersonaldocuments(
result.identifier, attachments)
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 200
except TypeError:
return {
'status': "TypeError",
'message': "Error while parsing JSON in request"
}, 500
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
class DisableFOIRawRequestWatcher(Resource):
"""Disable watcher for unopened request"""
@staticmethod
@TRACER.trace()
@cross_origin(origins=allowedorigins())
@auth.require
def put(requestid):
try:
result = watcherservice().disablerawrequestwatchers(
requestid, AuthHelper.getuserid())
return {
'status': result.success,
'message': result.message,
'id': result.identifier
}, 200
except KeyError as err:
return {'status': False, 'message': err.messages}, 400
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
