def post(self, mine_guid):
data = self.parser.parse_args()
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound(
'There was no mine found with the provided mine_guid.')
party = Party.find_by_party_guid(data.get('permittee_party_guid'))
if not party:
raise NotFound('Party not found')
permit = Permit.find_by_permit_no(data.get('permit_no'))
if permit:
raise BadRequest("That permit number is already in use.")
uploadedFiles = data.get('uploadedFiles', [])
permit = Permit.create(mine.mine_guid, data.get('permit_no'),
data.get('permit_status_code'))
amendment = PermitAmendment.create(
permit,
data.get('received_date'),
data.get('issue_date'),
data.get('authorization_end_date'),
'OGP',
description='Initial permit issued.')
db.session.add(permit)
db.session.add(amendment)
for newFile in uploadedFiles:
new_pa_doc = PermitAmendmentDocument(
document_name=newFile['fileName'],
document_manager_guid=newFile['document_manager_guid'],
mine_guid=permit.mine_guid,
)
amendment.related_documents.append(new_pa_doc)
db.session.commit()
permittee_start_date = data.get('issue_date'),
permittee = MinePartyAppointment.create(
mine.mine_guid,
data.get('permittee_party_guid'),
'PMT',
start_date=permittee_start_date,
processed_by=self.get_user_info(),
permit_guid=permit.permit_guid)
db.session.add(permittee)
db.session.commit()
return permit
def get(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound('Mine not found')
current_app.logger.info(f'Retrieving comments for {mine}')
comments = [comment.__dict__ for comment in mine.comments]
return comments, 200
def get(self, mine_guid):
variances = Variance.find_by_mine_guid(mine_guid)
if variances is None:
raise BadRequest(
'Unable to fetch variances. Confirm you\'ve provided a valid mine_guid')
if len(variances) == 0:
mine = Mine.find_by_mine_guid(mine_guid)
if mine is None:
raise NotFound('Mine')
return variances
def test_delete_mine_comment(test_client, db_session, auth_headers):
mine = MineFactory()
num_comments = len(mine.comments)
comment_to_delete = mine.comments[0]
del_resp = test_client.delete(
f'/mines/{mine.mine_guid}/comments/{comment_to_delete.mine_comment_guid}',
headers=auth_headers['full_auth_header'])
updated_mine = Mine.find_by_mine_guid(str(mine.mine_guid))
assert del_resp.status_code == 204
assert len(updated_mine.comments) == num_comments - 1
def get(self):
result = ""
now_info = ""
response_message = ""
try:
permit_no = request.args.get('a_PermitNumber')
permit_prefix = permit_no.split("-")[0]
permits = Permit.find_by_permit_no_all(permit_no)
for permit in permits:
mine = Mine.find_by_mine_guid(str(permit.mine_guid))
# Mine must be operating.
if not mine.mine_status or mine.mine_status[
0].mine_status_xref.mine_operation_status_code != "OP":
break
if permit_prefix not in ["CX", "MX"]:
break
for permit_amendment in permit.permit_amendments:
if (permit_amendment.authorization_end_date -
datetime.utcnow().date()).days > 30:
#only want permits that expire 30 days or further in the future
now_info = now_info + str(
permit_amendment.now_identity.now_submission.
trackingnumber) + " - " + str(
permit_amendment.authorization_end_date
) + '\r\c'
if now_info != "":
result = "Success"
else:
result = "Failure"
response_message = "NoValidNowsForPermit"
except Exception as e:
current_app.logger.error(str(e))
result = "Failure"
now_info = ""
response_message = "Unhandled Exception"
return {
"a_Result": result,
"a_NoWInfo": now_info,
"a_ResponseMessage": response_message,
"a_Timestamp": datetime.utcnow()
}
def get(self):
result = ""
mine_info = ""
response_message = ""
try:
permit_no = request.args.get('a_PermitNumber')
permit_prefix = permit_no.split("-")[0]
type_of_deemed_auth = request.args.get('a_TypeofDeemedAuth')
permits = Permit.find_by_permit_no_all(permit_no)
for permit in permits:
mine = Mine.find_by_mine_guid(str(permit.mine_guid))
# Mine must be operating.
if not mine.mine_status or mine.mine_status[
0].mine_status_xref.mine_operation_status_code != "OP":
break
# IP SURVEYS (Induced): Valid MMS mine types: 'CX','ES','EU'
# There may be need of a check against mine_tenure_type_code IN ["MIN", "COL"] and mine_disturbance_code IN ["SUR", "UND"]
# but this data is inconsistant for now.
if type_of_deemed_auth == "INDUCED" and permit_prefix not in ["CX", "MX"]:
break
# DRILL PROGRAM (Drill): Valid MMS mine types: 'CS','CU','MS','MU','IS','IU'
if type_of_deemed_auth != "INDUCED" and permit_prefix not in ["C", "M"]:
break
mine_info = mine_info + mine.mine_no + ' - ' + mine.mine_name + '\r'
if mine_info != "":
result = "Success"
else:
result = "Failure"
response_message = "NoValidMinesForPermit"
except Exception as e:
current_app.logger.error(str(e))
result = "Failure"
mine_info = ""
response_message = "Unhandled Exception"
return {
"a_Result": result,
"a_MineInfo": mine_info,
"a_ResponseMessage": response_message,
"a_Timestamp": datetime.utcnow()
}
def test_post_mine_report_comment(test_client, db_session, auth_headers):
mine = MineFactory()
num_comments = len(mine.comments)
data = {'mine_comment': 'Test comment'}
post_resp = test_client.post(f'/mines/{mine.mine_guid}/comments',
headers=auth_headers['full_auth_header'],
json=data)
updated_mine = Mine.find_by_mine_guid(str(mine.mine_guid))
comments = updated_mine.comments
assert post_resp.status_code == 201
assert len(comments) == num_comments + 1
assert comments[-1].mine_comment == 'Test comment'
def post(self, application_guid):
data = self.parser.parse_args()
mine_guid = data.get('mine_guid')
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound('Mine not found')
now_application_identity = NOWApplicationIdentity.query.filter_by(
now_application_guid=application_guid).first()
if not now_application_identity:
raise NotFound('No identity record for this application guid.')
application = transmogrify_now(now_application_identity)
application.mine_guid = mine_guid
application.now_application_guid = application_guid
application.save()
return {'now_application_guid': str(application.now_application_guid)}
def get(self):
mine_guid = request.args.get('mine_guid', None)
if mine_guid is None:
raise BadRequest('Please provide a mine_guid.')
mine = Mine.find_by_mine_guid(mine_guid)
if mine is None:
return []
permits = Permit.find_by_mine_guid(mine.mine_guid)
if not permits:
return []
bonds = [bond for permit in permits for bond in permit.bonds]
return bonds
def put(self, mine_guid, mine_incident_guid, mine_document_guid):
parser = CustomReqparser()
parser.add_argument('filename', type=str, required=True)
parser.add_argument('document_manager_guid', type=str, required=True)
parser.add_argument('mine_incident_document_type',
type=str,
required=True)
mine_incident = MineIncident.find_by_mine_incident_guid(
mine_incident_guid)
mine = Mine.find_by_mine_guid(mine_guid)
if not mine_incident:
raise NotFound('Mine incident not found')
if not mine:
raise NotFound('Mine not found.')
data = parser.parse_args()
document_manager_guid = data.get('document_manager_guid')
file_name = data.get('filename')
mine_incident_document_type = data.get('mine_incident_document_type')
mine_doc = MineDocument(mine_guid=mine.mine_guid,
document_name=file_name,
document_manager_guid=document_manager_guid)
if not mine_doc:
raise BadRequest('Unable to register uploaded file as document')
mine_doc.save()
mine_incident_doc = MineIncidentDocumentXref(
mine_document_guid=mine_doc.mine_document_guid,
mine_incident_id=mine_incident.mine_incident_id,
mine_incident_document_type_code=mine_incident_document_type
if mine_incident_document_type else 'INI')
mine_incident.documents.append(mine_incident_doc)
mine_incident.save()
return mine_incident
def post(self, mine_guid):
data = self.parser.parse_args()
compliance_article_id = data['compliance_article_id']
received_date = data['received_date']
inspector_party_guid = data.get('inspector_party_guid')
mine = Mine.find_by_mine_guid(mine_guid)
if mine is None:
raise NotFound('Mine')
# A manual check to prevent a stack trace dump on a foreign key /
# constraint error because global error handling doesn't currently work
# with these errors
variance_application_status_code = data.get('variance_application_status_code') or 'REV'
issue_date = data.get('issue_date')
expiry_date = data.get('expiry_date')
Variance.validate_status_with_other_values(status=variance_application_status_code,
issue=issue_date,
expiry=expiry_date,
inspector=inspector_party_guid)
variance = Variance.create(
compliance_article_id=compliance_article_id,
mine_guid=mine_guid,
received_date=received_date,
# Optional fields
variance_application_status_code=variance_application_status_code,
applicant_guid=data.get('applicant_guid'),
inspector_party_guid=inspector_party_guid,
note=data.get('note'),
parties_notified_ind=data.get('parties_notified_ind'),
issue_date=issue_date,
expiry_date=expiry_date)
if not variance:
raise BadRequest('Error: Failed to create variance')
variance.save()
return variance
def get(self):
mine_guid = request.args.get('mine_guid', None)
if mine_guid is None:
raise BadRequest('Please provide a mine_guid.')
mine = Mine.find_by_mine_guid(mine_guid)
if mine is None:
return []
permits = Permit.find_by_mine_guid(mine.mine_guid)
if not permits:
return []
reclamation_invoices = [
reclamation_invoice for permit in permits
for reclamation_invoice in permit.reclamation_invoices
]
return reclamation_invoices
def post(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound('Mine not found')
data = self.parser.parse_args()
if not data['mine_comment']:
raise BadRequest('Empty comment')
mine_comment = MineComment.create(
mine=mine,
mine_comment=data['mine_comment'],
)
current_app.logger.info(f'Creating comment {mine_comment}')
mine_comment.save()
return mine_comment, 201
def post(self):
data = self.parser.parse_args()
mine = Mine.find_by_mine_guid(data['mine_guid'])
permit = Permit.find_by_permit_guid(data['permit_guid'])
err_str = ''
if not mine:
err_str += 'Mine not Found. '
if not permit:
err_str += 'Permit not Found. '
if mine and not mine.major_mine_ind:
err_str += 'Permit Applications can only be created on mines where major_mine_ind=True'
if err_str:
raise BadRequest(err_str)
new_now = NOWApplicationIdentity(mine_guid=data['mine_guid'], permit=permit)
new_now.now_application = NOWApplication(
notice_of_work_type_code=data['notice_of_work_type_code'],
now_application_status_code='REC',
submitted_date=data['submitted_date'],
received_date=data['received_date'])
new_now.save()
return new_now, 201
def post(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound('Mine not found.')
data = self.parser.parse_args()
mine_tsf_list = mine.mine_tailings_storage_facilities
is_mine_first_tsf = len(mine_tsf_list) == 0
mine_tsf = MineTailingsStorageFacility.create(
mine,
mine_tailings_storage_facility_name=data[
'mine_tailings_storage_facility_name'])
mine.mine_tailings_storage_facilities.append(mine_tsf)
if is_mine_first_tsf:
try:
tsf_required_reports = MineReportDefinition.find_required_reports_by_category(
'TSF')
for tsf_req_doc in tsf_required_reports:
calculated_due_date = tsf_req_doc.default_due_date or datetime.utcnow(
)
MineReport.create(
mine_report_definition_id=tsf_req_doc.
mine_report_definition_id,
mine_guid=mine.mine_guid,
due_date=calculated_due_date,
received_date=None,
submission_year=calculated_due_date.year - 1,
permit_id=None)
except Exception as e:
db.session.rollback()
current_app.logger.error(str(e))
raise InternalServerError(str(e) + ", tsf not created")
mine.save()
return mine_tsf, 201
def put(self, application_guid):
now_application_identity = NOWApplicationIdentity.find_by_guid(
application_guid)
if not now_application_identity:
raise NotFound('No identity record for this application guid.')
if now_application_identity.now_application_id is None:
raise NotImplemented(
'This application has not been imported. Please import an application before making changes.'
)
data = request.json
lead_inspector_party_guid = data.get('lead_inspector_party_guid', None)
if lead_inspector_party_guid is not None:
now_application_identity.now_application.lead_inspector_party_guid = lead_inspector_party_guid
now_application_status_code = data.get('now_application_status_code',
None)
if now_application_status_code is not None and now_application_identity.now_application.now_application_status_code != now_application_status_code:
now_application_identity.now_application.status_updated_date = datetime.today(
)
if data.get('mine_guid', None):
mine = Mine.find_by_mine_guid(data['mine_guid'])
if not mine:
raise BadRequest('mine not found')
current_app.logger.info(
f'Assigning {now_application_identity} to {mine}')
now_application_identity.mine = mine
now_application_identity.save()
now_application_identity.now_application.deep_update_from_dict(data)
NROSNOWStatusService.nros_now_status_update(
now_application_identity.now_number,
now_application_identity.now_application.status.description,
now_application_identity.now_application.status_updated_date.
strftime("%Y-%m-%dT%H:%M:%S"))
return now_application_identity.now_application
def post(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound('Mine not found')
data = self.parser.parse_args()
do_sub_codes = []
if data['determination_type_code'] == 'DO':
do_sub_codes = data['dangerous_occurrence_subparagraph_ids']
if not do_sub_codes:
raise BadRequest(
'Dangerous occurrences require one or more cited sections of HSRC code 1.7.3')
incident = MineIncident.create(
mine,
data['incident_timestamp'],
data['incident_description'],
determination_type_code=data['determination_type_code'] or 'PEN',
followup_type_code=data['followup_type_code'] or 'UND',
followup_inspection_no=data['followup_inspection_no'],
reported_timestamp=data['reported_timestamp'],
reported_by=data['reported_by'],
reported_by_role=data['reported_by_role'],
)
for id in do_sub_codes:
sub = ComplianceArticle.find_by_compliance_article_id(id)
if not _compliance_article_is_do_subparagraph(sub):
raise BadRequest(
'One of the provided compliance articles is not a sub-paragraph of section 1.7.3 (dangerous occurrences)'
)
incident.dangerous_occurrence_subparagraphs.append(sub)
try:
incident.save()
except Exception as e:
raise InternalServerError(f'Error when saving: {e}')
return incident, 201
def get(self):
mine_guid = request.args.get('mine_guid', None)
if mine_guid is None:
raise BadRequest('Please provide a mine_guid.')
mine = Mine.find_by_mine_guid(mine_guid)
if mine is None:
return []
permits = Permit.find_by_mine_guid(mine.mine_guid)
if not permits:
return []
bonds = [bond for permit in permits for bond in permit.bonds]
if jwt.validate_roles([MINESPACE_PROPONENT]):
bonds = marshal(bonds, BOND_MINESPACE)
return bonds
def test_post_mine_report(test_client, db_session, auth_headers):
mine = MineFactory(mine_reports=ONE_REPORT)
mine_report = mine.mine_reports[0]
mine_report_definition = MineReportDefinition.active()
num_reports = len(mine.mine_reports)
new_report_definition = [
x for x in mine_report_definition if x.mine_report_definition_guid !=
mine_report.mine_report_definition_guid
][0]
data = {
'mine_report_definition_guid':
str(new_report_definition.mine_report_definition_guid),
'submission_year':
'2019',
'due_date':
'2019-07-05',
'permit_guid':
None,
'received_date':
None,
}
post_resp = test_client.post(f'/mines/{mine.mine_guid}/reports',
headers=auth_headers['full_auth_header'],
json=data)
post_data = json.loads(post_resp.data.decode())
updated_mine = Mine.find_by_mine_guid(str(mine.mine_guid))
reports = updated_mine.mine_reports
assert post_resp.status_code == 201
assert len(reports) == num_reports + 1
assert new_report_definition.mine_report_definition_id in [
x.mine_report_definition_id for x in reports
]
def get(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound('Mine not found.')
return mine.mine_documents
def get(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound('Mine not found.')
return mine.mine_tailings_storage_facilities
def post(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound('Mine not found.')
# see if this would be the first TSF
mine_tsf_list = mine.mine_tailings_storage_facilities
is_mine_first_tsf = len(mine_tsf_list) == 0
data = self.parser.parse_args()
mine_tsf = MineTailingsStorageFacility.create(
mine,
mine_tailings_storage_facility_name=data[
'mine_tailings_storage_facility_name'])
mine.mine_tailings_storage_facilities.append(mine_tsf)
if is_mine_first_tsf:
try:
req_documents_url = get_documents_svc_url(
'/required?category=TSF&sub_category=INI')
get_tsf_docs_resp = requests.get(
req_documents_url,
headers={
'Authorization': request.headers.get('Authorization')
})
if get_tsf_docs_resp.status_code != 200:
raise Exception(
f'get_tsf_req_docs returned >> {get_tsf_docs_resp.status_code}'
)
tsf_required_documents = get_tsf_docs_resp.json(
)['required_documents']
new_expected_documents = []
for tsf_req_doc in tsf_required_documents:
new_expected_documents.append({
'req_document_guid':
tsf_req_doc['req_document_guid'],
'document_name':
tsf_req_doc['req_document_name'],
'document_description':
tsf_req_doc['description'],
'document_due_date_type':
tsf_req_doc['req_document_due_date_type'],
'document_due_date_period_months':
tsf_req_doc['req_document_due_date_period_months'],
'hsrc_code':
tsf_req_doc['hsrc_code']
})
doc_assignment_response = requests.post(
get_documents_svc_url('/expected/mines/' + str(mine_guid)),
headers={
'Authorization': request.headers.get('Authorization')
},
json={'documents': new_expected_documents})
if doc_assignment_response.status_code != 200:
raise Exception(
f"Error creating tsf expected documents >> {doc_assignment_response}"
)
except Exception as e:
db.session.rollback()
current_app.logger.error(str(e))
raise InternalServerError(str(e) + ", tsf not created")
mine.save()
return mine_tsf
def get(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound("Mine not found")
return mine.mine_incidents
def test_mine_model_find_by_mine_guid_fail(test_client, auth_headers):
mine = Mine.find_by_mine_guid('jflkjfsdl')
assert mine is None
def post(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound('Mine not found')
data = self.parser.parse_args()
do_sub_codes = []
if data['determination_type_code'] == 'DO':
do_sub_codes = data['dangerous_occurrence_subparagraph_ids']
if not do_sub_codes:
raise BadRequest(
'Dangerous occurrences require one or more cited sections of HSRC code 1.7.3'
)
incident = MineIncident.create(
mine,
data['incident_timestamp'],
data['incident_description'],
determination_type_code=data['determination_type_code'],
mine_determination_type_code=data['mine_determination_type_code'],
mine_determination_representative=data[
'mine_determination_representative'],
followup_investigation_type_code=data[
'followup_investigation_type_code'],
reported_timestamp=data['reported_timestamp'],
reported_by_name=data['reported_by_name'],
)
incident.reported_by_email = data.get('reported_by_email')
incident.reported_by_phone_no = data.get('reported_by_phone_no')
incident.reported_by_phone_ext = data.get('reported_by_phone_ext')
incident.number_of_fatalities = data.get('number_of_fatalities')
incident.number_of_injuries = data.get('number_of_injuries')
incident.emergency_services_called = data.get(
'emergency_services_called')
incident.followup_inspection = data.get('followup_inspection')
incident.followup_inspection_date = data.get(
'followup_inspection_date')
incident.status_code = data.get('status_code')
incident.proponent_incident_no = data.get('proponent_incident_no')
# lookup and validated inspector party relationships
tmp_party = Party.query.filter_by(
party_guid=data.get('reported_to_inspector_party_guid')).first()
if tmp_party and 'INS' in tmp_party.business_roles_codes:
incident.reported_to_inspector_party_guid = tmp_party.party_guid
tmp_party = Party.query.filter_by(
party_guid=data.get('responsible_inspector_party_guid')).first()
if tmp_party and 'INS' in tmp_party.business_roles_codes:
incident.responsible_inspector_party_guid = tmp_party.party_guid
tmp_party = Party.query.filter_by(
party_guid=data.get('determination_inspector_party_guid')).first()
if tmp_party and 'INS' in tmp_party.business_roles_codes:
incident.determination_inspector_party_guid = tmp_party.party_guid
incident.determination_type_code = data.get('determination_type_code')
incident.followup_investigation_type_code = data.get(
'followup_investigation_type_code')
for id in do_sub_codes:
sub = ComplianceArticle.find_by_compliance_article_id(id)
if not _compliance_article_is_do_subparagraph(sub):
raise BadRequest(
'One of the provided compliance articles is not a sub-paragraph of section 1.7.3 (dangerous occurrences)'
)
incident.dangerous_occurrence_subparagraphs.append(sub)
updated_documents = data.get('updated_documents')
if updated_documents is not None:
for updated_file in updated_documents:
mine_doc = MineDocument(
mine_guid=mine.mine_guid,
document_name=updated_file['document_name'],
document_manager_guid=updated_file['document_manager_guid']
)
if not mine_doc:
raise BadRequest(
'Unable to register uploaded file as document')
mine_doc.save()
mine_incident_doc = MineIncidentDocumentXref(
mine_document_guid=mine_doc.mine_document_guid,
mine_incident_id=incident.mine_incident_id,
mine_incident_document_type_code=updated_file[
'mine_incident_document_type_code']
if updated_file['mine_incident_document_type_code'] else
'INI')
incident.documents.append(mine_incident_doc)
try:
incident.save()
except Exception as e:
raise InternalServerError(f'Error when saving: {e}')
recommendations = data.get('recommendations')
if recommendations is not None:
for recommendation in recommendations:
rec_string = recommendation.get('recommendation')
if rec_string is None:
continue
new_recommendation = MineIncidentRecommendation.create(
rec_string, mine_incident_id=incident.mine_incident_id)
new_recommendation.save()
return incident, 201
def test_mine_model_find_by_mine_guid(test_client, auth_headers):
mine = Mine.find_by_mine_guid(TEST_MINE_GUID)
assert str(mine.mine_guid) == TEST_MINE_GUID
def put(self, mine_guid, mine_report_guid):
mine = Mine.find_by_mine_guid(mine_guid)
mine_report = MineReport.find_by_mine_report_guid(mine_report_guid)
if not mine_report or str(mine_report.mine_guid) != mine_guid:
raise NotFound("Mine Report not found")
data = self.parser.parse_args()
if 'due_date' in data:
mine_report.due_date = data.get('due_date')
if 'received_date' in data:
mine_report.received_date = data['received_date']
if 'submission_year' in data:
mine_report.submission_year = data['submission_year']
if data.get('mine_report_submission_status') is not None:
mine_report_submission_status = data.get(
'mine_report_submission_status')
else:
mine_report_submission_status = 'NRQ'
report_submissions = data.get('mine_report_submissions')
submission_iterator = iter(report_submissions)
new_submission = next(
(x for x in submission_iterator
if x.get('mine_report_submission_guid') is None), None)
if new_submission is not None:
new_report_submission = MineReportSubmission(
submission_date=datetime.now(),
mine_report_submission_status_code=mine_report_submission_status
)
# Copy the current list of documents for the report submission
last_submission_docs = mine_report.mine_report_submissions[
-1].documents.copy() if len(
mine_report.mine_report_submissions) > 0 else []
# Gets the difference between the set of documents in the new submission and the last submission
new_docs = [
x for x in new_submission.get('documents') if not any(
str(doc.document_manager_guid) ==
x['document_manager_guid'] for doc in last_submission_docs)
]
# Get the documents that were on the last submission but not part of the new submission
removed_docs = [
x for x in last_submission_docs
if not any(doc['document_manager_guid'] == str(
x.document_manager_guid)
for doc in new_submission.get('documents'))
]
# Remove the deleted documents from the existing set.
for doc in removed_docs:
last_submission_docs.remove(doc)
if len(last_submission_docs) > 0:
new_report_submission.documents.extend(last_submission_docs)
for doc in new_docs:
mine_doc = MineDocument(
mine_guid=mine.mine_guid,
document_name=doc['document_name'],
document_manager_guid=doc['document_manager_guid'])
if not mine_doc:
raise BadRequest(
'Unable to register uploaded file as document')
mine_doc.save()
new_report_submission.documents.append(mine_doc)
mine_report.mine_report_submissions.append(new_report_submission)
# if the status has changed, update the status of the last submission
elif (
len(mine_report.mine_report_submissions) > 0
) and mine_report_submission_status != mine_report.mine_report_submissions[
-1].mine_report_submission_status_code:
mine_report.mine_report_submissions[
-1].mine_report_submission_status_code = mine_report_submission_status
try:
mine_report.save()
except Exception as e:
raise InternalServerError(f'Error when saving: {e}')
return mine_report
def get(self, mine_guid):
mine = Mine.find_by_mine_guid(mine_guid)
if not mine:
raise NotFound("Mine not found")
return [i for i in mine.mine_incidents if i.deleted_ind == False]
def test_mine_model_find_by_mine_guid(db_session):
init_mine_guid = MineFactory().mine_guid
mine = Mine.find_by_mine_guid(str(init_mine_guid))
assert mine.mine_guid == init_mine_guid
def test_mine_model_find_by_mine_guid_fail(db_session):
init_mine = MineFactory()
mine = Mine.find_by_mine_guid('jflkjfsdl')
assert mine is None