def save_request(request, date_modified=None):
obj = request.validated["request"]
patch = get_revision_changes(
request.validated["request_src"], obj.serialize("plain")
)
if patch:
add_revision(request, obj, patch)
old_date_modified = obj.dateModified
obj.dateModified = date_modified or get_now()
try:
obj.store(request.registry.db)
except ModelValidationError as e: # pragma: no cover
for i in e.messages:
request.errors.add("body", i, e.messages[i])
request.errors.status = 422
except Exception as e: # pragma: no cover
request.errors.add("body", "data", str(e))
else:
LOGGER.info(
"Saved request {}: dateModified {} -> {}".format(
obj.id,
old_date_modified and old_date_modified.isoformat(),
obj.dateModified.isoformat(),
),
extra=context_unpack(request, {"MESSAGE_ID": "save_request"}),
)
return True
def patch(self):
inspection = self.request.validated['inspection']
apply_patch(self.request, src=self.request.validated['inspection_src'])
LOGGER.info('Updated monitoring {}'.format(inspection.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'inspection_patch'}))
return {'data': inspection.serialize('view')}
def save_monitoring(request, date_modified=None, update_context_date=False):
monitoring = request.validated['monitoring']
patch = get_revision_changes(request.validated['monitoring_src'],
monitoring.serialize('plain'))
if patch:
add_revision(request, monitoring, patch)
old_date_modified = monitoring.dateModified
now = date_modified or get_now()
monitoring.dateModified = now
if update_context_date and "dateModified" in request.context:
request.context.dateModified = now
try:
monitoring.store(request.registry.db)
except ModelValidationError as e: # pragma: no cover
for i in e.messages:
request.errors.add('body', i, e.messages[i])
request.errors.status = 422
except Exception as e: # pragma: no cover
request.errors.add('body', 'data', str(e))
else:
LOGGER.info('Saved monitoring {}: dateModified {} -> {}'.format(
monitoring.id, old_date_modified
and old_date_modified.isoformat(),
monitoring.dateModified.isoformat()),
extra=context_unpack(
request, {'MESSAGE_ID': 'save_monitoring'}))
return True
def patch(self):
apply_patch(self.request)
self.LOGGER.info(
'Updated liability {}'.format(self.request.context.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'liability_patch'}))
return {'data': self.request.context.serialize('view')}
def save_inspection(request, date_modified=None):
inspection = request.validated['inspection']
patch = get_revision_changes(request.validated['inspection_src'],
inspection.serialize("plain"))
if patch:
add_revision(request, inspection, patch)
old_date_modified = inspection.dateModified
inspection.dateModified = date_modified or get_now()
try:
inspection.store(request.registry.db)
except ModelValidationError as e: # pragma: no cover
for i in e.messages:
request.errors.add('body', i, e.messages[i])
request.errors.status = 422
except Exception as e: # pragma: no cover
request.errors.add('body', 'data', str(e))
else:
LOGGER.info('Saved inspection {}: dateModified {} -> {}'.format(
inspection.id, old_date_modified
and old_date_modified.isoformat(),
inspection.dateModified.isoformat()),
extra=context_unpack(
request, {'MESSAGE_ID': 'save_inspection'}))
return True
def patch(self):
appeal = self.request.context
monitoring = self.request.validated['monitoring']
apply_patch(self.request, src=appeal.serialize())
self.LOGGER.info('Updated appeal {}'.format(monitoring.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'appeal_patch'}))
return {'data': appeal.serialize('view')}
def patch(self):
document = self.request.context
if apply_patch(self.request):
self.LOGGER.info('Updated inspection document {}'.format(document.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'inspection_document_patch'},
{'DOCUMENT_ID': document.id}))
return {'data': self.request.context.serialize("view")}
def patch(self):
"""
Post a party resolution
"""
apply_patch(self.request)
self.LOGGER.info('Updated party {}'.format(self.request.context.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'party_patch'}))
return {'data': self.request.context.serialize('view')}
def put(self):
appeal = self.request.validated['appeal']
set_author(appeal.documents, self.request, 'author')
upload_objects_documents(self.request, appeal)
appeal.datePublished = appeal.dateCreated
apply_patch(self.request, data=dict(appeal=appeal))
self.LOGGER.info('Updated appeal {}'.format(self.request.context.id),
extra=context_unpack(self.request, {'MESSAGE_ID': 'appeal_put'}))
return {'data': appeal.serialize('view')}
def put(self):
parent = self.request.context.__parent__
document = upload_file(self.request)
set_author(document, self.request, 'author')
parent.documents.append(document)
if save_inspection(self.request):
self.LOGGER.info('Updated inspection document {}'.format(document.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'inspection_document_put'},
{'DOCUMENT_ID': document.id}))
return {'data': document.serialize("view")}
def patch(self):
document = self.request.context
if apply_patch(self.request):
self.LOGGER.info(
"Updated request document {}".format(document.id),
extra=context_unpack(
self.request,
{"MESSAGE_ID": "request_document_patch"},
{"DOCUMENT_ID": document.id},
),
)
return {"data": self.request.context.serialize("view")}
def put(self):
elimination = self.request.validated['eliminationreport']
elimination.datePublished = elimination.dateCreated
set_author(elimination.documents, self.request, 'author')
upload_objects_documents(self.request, elimination)
apply_patch(self.request,
data=dict(eliminationReport=elimination),
date_modified=elimination.dateCreated)
self.LOGGER.info(
'Updated elimination {}'.format(self.request.context.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'elimination_put'}))
return {'data': elimination.serialize('view')}
def patch(self):
"""
Monitoring Document Update
"""
document = self.request.context
if apply_patch(self.request, update_context_date=True):
self.LOGGER.info('Updated {} monitoring document {}'.format(
self.document_type, document.id),
extra=context_unpack(
self.request,
{'MESSAGE_ID': 'monitoring_document_patch'},
{'DOCUMENT_ID': document.id}))
return {'data': self.request.context.serialize('view')}
def patch(self):
obj = self.request.validated["request"]
now = get_now()
if obj.answer is not None:
raise forbidden(self.request)
apply_patch(self.request, src=self.request.validated["request_src"], save=False)
if obj.answer:
obj.dateAnswered = now
save_request(self.request, date_modified=now)
LOGGER.info(
"Updated request {}".format(obj.id),
extra=context_unpack(self.request, {"MESSAGE_ID": "request_patch"}),
)
return {"data": request_serialize_view(obj, self.request.authenticated_role)}
def collection_post(self):
document = upload_file(self.request)
set_author(document, self.request, 'author')
documents = self.context.documents
documents.append(document)
if save_inspection(self.request):
self.LOGGER.info('Created inspection document {}'.format(document.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'inspection_document_create'},
{'DOCUMENT_ID': document.id}))
route = self.request.matched_route.name.replace("collection_", "")
location = self.request.current_route_url(document_id=document.id, _route_name=route, _query={})
self.request.response.status = 201
self.request.response.headers['Location'] = location
return {'data': document.serialize("view")}
def post(self):
inspection = self.request.validated['inspection']
inspection.id = generate_id()
inspection.inspection_id = generate_inspection_id(
get_now(), self.db, self.server_id)
set_author(inspection.documents, self.request, 'author')
save_inspection(self.request, date_modified=inspection.dateCreated)
LOGGER.info('Created inspection {}'.format(inspection.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'inspection_create'},
{'MONITORING_ID': inspection.id}))
self.request.response.status = 201
self.request.response.headers['Location'] = self.request.route_url(
'Inspection', inspection_id=inspection.id)
return {'data': inspection.serialize('view')}
def put(self):
parent = self.request.context.__parent__
document = upload_file(self.request)
set_author(document, self.request, "author")
parent.documents.append(document)
if save_request(self.request):
self.LOGGER.info(
"Updated request document {}".format(document.id),
extra=context_unpack(
self.request,
{"MESSAGE_ID": "request_document_put"},
{"DOCUMENT_ID": document.id},
),
)
return {"data": document.serialize("view")}
def patch(self):
monitoring = self.request.validated['monitoring']
set_ownership(monitoring, self.request, 'tender_owner')
if save_monitoring(self.request):
self.LOGGER.info(
'Generate Monitoring credentials {}'.format(monitoring.id),
extra=context_unpack(
self.request,
{'MESSAGE_ID': 'monitoring_generate_credentials'}))
return {
'data': monitoring.serialize('view'),
'access': {
'token': monitoring.tender_owner_token
}
}
def put(self):
"""
Monitoring Document Update
"""
parent = self.request.context.__parent__
document = upload_file(self.request)
set_author(document, self.request, 'author')
parent.documents.append(document)
if save_monitoring(self.request):
self.LOGGER.info(
'Updated {} monitoring document {}'.format(
self.document_type, document.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'monitoring_document_put'},
{'DOCUMENT_ID': document.id}))
return {'data': document.serialize('view')}
def collection_post(self):
"""
Post a party
"""
monitoring = self.context
party = self.request.validated['party']
monitoring.parties.append(party)
if save_monitoring(self.request):
self.LOGGER.info(
'Created monitoring party {}'.format(party.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'monitoring_party_create'},
{'party_id': party.id}))
self.request.response.status = 201
self.request.response.headers['Location'] = self.request.route_url(
'Monitoring Party',
monitoring_id=monitoring.id,
party_id=party.id)
return {'data': party.serialize('view')}
def collection_post(self):
monitoring = self.context
liability = self.request.validated['liability']
set_author(liability.documents, self.request, 'author')
# upload_objects_documents(self.request, liability)
monitoring.liabilities.append(liability)
if save_monitoring(self.request):
self.LOGGER.info(
'Created monitoring liability {}'.format(liability.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'liability_create'},
{'liability_id': liability.id}))
self.request.response.status = 201
self.request.response.headers['Location'] = self.request.route_url(
'Monitoring Liability',
monitoring_id=monitoring.id,
liability_id=liability.id)
return {'data': liability.serialize('view')}
def post(self):
monitoring = self.request.validated['monitoring']
monitoring.id = generate_id()
monitoring.monitoring_id = generate_monitoring_id(
get_now(), self.db, self.server_id)
if monitoring.decision:
upload_objects_documents(self.request,
monitoring.decision,
key="decision")
set_author(monitoring.decision.documents, self.request, 'author')
save_monitoring(self.request, date_modified=monitoring.dateCreated)
LOGGER.info('Created monitoring {}'.format(monitoring.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'monitoring_create'},
{'MONITORING_ID': monitoring.id}))
self.request.response.status = 201
self.request.response.headers['Location'] = self.request.route_url(
'Monitoring', monitoring_id=monitoring.id)
return {'data': monitoring.serialize('view')}
def post(self):
obj = self.request.validated["request"]
obj.id = generate_id()
obj.requestId = generate_request_id(get_now(), self.db, self.server_id)
set_author(obj.documents, self.request, "author")
upload_objects_documents(self.request, obj)
save_request(self.request, date_modified=obj.dateCreated)
LOGGER.info(
"Created request {}".format(obj.id),
extra=context_unpack(
self.request,
{"MESSAGE_ID": "request_create"},
{"MONITORING_ID": obj.id},
),
)
self.request.response.status = 201
self.request.response.headers["Location"] = self.request.route_url(
"Request", request_id=obj.id
)
return {"data": request_serialize_view(obj, self.request.authenticated_role)}
def get(self):
if self.request.params.get('mode') == 'draft':
perm = self.request.has_permission('view_draft_monitoring')
if not isinstance(perm, ACLAllowed):
return forbidden(self.request)
tender_id = self.request.matchdict["tender_id"]
opt_fields = self.request.params.get('opt_fields', '')
opt_fields = set(e for e in opt_fields.split(',') if e)
mode = self.request.params.get('mode', '')
list_view = self.views.get(mode, "")
view_kwargs = dict(
limit=500, # TODO: pagination
startkey=[tender_id, None],
endkey=[tender_id, {}],
)
if opt_fields - self.default_fields:
self.LOGGER.info(
'Used custom fields for monitoring list: {}'.format(','.join(
sorted(opt_fields))),
extra=context_unpack(self.request,
{'MESSAGE_ID': "CUSTOM_MONITORING_LIST"}))
results = [
monitoring_serialize(self.request, i[u'doc'],
opt_fields | self.default_fields)
for i in list_view(self.db, include_docs=True, **view_kwargs)
]
else:
results = [
dict(id=e.id, dateCreated=e.key[1], **e.value)
for e in list_view(self.db, **view_kwargs)
]
data = {
'data': results,
}
return data
def get(self):
monitoring_id = self.request.matchdict["monitoring_id"]
opt_fields = self.request.params.get('opt_fields', '')
opt_fields = set(e for e in opt_fields.split(',') if e)
mode = self.request.params.get('mode', '')
views = {
"": inspections_by_monitoring_id_view,
"test": test_inspections_by_monitoring_id_view,
}
list_view = views.get(mode, inspections_by_monitoring_id_view)
view_kwargs = dict(
limit=500, # TODO: pagination
startkey=[monitoring_id, None],
endkey=[monitoring_id, {}],
)
default_fields = set(CHANGES_FIELDS) | {"id", "dateCreated"}
if opt_fields - default_fields:
self.LOGGER.info(
'Used custom fields for monitoring list: {}'.format(','.join(
sorted(opt_fields))),
extra=context_unpack(self.request,
{'MESSAGE_ID': "CUSTOM_MONITORING_LIST"}))
results = [
inspection_serialize(self.request, i[u'doc'],
opt_fields | default_fields)
for i in list_view(self.db, include_docs=True, **view_kwargs)
]
else:
results = [
dict(id=e.id, dateCreated=e.key[1], **e.value)
for e in list_view(self.db, **view_kwargs)
]
data = {
'data': results,
}
return data
def collection_post(self):
document = upload_file(self.request)
set_author(document, self.request, "author")
documents = self.context.documents
documents.append(document)
if save_request(self.request):
self.LOGGER.info(
"Created request document {}".format(document.id),
extra=context_unpack(
self.request,
{"MESSAGE_ID": "request_document_create"},
{"DOCUMENT_ID": document.id},
),
)
route = self.request.matched_route.name.replace("collection_", "")
location = self.request.current_route_url(
document_id=document.id, _route_name=route, _query={}
)
self.request.response.status = 201
self.request.response.headers["Location"] = location
return {"data": document.serialize("view")}
def collection_post(self):
"""
Monitoring Document Upload
"""
document = upload_file(self.request)
set_author(document, self.request, 'author')
documents = self.context.documents
documents.append(document)
if save_monitoring(self.request):
self.LOGGER.info('Created {} monitoring document {}'.format(
self.document_type, document.id),
extra=context_unpack(
self.request,
{'MESSAGE_ID': 'monitoring_document_create'},
{'DOCUMENT_ID': document.id}))
route = self.request.matched_route.name.replace('collection_', '')
location = self.request.current_route_url(document_id=document.id,
_route_name=route,
_query={})
self.request.response.status = 201
self.request.response.headers['Location'] = location
return {'data': document.serialize('view')}
def collection_post(self):
"""
Post a post
"""
monitoring = self.context
post = self.request.validated['post']
set_author(post, self.request, 'author')
set_author(post.documents, self.request, 'author')
upload_objects_documents(self.request, post)
if post.author == get_monitoring_role('sas') and post.relatedPost is None:
accelerator = get_monitoring_accelerator(self.context)
post.dateOverdue = calculate_normalized_business_date(get_now(), POST_OVERDUE_TIME, accelerator)
if monitoring.status in (ADDRESSED_STATUS, DECLINED_STATUS):
post.postOf = CONCLUSION_OBJECT_TYPE
monitoring.posts.append(post)
if save_monitoring(self.request):
self.LOGGER.info('Created monitoring post {}'.format(post.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'monitoring_post_create'},
{'POST_ID': post.id}))
self.request.response.status = 201
self.request.response.headers['Location'] = self.request.route_url(
'Monitoring Post', monitoring_id=monitoring.id, post_id=post.id)
return {'data': post.serialize('view')}
old_date_modified = monitoring.dateModified
monitoring.dateModified = date_modified or get_now()
try:
monitoring.store(request.registry.db)
except ModelValidationError, e: # pragma: no cover
for i in e.message:
request.errors.add('body', i, e.message[i])
request.errors.status = 422
except Exception, e: # pragma: no cover
request.errors.add('body', 'data', str(e))
else:
LOGGER.info('Saved monitoring {}: dateModified {} -> {}'.format(
monitoring.id, old_date_modified
and old_date_modified.isoformat(),
monitoring.dateModified.isoformat()),
extra=context_unpack(
request, {'MESSAGE_ID': 'save_monitoring'}))
return True
def apply_patch(request, data=None, save=True, src=None, date_modified=None):
data = request.validated['data'] if data is None else data
patch = data and apply_data_patch(src or request.context.serialize(), data)
if patch:
request.context.import_data(patch)
if save:
return save_monitoring(request, date_modified=date_modified)
def add_revision(request, item, changes):
revision_data = {
'author': request.authenticated_userid,
try:
inspection.store(request.registry.db)
except ModelValidationError, e: # pragma: no cover
for i in e.message:
request.errors.add('body', i, e.message[i])
request.errors.status = 422
except Exception, e: # pragma: no cover
request.errors.add('body', 'data', str(e))
else:
LOGGER.info(
'Saved inspection {}: dateModified {} -> {}'.format(
inspection.id,
old_date_modified and old_date_modified.isoformat(),
inspection.dateModified.isoformat()
),
extra=context_unpack(request, {'MESSAGE_ID': 'save_inspection'})
)
return True
def apply_patch(request, data=None, save=True, src=None, date_modified=None):
data = request.validated['data'] if data is None else data
patch = data and apply_data_patch(src or request.context.serialize(), data)
if patch:
request.context.import_data(patch)
if save:
return save_inspection(request, date_modified=date_modified)
def generate_inspection_id(ctime, db, server_id=''):
key = ctime.date().isoformat()
