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()