def validate_patch_tender_stage2_data(request):
data = validate_json_data(request)
if request.context.status == 'draft':
default_statuses = ['active.tendering', STAGE2_STATUS]
if data.get('status') not in default_statuses:
raise_operation_error(request, 'Can\'t update tender in current ({0}) status'.format(data['status']))
request.validated['data'] = {'status': data.get('status')}
request.context.status = data.get('status')
return
if data:
if 'items' in data:
items = request.context.items
cpv_group_lists = [i.classification.id[:3] for i in items]
for item in data['items']:
if 'classification' in item and 'id' in item['classification']:
cpv_group_lists.append(item['classification']['id'][:3])
if len(set(cpv_group_lists)) != 1:
request.errors.add('body', 'item', 'Can\'t change classification')
request.errors.status = 403
raise error_handler(request.errors)
if 'enquiryPeriod' in data:
if apply_data_patch(request.context.enquiryPeriod.serialize(), data['enquiryPeriod']):
request.errors.add('body', 'item', 'Can\'t change enquiryPeriod')
request.errors.status = 403
raise error_handler(request.errors)
if request.context.status == STAGE2_STATUS and data.get('status') == 'active.tendering':
data = validate_data(request, type(request.tender), True, data)
if data: # if no error then add status to validate data
request.context.status = 'active.tendering'
data['status'] = 'active.tendering'
else:
data = validate_data(request, type(request.tender), True, data)
return data
def validate_complaint_data(request, **kwargs):
err_msg = 'Broker Accreditation level does not permit complaint creation'
if not check_subresource_create_accredetation(request, err_msg):
return
update_logging_context(request, {'complaint_id': '__new__'})
model = type(request.auction).complaints.model_class
return validate_data(request, model, "complaint")
def validate_bid_data(request):
if not request.check_accreditation(request.tender.edit_accreditation):
request.errors.add(
'procurementMethodType', 'accreditation',
'Broker Accreditation level does not permit bid creation')
request.errors.status = 403
raise error_handler(request.errors)
if request.tender.get('mode',
None) is None and request.check_accreditation('t'):
request.errors.add(
'procurementMethodType', 'mode',
'Broker Accreditation level does not permit bid creation')
request.errors.status = 403
raise error_handler(request.errors)
update_logging_context(request, {'bid_id': '__new__'})
model = type(request.tender).bids.model_class
bid = validate_data(request, model)
validated_bid = request.validated.get('bid')
if validated_bid:
if any([
key == 'documents' or 'Documents' in key
for key in validated_bid.keys()
]):
bid_documents = validate_bid_documents(request)
if not bid_documents:
return
for documents_type, documents in bid_documents.items():
validated_bid[documents_type] = documents
return bid
def validate_patch_tender_ua_data(request):
data = validate_json_data(request)
# TODO try to use original code openprocurement.tender.core.validation.validate_patch_tender_data
if request.context.status == 'draft':
default_status = type(request.tender).fields['status'].default
if data and data.get('status') != default_status:
raise_operation_error(
request, 'Can\'t update tender in current (draft) status')
request.validated['data'] = {'status': default_status}
request.context.status = default_status
return
if data:
if 'items' in data:
items = request.context.items
cpv_group_lists = [i.classification.id[:3] for i in items]
for item in data['items']:
if 'classification' in item and 'id' in item['classification']:
cpv_group_lists.append(item['classification']['id'][:3])
if len(set(cpv_group_lists)) != 1:
request.errors.add('body', 'item',
'Can\'t change classification')
request.errors.status = 403
raise error_handler(request.errors)
if 'enquiryPeriod' in data:
if apply_data_patch(request.context.enquiryPeriod.serialize(),
data['enquiryPeriod']):
request.errors.add('body', 'item',
'Can\'t change enquiryPeriod')
request.errors.status = 403
raise error_handler(request.errors)
return validate_data(request, type(request.tender), True, data)
def validate_tender_data(request):
update_logging_context(request, {'tender_id': '__new__'})
data = validate_json_data(request)
model = request.tender_from_data(data, create=False)
#if not request.check_accreditation(model.create_accreditation):
#if not any([request.check_accreditation(acc) for acc in getattr(model, 'create_accreditations', [getattr(model, 'create_accreditation', '')])]):
if not any([
request.check_accreditation(acc)
for acc in iter(str(model.create_accreditation))
]):
request.errors.add(
'procurementMethodType', 'accreditation',
'Broker Accreditation level does not permit tender creation')
request.errors.status = 403
raise error_handler(request.errors)
data = validate_data(request, model, data=data)
if data and data.get('mode',
None) is None and request.check_accreditation('t'):
request.errors.add(
'procurementMethodType', 'mode',
'Broker Accreditation level does not permit tender creation')
request.errors.status = 403
raise error_handler(request.errors)
if data and data.get('procuringEntity', {}).get(
'kind', '') not in model.procuring_entity_kinds:
request.errors.add(
'procuringEntity', 'kind',
'{kind!r} procuringEntity cannot publish this type of procedure. '
'Only {kinds} are allowed.'.format(
kind=data.get('procuringEntity', {}).get('kind', ''),
kinds=', '.join(model.procuring_entity_kinds)))
request.errors.status = 403
def validate_patch_tender_ua_data(request):
data = validate_json_data(request)
if request.context.status == 'draft':
default_status = type(request.tender).fields['status'].default
if data and data.get('status') != default_status:
request.errors.add('body', 'data', 'Can\'t update tender in current (draft) status')
request.errors.status = 403
return
request.validated['data'] = {'status': default_status}
request.context.status = default_status
return
if data:
if 'items' in data:
items = request.context.items
cpv_group_lists = [i.classification.id[:3] for i in items]
for item in data['items']:
if 'classification' in item and 'id' in item['classification']:
cpv_group_lists.append(item['classification']['id'][:3])
if len(set(cpv_group_lists)) != 1:
request.errors.add('body', 'item', 'Can\'t change classification')
request.errors.status = 403
return None
if 'enquiryPeriod' in data:
if apply_data_patch(request.context.enquiryPeriod.serialize(), data['enquiryPeriod']):
request.errors.add('body', 'item', 'Can\'t change enquiryPeriod')
request.errors.status = 403
return None
return validate_data(request, type(request.tender), True, data)
def validate_monitor_data(request):
update_logging_context(request, {'monitor_id': '__new__'})
data = validate_json_data(request)
if data is None:
return
data = validate_data(request, Monitor, data=data)
return data
def validate_patch_tender_ua_data(request):
data = validate_json_data(request)
classification_id = request.context.items[0].classification.id
if 'items' in data:
for item in data['items']:
if 'classification' in item:
if item['classification'].get('id', '') != classification_id:
request.errors.add('body', 'item', 'Can\'t change classification')
request.errors.status = 403
return None
if 'enquiryPeriod' in data:
request.errors.add('body', 'item', 'Can\'t change enquiryPeriod')
request.errors.status = 403
return None
if 'tenderPeriod' in data:
data["auctionPeriod"] = {'startDate': None}
if len(request.context.lots) > 0:
lots = list(data['lots']) if 'lots' in data else []
data['lots'] = []
for index, lot in enumerate(request.context.lots):
lot_data = lots[index] if lots else {}
lot_data['auctionPeriod'] = {'startDate': None}
data['lots'].append(lot_data)
return validate_data(request, request.tender.__class__, True, data)
def validate_qualification_complaint_post_data(request):
update_logging_context(request, {"post_id": "__new__"})
validate_post_accreditation_level(request)
model = type(
request.tender
).qualifications.model_class.complaints.model_class.posts.model_class
return validate_data(request, model)
def validate_patch_tender_ua_data(request):
data = validate_json_data(request)
if request.context.status == "draft":
validate_patch_tender_data_draft(request)
return
if data:
if "items" in data:
items = request.context.items
cpv_group_lists = [i.classification.id[:3] for i in items]
for item in data["items"]:
if "classification" in item and "id" in item["classification"]:
cpv_group_lists.append(item["classification"]["id"][:3])
if len(set(cpv_group_lists)) != 1:
request.errors.add("body", "item",
"Can't change classification")
request.errors.status = 403
raise error_handler(request.errors)
if "enquiryPeriod" in data:
if apply_data_patch(request.context.enquiryPeriod.serialize(),
data["enquiryPeriod"]):
request.errors.add("body", "item",
"Can't change enquiryPeriod")
request.errors.status = 403
raise error_handler(request.errors)
return validate_data(request, type(request.tender), True, data)
def validate_transfer_data(request):
update_logging_context(request, {'transfer_id': '__new__'})
data = validate_json_data(request)
if data is None:
return
model = Transfer
return validate_data(request, model, data=data)
def validate_plan_data(request):
update_logging_context(request, {"plan_id": "__new__"})
data = validate_json_data(request)
model = request.plan_from_data(data, create=False)
validate_plan_accreditation_level(request, model)
data = validate_data(request, model, data=data)
validate_plan_accreditation_level_mode(request)
return data
def validate_framework_data(request, **kwargs):
update_logging_context(request, {"framework_id": "__new__"})
data = validate_json_data(request)
model = request.framework_from_data(data, create=False)
validate_framework_accreditation_level_central(request, model)
data = validate_data(request, model, data=data)
validate_doc_accreditation_level_mode(request, "frameworkType", "framework")
return data
def validate_patch_tender_data(request):
data = validate_json_data(request)
if request.context.status != 'draft':
return validate_data(request, type(request.tender), True, data)
default_status = type(request.tender).fields['status'].default
if data.get('status') != default_status:
raise_operation_error(request, 'Can\'t update tender in current (draft) status')
request.validated['data'] = {'status': default_status}
request.context.status = default_status
def validate_plan_data(request):
update_logging_context(request, {'plan_id': '__new__'})
data = validate_json_data(request)
if data is None:
return
model = request.plan_from_data(data, create=False)
return validate_data(request, model, data=data)
def validate_lot_data(request, **kwargs):
update_logging_context(request, {'lot_id': '__new__'})
data = validate_json_data(request)
model = request.lot_from_data(data, create=False)
validate_accreditations(request, model, 'lot')
data = validate_data(request, model, "lot", data=data)
validate_t_accreditation(request, data, 'lot')
def validate_file_transaction_upload(request, **kwargs):
transaction = get_transaction_by_id(request)
if not transaction:
raise_operation_error(request, "Can't add document contract to nonexistent transaction", status=404)
update_logging_context(request, {"document_id": "__new__"})
if request.registry.docservice_url and request.content_type == "application/json":
model = type(transaction).documents.model_class
return validate_data(request, model)
def validate_asset_data(request, error_handler, **kwargs):
update_logging_context(request, {'asset_id': '__new__'})
data = validate_json_data(request)
model = request.asset_from_data(data, create=False)
validate_accreditations(request, model, 'asset')
data = validate_data(request, model, "asset", data=data)
validate_t_accreditation(request, data, 'asset')
def validate_patch_complaint_data_stage2(request):
model = type(request.tender).complaints.model_class
data = validate_data(request, model, True)
if data:
if validate_author(request, request.tender['shortlistedFirms'], request.validated['complaint']):
return data # validate is OK
else:
return None # we catch errors
return data
def validate_contract_data(request):
update_logging_context(request, {'contract_id': '__new__'})
data = request.validated['json_data'] = validate_json_data(request)
model = request.contract_from_data(data, create=False)
if hasattr(request, 'check_accreditation') and not request.check_accreditation(model.create_accreditation):
request.errors.add('contract', 'accreditation', 'Broker Accreditation level does not permit contract creation')
request.errors.status = 403
raise error_handler(request.errors)
return validate_data(request, model, data=data)
def validate_milestone_data(request, **kwargs):
update_logging_context(request, {"milestone_id": "__new__"})
model = type(request.plan).milestones.model_class
milestone = validate_data(request, model)
upload_objects_documents(
request,
request.validated["milestone"],
route_kwargs={"milestone_id": request.validated["milestone"].id})
return milestone
def validate_qualification_complaint_post_data(request):
update_logging_context(request, {"post_id": "__new__"})
validate_post_accreditation_level(request)
model = type(request.tender).qualifications.model_class.complaints.model_class.posts.model_class
post = validate_data(request, model)
upload_objects_documents(
request, request.validated["post"],
route_kwargs={"post_id": request.validated["post"].id}
)
return post
def validate_tender_plan_data(request):
data = validate_data(request, type(request.tender).plans.model_class)
plan_id = data["id"]
update_logging_context(request, {"plan_id": plan_id})
plan = extract_plan_adapter(request, plan_id)
with handle_data_exceptions(request):
plan.validate()
request.validated["plan"] = plan
request.validated["plan_src"] = plan.serialize("plain")
def validate_patch_framework_data(request, **kwargs):
data = validate_json_data(request)
data = validate_data(request, type(request.framework), True, data)
framework = request.validated["framework"]
if framework.agreementID:
agreement = get_agreement_by_id(request.registry.db, framework.agreementID)
request.validated["agreement_src"] = agreement
request.validated["agreement"] = Agreement(agreement)
request.validated["agreement"].__parent__ = framework.__parent__
return data
def validate_qualification_data(request, **kwargs):
update_logging_context(request, {"qualification_id": "__new__"})
data = validate_json_data(request)
model = request.qualification_from_data(data, create=False)
data = validate_data(request, model, data=data)
submission = get_submission_by_id(request, data["submissionID"])
framework = get_framework_by_id(request, data["frameworkID"])
request.validated["submission"] = submission
request.validated["framework"] = framework
return data
def validate_agreement_patch(request, **kwargs):
data = validate_json_data(request)
if data:
if "features" in data:
if apply_data_patch([f.serialize() for f in request.context.features], data["features"]):
request.errors.add("body", "features", "Can't change features")
request.errors.status = 403
raise error_handler(request)
return validate_data(request, type(request.agreement), True, data=data)
def validate_plan_data(request, **kwargs):
update_logging_context(request, {"plan_id": "__new__"})
data = validate_json_data(request)
model = request.plan_from_data(data, create=False)
_validate_plan_accreditation_level(request, model)
data = validate_data(request, model, data=data)
_validate_plan_availability(request)
_validate_plan_accreditation_level_mode(request)
_validate_tender_procurement_method_type(request)
return data
def validate_tender_data(request):
update_logging_context(request, {"tender_id": "__new__"})
data = validate_json_data(request)
model = request.tender_from_data(data, create=False)
validate_tender_accreditation_level(request, model)
validate_tender_accreditation_level_central(request, model)
data = validate_data(request, model, data=data)
validate_tender_accreditation_level_mode(request)
validate_tender_kind(request, model)
return data
def validate_patch_lot_data(request, error_handler, **kwargs):
data = validate_json_data(request)
editing_roles = request.content_configurator.available_statuses[request.context.status]['editing_permissions']
if request.authenticated_role not in editing_roles:
msg = 'Can\'t update {} in current ({}) status'.format(request.validated['resource_type'],
request.context.status)
raise_operation_error(request, error_handler, msg)
default_status = type(request.lot).fields['status'].default
if data.get('status') == default_status and data.get('status') != request.context.status:
raise_operation_error(request, error_handler, 'Can\'t switch lot to {} status'.format(default_status))
return validate_data(request, type(request.lot), data=data)
def validate_complaint_data_stage2(request):
update_logging_context(request, {"complaint_id": "__new__"})
validate_complaint_accreditation_level(request)
data = validate_data(request, type(request.tender).complaints.model_class)
if data:
if validate_author(request, request.tender["shortlistedFirms"],
request.validated["complaint"]):
return data # validate is OK
else:
return None # we catch errors
return data
def validate_auction_data(request, **kwargs):
update_logging_context(request, {'auction_id': '__new__'})
data = validate_json_data(request)
if data is None:
return
model = request.auction_from_data(data, create=False)
validate_accreditations(request, model, 'auction')
data = validate_data(request, model, "auction", data=data)
validate_t_accreditation(request, data, 'auction')
def validate_plan_data(request):
update_logging_context(request, {'plan_id': '__new__'})
data = validate_json_data(request)
if data is None:
return
model = request.plan_from_data(data, create=False)
if hasattr(request, 'check_accreditation') \
and not any([request.check_accreditation(acc) for acc in model.create_accreditations]):
request.errors.add('plan', 'accreditation', 'Broker Accreditation level does not permit plan creation')
request.errors.status = 403
return
return validate_data(request, model, data=data)
def validate_complaint_data(request):
if not request.check_accreditation(request.tender.edit_accreditation):
request.errors.add('procurementMethodType', 'accreditation', 'Broker Accreditation level does not permit complaint creation')
request.errors.status = 403
return
if request.tender.get('mode', None) is None and request.check_accreditation('t'):
request.errors.add('procurementMethodType', 'mode', 'Broker Accreditation level does not permit complaint creation')
request.errors.status = 403
return
update_logging_context(request, {'complaint_id': '__new__'})
model = type(request.context).complaints.model_class
return validate_data(request, model)
def validate_patch_tender_data(request):
data = validate_json_data(request)
if request.context.status != 'draft':
return validate_data(request, type(request.tender), True, data)
default_status = type(request.tender).fields['status'].default
if data.get('status') != default_status:
request.errors.add('body', 'data',
'Can\'t update tender in current (draft) status')
request.errors.status = 403
raise error_handler(request.errors)
request.validated['data'] = {'status': default_status}
request.context.status = default_status
def validate_post_question_data_stage2(request):
update_logging_context(request, {"question_id": "__new__"})
validate_question_accreditation_level(request)
model = type(request.tender).questions.model_class
data = validate_data(request, model)
if data:
if validate_author(request, request.tender["shortlistedFirms"],
request.validated["question"]):
return data # validate is OK
else:
return None # we catch errors
return data
def validate_complaint_data(request):
if not request.check_accreditation(request.auction.edit_accreditation):
request.errors.add('procurementMethodType', 'accreditation', 'Broker Accreditation level does not permit complaint creation')
request.errors.status = 403
return
if request.auction.get('mode', None) is None and request.check_accreditation('t'):
request.errors.add('procurementMethodType', 'mode', 'Broker Accreditation level does not permit complaint creation')
request.errors.status = 403
return
update_logging_context(request, {'complaint_id': '__new__'})
model = type(request.auction).complaints.model_class
return validate_data(request, model)
def validate_complaint_data_stage2(request):
if not request.check_accreditation(request.tender.edit_accreditation):
request.errors.add('procurementMethodType', 'accreditation', 'Broker Accreditation level does not permit complaint creation')
request.errors.status = 403
raise error_handler(request.errors)
if request.tender.get('mode', None) is None and request.check_accreditation('t'):
request.errors.add('procurementMethodType', 'mode', 'Broker Accreditation level does not permit complaint creation')
request.errors.status = 403
raise error_handler(request.errors)
update_logging_context(request, {'complaint_id': '__new__'})
data = validate_data(request, type(request.tender).complaints.model_class)
if data:
if validate_author(request, request.tender['shortlistedFirms'], request.validated['complaint']):
return data # validate is OK
else:
return None # we catch errors
return data
def validate_patch_tender_ua_data(request):
data = validate_json_data(request)
items = request.context.items
if data:
if 'items' in data:
cpv_group_lists = [i.classification.id[:3] for i in items]
for item in data['items']:
if 'classification' in item and 'id' in item['classification']:
cpv_group_lists.append(item['classification']['id'][:3])
if len(set(cpv_group_lists)) != 1:
request.errors.add('body', 'item', 'Can\'t change classification')
request.errors.status = 403
return None
if 'enquiryPeriod' in data:
if apply_data_patch(request.context.enquiryPeriod.serialize(), data['enquiryPeriod']):
request.errors.add('body', 'item', 'Can\'t change enquiryPeriod')
request.errors.status = 403
return None
return validate_data(request, request.tender.__class__, True, data)
def validate_patch_change_data(request):
return validate_data(request, Change, True)
def validate_patch_plan_data(request):
return validate_data(request, Plan, True)
def validate_change_data(request):
update_logging_context(request, {'change_id': '__new__'})
data = validate_json_data(request)
return validate_data(request, Change, data=data)
def validate_patch_contract_data(request):
return validate_data(request, Contract, True)
def validate_patch_award_data(request):
return validate_data(request, Award, True)
def validate_patch_complaint_data(request):
model = type(request.context.__parent__).complaints.model_class
return validate_data(request, model, True)
def validate_complaint_data(request):
update_logging_context(request, {'complaint_id': '__new__'})
model = type(request.context).complaints.model_class
return validate_data(request, model)
def validate_plan_data(request):
update_logging_context(request, {'plan_id': '__new__'})
return validate_data(request, Plan)
def validate_patch_qualification_data(request):
return validate_data(request, Qualification, True)
