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
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
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
def put(requesttype, commentid):
if requesttype != "ministryrequest" and requesttype != "rawrequest":
return {
'status': False,
'message': EXCEPTION_MESSAGE_BAD_REQUEST
}, 400
try:
requestjson = request.get_json()
if requesttype == "ministryrequest":
commentschema = FOIMinistryRequestCommentSchema().load(
requestjson)
result = commentservice().updateministryrequestcomment(
commentid, commentschema, AuthHelper.getuserid())
else:
commentschema = EditFOIRawRequestCommentSchema().load(
requestjson)
result = commentservice().updaterawrequestcomment(
commentid, commentschema, 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
def get(queuetype="all"):
try:
DEFAULT_PAGE = 1
DEFAULT_SIZE = 10
DEFAULT_SORT_ITEMS = ['currentState']
DEFAULT_SORT_ORDERS = ['desc']
DEFAULT_FILTER_FIELDS = [
'idNumber', 'currentState', 'firstName', 'lastName',
'assignedToFirstName', 'assignedToLastName',
'assignedministrypersonFirstName',
'assignedministrypersonLastName', 'requestType'
]
DEFAULT_ADDITIONAL_FILTER = 'All'
_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[]')
_filterfields = flask.request.args.getlist('filters[]')
_additionalfilter = flask.request.args.get(
'additionalfilter', DEFAULT_ADDITIONAL_FILTER, type=str)
_userid = flask.request.args.get('userid', None, type=str)
if (len(_sortingitems) == 0):
_sortingitems = DEFAULT_SORT_ITEMS
if (len(_sortingorders) == 0):
_sortingorders = DEFAULT_SORT_ORDERS
if (len(_filterfields) == 0):
_filterfields = DEFAULT_FILTER_FIELDS
_keyword = flask.request.args.get('keyword', None, type=str)
groups = AuthHelper.getusergroups()
statuscode = 200
if (AuthHelper.getusertype() == "iao") and (queuetype is None
or queuetype == "all"):
requests = dashboardservice().getrequestqueuepagination(
groups, _page, _size, _sortingitems, _sortingorders,
_filterfields, _keyword, _additionalfilter, _userid)
elif queuetype is not None and queuetype == "ministry" and AuthHelper.getusertype(
) == "ministry":
requests = dashboardservice(
).getministryrequestqueuepagination(
AuthHelper.getministrygroups(), _page, _size,
_sortingitems, _sortingorders, _filterfields, _keyword,
_additionalfilter, _userid)
else:
statuscode = 401
return requests, statuscode
except BusinessException as exception:
return {
'status': exception.status_code,
'message': exception.message
}, 500
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
def post():
try:
requestjson = request.get_json()
rawrquestwatcherschema = FOIRawRequestWatcherSchema().load(
requestjson)
result = watcherservice().createrawrequestwatcher(
rawrquestwatcherschema, AuthHelper.getuserid(),
AuthHelper.getusergroups())
return {'status': result.success, 'message': result.message}, 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
def put(_requestid=None):
request_json = request.get_json()
try:
_wfinstanceid = request_json['wfinstanceid']
notes = request_json['notes'] if request_json.get(
'notes') is not None else 'Workflow Update'
requestid = int(_requestid)
result = rawrequestservice().updateworkflowinstancewithstatus(
_wfinstanceid, requestid, notes, AuthHelper.getuserid())
if result.identifier != -1:
return {
'status': result.success,
'message': result.message
}, 200
else:
return {
'status': result.success,
'message': result.message
}, 404
except KeyError:
return {
'status':
"Invalid PUT request",
'message':
"Key Error on JSON input, please confirm requestid and wfinstanceid"
}, 500
except ValueError as valuexception:
return {
'status': "BAD Request",
'message': str(valuexception)
}, 500
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
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
def __getauthenticateduserid(message):
if message.get("x-jwt-token") is not None:
try:
return AuthHelper.getwsuserid(message.get("x-jwt-token"))
except BusinessException as exception:
current_app.logger.error(
"%s,%s" % ('Unable to get user details', exception.message))
return None
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
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
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
def post(requestid, ministryrequestid, extensionid):
try:
if (AuthHelper.isministrymember() == False):
result = extensionservice().deleterequestextension(
requestid, ministryrequestid, extensionid,
AuthHelper.getuserid())
if result.success == True:
asyncio.create_task(eventservice().posteventforextension(
ministryrequestid, extensionid, AuthHelper.getuserid(),
AuthHelper.getusername(), "delete"))
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
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
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
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
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
def post(requestid=None):
try:
updaterequest = request.get_json()
if int(requestid) and str(requestid) != "-1":
status = rawrequestservice().getstatus(updaterequest)
rawrequest = rawrequestservice().getrawrequest(requestid)
requestdata = getparams(updaterequest)
assigneegroup = requestdata['assigneegroup']
assignee = requestdata['assignee']
assigneefirstname = requestdata['assigneefirstname']
assigneemiddlename = requestdata['assigneemiddlename']
assigneelastname = requestdata['assigneelastname']
result = rawrequestservice().saverawrequestversion(
updaterequest, requestid, assigneegroup, assignee, status,
AuthHelper.getuserid(), AuthHelper.getusername(),
AuthHelper.isministrymember(), assigneefirstname,
assigneemiddlename, assigneelastname)
if result.success == True:
asyncio.create_task(
rawrequestservice().posteventtoworkflow(
result.identifier, rawrequest['wfinstanceid'],
updaterequest, status))
return {
'status': result.success,
'message': result.message
}, 200
elif int(requestid) and str(requestid) == "-1":
result = rawrequestservice().saverawrequest(
updaterequest,
"intake",
AuthHelper.getuserid(),
notes="Request submitted from FOI Flow")
asyncio.create_task(eventservice().postevent(
result.identifier, "rawrequest", AuthHelper.getuserid(),
AuthHelper.getusername(), AuthHelper.isministrymember()))
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
def __getauditfromrawrequest(self, type, id, groups):
_rawdescriptions = []
if type == "ministryrequest":
requestrecord = FOIRequest().getrequest(id)
rawrequestid= requestrecord['foirawrequestid']
else:
rawrequestid= id
rawrecords = FOIRawRequest().getDescriptionSummaryById(rawrequestid)
for entry in rawrecords:
fromdate =dateutil.parser.parse(entry['fromdate']).strftime('%Y-%m-%d') if entry['fromdate'] is not None else None
todate = dateutil.parser.parse(entry['todate']).strftime('%Y-%m-%d') if entry['todate'] is not None else None
if AuthHelper.getusertype() == "iao":
_rawdescriptions.append({"description": entry['description'], "fromdate": fromdate, "todate": todate, "createdat": entry['createdat'] , "createdby": entry['createdby'], "status": entry['status']})
else:
if entry['ispiiredacted'] == True:
_rawdescriptions.append({"description": entry['description'], "fromdate": fromdate, "todate": todate, "createdat": entry['createdat'] , "createdby": entry['createdby'], "status": entry['status']})
return _rawdescriptions
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
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
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
def post(requestid, requesttype):
try:
if requesttype != "ministryrequest" and requesttype != "rawrequest":
return {'status': False, 'message':'Bad Request'}, 400
requestjson = request.get_json()
documentschema = CreateDocumentSchema().load(requestjson)
result = documentservice().createrequestdocument(requestid, documentschema, AuthHelper.getuserid(), requesttype)
return {'status': result.success, 'message':result.message} , 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
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