def patch(self):
"""
Submission edit(partial)
"""
submission = self.request.context
old_status = submission.status
new_status = self.request.validated["data"].get("status", old_status)
now = get_now()
if new_status != old_status:
submission.date = now
activated = new_status == "active" and old_status != new_status
if activated:
submission.datePublished = now
self.create_qualification()
apply_patch(self.request,
src=self.request.validated["submission_src"],
obj_name="submission")
self.LOGGER.info("Updated submission {}".format(submission.id),
extra=context_unpack(
self.request, {"MESSAGE_ID": "submission_patch"}))
return {"data": submission.serialize("view")}
def create_agreement_contract(self):
db = self.request.registry.db
qualification = self.request.validated["qualification"]
framework = self.request.validated["framework"]
agreement_data = get_agreement_by_id(db, framework.agreementID)
submission_data = get_submission_by_id(db, qualification.submissionID)
if agreement_data["status"] != "active":
return
contract_id = generate_id()
first_milestone_data = {
"type": "activation",
"documents": qualification.documents
}
contract_data = {
"id": contract_id,
"qualificationID": qualification.id,
"status": "active",
"suppliers": submission_data["tenderers"],
"milestones": [first_milestone_data],
}
new_contracts = deepcopy(agreement_data.get("contracts", []))
new_contracts.append(contract_data)
apply_patch(self.request,
data={"contracts": new_contracts},
src=agreement_data,
obj_name="agreement")
self.LOGGER.info(
"Updated agreement {} with contract {}".format(
agreement_data["_id"], contract_id),
extra=context_unpack(self.request,
{"MESSAGE_ID": "qualification_patch"}))
def patch(self):
"""
Qualification edit(partial)
"""
qualification = self.request.context
old_status = qualification.status
new_status = self.request.validated["data"].get("status", old_status)
changed_status = old_status != new_status
if changed_status:
qualification.date = get_now()
apply_patch(self.request,
src=self.request.validated["qualification_src"],
obj_name="qualification")
self.LOGGER.info(
"Updated qualification {}".format(qualification.id),
extra=context_unpack(self.request,
{"MESSAGE_ID": "qualification_patch"}))
if changed_status:
self.complete_submission()
if old_status == "pending" and new_status == "active":
self.ensure_agreement()
self.create_agreement_contract()
return {"data": qualification.serialize("view")}
def patch(self):
agreement = self.context
apply_patch(self.request,
obj_name="agreement",
save=False,
src=self.request.validated["agreement_src"])
if save_agreement(self.request):
self.LOGGER.info(
"Updated agreement {}".format(agreement.id),
extra=context_unpack(self.request,
{"MESSAGE_ID": "agreement_patch"}),
)
return {"data": agreement.serialize("view")}
def test_apply_patch(self, mocked_apply_data_patch, mocked_save_framework):
request = MagicMock()
data = deepcopy(test_framework_data)
request.validated = {"data": data, "framework": data}
mocked_save_framework.return_value = True
request.context.serialize.return_value = data
res = apply_patch(request, "framework")
self.assertTrue(res)
mocked_apply_data_patch.return_value = data
res = apply_patch(request, "framework")
self.assertEqual(res, data)
def update_agreement(self):
framework = self.request.validated["framework"]
updated_agreement_data = {
"period": {
"startDate": self.request.validated["agreement_src"]["period"]["startDate"],
"endDate": framework.qualificationPeriod.endDate.isoformat()
},
"procuringEntity": framework.procuringEntity
}
apply_patch(
self.request, src=self.request.validated["agreement_src"], data=updated_agreement_data, obj_name="agreement"
)
self.LOGGER.info("Updated agreement {}".format(self.request.validated["agreement_src"]["id"]),
extra=context_unpack(self.request, {"MESSAGE_ID": "framework_patch"}))
def test_apply_patch(self, mocked_apply_data_patch, mocked_save_agreement):
request = MagicMock()
agreement = MagicMock()
agreement.__class__ = Agreement
data = deepcopy(TEST_AGREEMENT)
request.validated = {"data": data, "agreement": agreement}
mocked_save_agreement.return_value = True
request.context.serialize.return_value = data
res = apply_patch(request, "agreement")
self.assertTrue(res)
mocked_apply_data_patch.return_value = data
res = apply_patch(request, "agreement")
self.assertEqual(res, data)
def complete_submission(self):
db = self.request.registry.db
qualification = self.request.validated["qualification"]
submission_data = get_submission_by_id(db, qualification.submissionID)
submission = Submission(submission_data)
self.request.validated["submission_src"] = submission.serialize(
"plain")
submission.status = "complete"
self.request.validated["submission"] = submission
apply_patch(self.request,
src=self.request.validated["submission_src"],
obj_name="submission")
self.LOGGER.info("Updated submission {}".format(submission.id),
extra=context_unpack(
self.request, {"MESSAGE_ID": "submission_patch"}))
def create_agreement_contract(self):
qualification = self.request.validated["qualification"]
framework = self.request.validated["framework"]
agreement_data = get_agreement_by_id(self.request,
framework.agreementID)
if not agreement_data:
raise_operation_error(
self.request,
"agreementID must be one of exists agreement",
)
submission_data = get_submission_by_id(self.request,
qualification.submissionID)
if not agreement_data:
raise_operation_error(
self.request,
"submissionID must be one of exists submission",
)
if agreement_data["status"] != "active":
return
contract_id = generate_id()
first_milestone_data = {
"type": "activation",
"dueDate": framework.get("qualificationPeriod").get("endDate")
}
contract_data = {
"id": contract_id,
"qualificationID": qualification.id,
"submissionID": submission_data["_id"],
"status": "active",
"suppliers": submission_data["tenderers"],
"milestones": [first_milestone_data],
}
new_contracts = deepcopy(agreement_data.get("contracts", []))
new_contracts.append(contract_data)
apply_patch(self.request,
data={"contracts": new_contracts},
src=agreement_data,
obj_name="agreement")
self.LOGGER.info(
"Updated agreement {} with contract {}".format(
agreement_data["_id"], contract_id),
extra=context_unpack(self.request,
{"MESSAGE_ID": "qualification_patch"}))
def patch(self):
contract = self.request.validated["contract"]
if apply_patch(self.request, "agreement", src=contract.to_primitive()):
self.LOGGER.info(
f"Updated contract {contract.id}",
extra=context_unpack(self.request,
{"MESSAGE_ID": "contract_patch"}),
)
return {"data": contract.serialize("view")}
def patch(self):
if self.request.authenticated_role == "chronograph":
if not check_agreement_status(self.request):
check_contract_statuses(self.request)
if apply_patch(self.request,
obj_name="agreement",
data=self.request.validated["agreement"].to_primitive(),
src=self.request.validated["agreement_src"]):
self.LOGGER.info(
f"Updated agreement {self.request.validated['agreement'].id}",
extra=context_unpack(self.request,
{"MESSAGE_ID": "agreement_patch"}))
return {"data": self.request.context.serialize("view")}
def patch(self):
# PATCH now working only for milestone type `activation`
milestone = self.request.context
apply_patch(self.request,
obj_name="agreement",
save=False,
src=milestone.to_primitive())
if milestone.status == "met":
contract = self.request.validated["contract"]
contract.status = "terminated"
for i in contract.milestones:
if i.status == 'scheduled':
i.status = 'notMet'
if save_agreement(self.request, additional_obj_names=("milestone", )):
self.LOGGER.info(
f"Updated milestone {milestone.id}",
extra=context_unpack(self.request,
{"MESSAGE_ID": "milestone_patch"}),
)
return {"data": milestone.serialize("view")}
def collection_post(self):
milestone = self.request.validated["milestone"]
self.request.context.date = milestone.dateModified
self.request.context.milestones.append(milestone)
upload_objects_documents(
self.request,
milestone,
route_kwargs={"milestone_id": milestone.id},
)
if apply_patch(
self.request,
obj_name="agreement",
data={"status": MILESTONE_CONTRACT_STATUSES[milestone.type]},
src=self.request.validated["contract"].to_primitive()):
self.request.response.status = 201
return {"data": milestone.serialize("view")}
def patch(self):
"""Framework Edit (partial)
.. sourcecode:: http
PATCH /frameworks/40b48e4878534db1bf228d5928f8f1d9?acc_token=7c6a46e300bb41438ef626232028950b HTTP/1.1
Host: example.com
Accept: application/json
{
"data": {
"qualificationPeriod": {
"endDate": "2021-02-22T14:33:22.129267+02:00"
},
"procuringEntity": {
"contactPoint": {
"email": "*****@*****.**",
"name": "зміна",
"telephone": "0440000002"
}
},
"description": "Назва предмета закупівлі1"
}
}
And here is the response to be expected:
.. sourcecode:: http
HTTP/1.0 200 OK
Content-Type: application/json
{
"data": {
"status": "active",
"description": "Назва предмета закупівлі1",
"classification": {
"scheme": "ДК021",
"description": "Mustard seeds",
"id": "03111600-8"
},
"title": "updated in draft status",
"enquiryPeriod": {
"startDate": "2020-09-08T01:00:00+03:00",
"endDate": "2020-09-23T00:00:00+03:00"
},
"qualificationPeriod": {
"startDate": "2020-09-23T00:00:00+03:00",
"endDate": "2021-02-22T14:33:22.129267+02:00"
},
"prettyID": "UA-F-2020-09-08-000001",
"period": {
"startDate": "2020-09-08T01:00:00+03:00",
"endDate": "2021-01-23T00:00:00+02:00"
},
"frameworkType": "electronicCatalogue",
"date": "2020-09-08T01:00:00+03:00",
"additionalClassifications": [
{
"scheme": "ДК003",
"id": "17.21.1",
"description": "папір і картон гофровані, паперова й картонна тара"
}
],
"next_check": "2020-10-07T00:00:00+03:00",
"procuringEntity": {
"contactPoint": {
"email": "*****@*****.**",
"telephone": "0440000002",
"name": "зміна"
},
"identifier": {
"scheme": "UA-EDR",
"id": "40996564",
"legalName": "Назва організації(ЦЗО)"
},
"name": "Повна назва юридичної організації.",
"kind": "central",
"address": {
"countryName": "Україна",
"postalCode": "01220",
"streetAddress": "вул. Банкова, 11, корпус 1",
"region": "м. Київ",
"locality": "м. Київ"
}
},
"owner": "broker",
"dateModified": "2020-09-08T01:00:00+03:00",
"id": "40b48e4878534db1bf228d5928f8f1d9"
}
}
"""
framework = self.context
if self.request.authenticated_role == "chronograph":
check_status(self.request)
save_framework(self.request)
else:
if self.request.validated["data"].get("status") not in ("draft",
"active"):
raise_operation_error(
self.request, "Can't switch to {} status".format(
self.request.validated["data"].get("status")))
if self.request.validated["data"].get("status") == "active":
model = self.request.context._fields["qualificationPeriod"]
calculate_framework_periods(self.request, model)
validate_qualification_period_duration(self.request, model)
apply_patch(self.request,
src=self.request.validated["framework_src"],
obj_name="framework")
self.LOGGER.info("Updated framework {}".format(framework.id),
extra=context_unpack(
self.request, {"MESSAGE_ID": "framework_patch"}))
# TODO: Change to chronograph_view for chronograph
return {"data": framework.serialize(framework.status)}
def apply(self, request, **kwargs):
return apply_patch(request, "agreement", **kwargs)
def apply(self, request, **kwargs):
return apply_patch(request, "agreement", additional_obj_names=("milestone",), **kwargs)
def ensure_agreement(self):
framework_data = self.request.validated["framework_src"]
agreementID = framework_data.get("agreementID")
if agreementID:
agreement = get_agreement_by_id(self.request, agreementID)
if not agreement:
raise_operation_error(
self.request,
"agreementID must be one of exists agreement",
)
self.request.validated["agreement"] = agreement = Agreement(
agreement)
agreement.__parent__ = self.request.validated[
"qualification"].__parent__
self.request.validated["agreement_src"] = agreement.serialize(
"plain")
else:
agreement_id = generate_id()
now = get_now()
transfer = generate_id()
transfer_token = sha512(transfer.encode("utf-8")).hexdigest()
agreement_data = {
"id":
agreement_id,
"agreementID":
generate_agreementID(
get_now(), self.request.registry.databases.agreements,
self.server_id),
"frameworkID":
framework_data["id"],
"agreementType":
framework_data["frameworkType"],
"status":
"active",
"period": {
"startDate":
now,
"endDate":
framework_data.get("qualificationPeriod").get("endDate")
},
"procuringEntity":
framework_data.get("procuringEntity"),
"classification":
framework_data.get("classification"),
"additionalClassifications":
framework_data.get("additionalClassifications"),
"contracts": [],
"owner":
framework_data["owner"],
"owner_token":
framework_data["owner_token"],
"mode":
framework_data.get("mode"),
"dateModified":
now,
"date":
now,
"transfer_token":
transfer_token,
"frameworkDetails":
framework_data.get("frameworkDetails"),
}
agreement = Agreement(agreement_data)
self.request.validated["agreement_src"] = {}
self.request.validated["agreement"] = agreement
if save_agreement(self.request):
self.LOGGER.info(
"Created agreement {}".format(agreement_id),
extra=context_unpack(
self.request,
{"MESSAGE_ID": "agreement_create"},
{
"agreement_id": agreement_id,
"agreement_mode": agreement.mode
},
),
)
framework_data_updated = {"agreementID": agreement_id}
apply_patch(self.request,
data=framework_data_updated,
src=self.request.validated["framework_src"],
obj_name="framework")
self.LOGGER.info(
"Updated framework {} with agreementID".format(
framework_data["id"]),
extra=context_unpack(
self.request, {"MESSAGE_ID": "qualification_patch"}))
def apply(self, request, **kwargs):
return apply_patch(request, self.context_short_name, **kwargs)
