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 test_patch_to_active(self):
self.app.authorization = ('Basic', (self.sas_name, self.sas_pass))
context = self.acceleration if SANDBOX_MODE else {}
accelerator = get_monitoring_accelerator(context)
now_date = datetime.now(TZ)
if accelerator:
end_date = calc_datetime(
now_date,
MONITORING_TIME,
accelerator=accelerator
)
else:
end_date = calc_working_datetime(
now_date,
MONITORING_TIME,
midnight=True,
calendar=WORKING_DAYS
)
response = self.app.patch_json(
'/monitorings/{}'.format(self.monitoring_id),
{"data": {
"status": "active",
"decision": {
"description": "text",
"date": (now_date - timedelta(days=2)).isoformat()
}
}}
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['data']["status"], "active")
self.assertEqual(response.json['data']["monitoringPeriod"]["startDate"], now_date.isoformat())
self.assertEqual(response.json['data']["dateModified"], now_date.isoformat())
self.assertEqual(response.json['data']["monitoringPeriod"]["endDate"], end_date.isoformat())
self.assertEqual(response.json['data']["endDate"], end_date.isoformat())
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_no_acceleration(self):
self.assertEqual(get_monitoring_accelerator({}), 0)
def test_acceleration_value(self):
self.assertEqual(
get_monitoring_accelerator({'monitoringDetails': 'accelerator=2'}),
2)
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')}
