def test_success_post_resolution_without_report(self):
self.app.authorization = ('Basic', (self.sas_name, self.sas_pass))
response = self.app.get('/monitorings/{}'.format(self.monitoring_id))
conclusion_published = response.json["data"]["conclusion"][
"datePublished"]
allow_post_since = calculate_normalized_business_date(
parse_date(conclusion_published), RESOLUTION_WAIT_PERIOD)
request_data = self.get_elimination_resolution()
with freeze_time(allow_post_since):
response = self.app.patch_json(
'/monitorings/{}'.format(self.monitoring_id),
{"data": {
"eliminationResolution": request_data,
}},
)
resolution = response.json["data"]["eliminationResolution"]
self.assertEqual(resolution["result"], request_data["result"])
self.assertEqual(resolution["resultByType"],
request_data["resultByType"])
self.assertEqual(resolution["description"],
request_data["description"])
self.assertEqual(resolution["dateCreated"],
allow_post_since.isoformat())
self.assertEqual(len(resolution["documents"]),
len(request_data["documents"]))
def validate_posting_elimination_resolution(request):
monitoring = request.validated['monitoring']
monitoring.eliminationResolution.datePublished = monitoring.eliminationResolution.dateCreated
if not monitoring.eliminationReport:
accelerator = get_monitoring_accelerator(request.context)
allow_post_since = calculate_normalized_business_date(
monitoring.conclusion.datePublished, RESOLUTION_WAIT_PERIOD,
accelerator)
if get_now() < allow_post_since:
raise_operation_error(
request,
"Can't post eliminationResolution without eliminationReport "
"earlier than {} business days since conclusion.datePublished".
format(RESOLUTION_WAIT_PERIOD.days))
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')}
def test_ends_after_non_working(self):
date = datetime(2018, 1, 2, 12, 0, 0, tzinfo=TZ)
result = calculate_normalized_business_date(date, timedelta(days=4))
self.assertEqual(result, datetime(2018, 1, 10, 0, 0, 0, tzinfo=TZ))
def test_starts_on_non_working_before_non_working(self):
date = datetime(2017, 12, 31, 12, 0, 0, tzinfo=TZ)
result = calculate_normalized_business_date(date, timedelta(days=1))
self.assertEqual(result, datetime(2018, 1, 3, 0, 0, 0, tzinfo=TZ))
def patch(self):
monitoring = self.request.validated['monitoring']
monitoring_old_status = monitoring.status
elimination_resolution = monitoring.eliminationResolution
apply_patch(self.request,
save=False,
src=self.request.validated['monitoring_src'])
now = get_now()
if monitoring_old_status == DRAFT_STATUS and monitoring.status == ACTIVE_STATUS:
set_author(monitoring.decision.documents, self.request, 'author')
accelerator = get_monitoring_accelerator(self.context)
monitoring.monitoringPeriod = generate_period(
now, MONITORING_TIME, accelerator)
monitoring.decision.datePublished = now
monitoring.endDate = calculate_normalized_business_date(
now, MONITORING_TIME, accelerator)
elif monitoring_old_status == ACTIVE_STATUS and monitoring.status == ADDRESSED_STATUS:
set_author(monitoring.conclusion.documents, self.request, 'author')
accelerator = get_monitoring_accelerator(self.context)
monitoring.conclusion.datePublished = now
monitoring.eliminationPeriod = generate_period(
now, ELIMINATION_PERIOD_TIME, accelerator)
elif monitoring_old_status == ACTIVE_STATUS and monitoring.status == DECLINED_STATUS:
accelerator = get_monitoring_accelerator(self.context)
monitoring.eliminationPeriod = generate_period(
now, ELIMINATION_PERIOD_NO_VIOLATIONS_TIME, accelerator)
monitoring.conclusion.datePublished = now
elif any([
monitoring_old_status == DRAFT_STATUS
and monitoring.status == CANCELLED_STATUS,
monitoring_old_status == ACTIVE_STATUS
and monitoring.status == STOPPED_STATUS,
monitoring_old_status == DECLINED_STATUS
and monitoring.status == STOPPED_STATUS,
monitoring_old_status == ADDRESSED_STATUS
and monitoring.status == STOPPED_STATUS
]):
set_author(monitoring.cancellation.documents, self.request,
'author')
monitoring.cancellation.datePublished = now
if not elimination_resolution and monitoring.eliminationResolution:
validate_posting_elimination_resolution(self.request)
monitoring.eliminationResolution.datePublished = monitoring.eliminationResolution.dateCreated
# download (change urls of) documents for Decision, Conclusion, etc.
raw_data = self.request.json.get("data", {})
for key in raw_data.keys():
if hasattr(getattr(monitoring, key, None),
"documents") and "documents" in raw_data[key]:
upload_objects_documents(self.request,
getattr(monitoring, key),
key=key)
save_monitoring(self.request, date_modified=now)
LOGGER.info('Updated monitoring {}'.format(monitoring.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'monitoring_patch'}))
return {'data': monitoring.serialize('view')}