def patch_decisions_with_lot_by_broker(self):
self.app.authorization = ('Basic', ('broker', ''))
self.initial_status = 'draft'
self.create_resource(with_decisions=False)
decision_data = [
{
'decisionID': 'decID',
'decisionDate': get_now().isoformat()
},
{
'decisionID': 'decID2',
'decisionDate': get_now().isoformat()
}
]
decision_data = {
'decisions': decision_data
}
response = self.app.patch_json(
'/{}'.format(self.resource_id),
params={'data': decision_data},
headers=self.access_header
)
self.assertNotIn('decisions', response.json)
def rectificationPeriod_serializable(self):
if self.status == 'pending' and not self.rectificationPeriod:
self.rectificationPeriod = type(self).rectificationPeriod.model_class()
self.rectificationPeriod.startDate = get_now()
self.rectificationPeriod.endDate = calculate_business_date(self.rectificationPeriod.startDate,
RECTIFICATION_PERIOD_DURATION,
None)
def create_decisions_with_asset(self):
data = deepcopy(self.initial_data)
decision_1 = {'id': '1' * 32, 'decisionID': 'decID', 'decisionDate': get_now().isoformat()}
decision_2 = deepcopy(decision_1)
decision_2['id'] = '2' * 32
data['decisions'] = [
decision_1, decision_2
]
response = self.app.post_json('/', params={'data': data})
decision_1['decisionOf'] = 'asset'
decision_2['decisionOf'] = 'asset'
self.assertEqual(response.status, '201 Created')
self.assertEqual(len(response.json['data']['decisions']), 2)
self.assertEqual(response.json['data']['decisions'][0], decision_1)
self.assertEqual(response.json['data']['decisions'][1], decision_2)
del decision_1['decisionOf']
del decision_2['decisionOf']
decision_2['id'] = '1' * 32
data['decisions'] = [
decision_1, decision_2
]
response = self.app.post_json('/', params={'data': data}, status=422)
self.assertEqual(response.status, '422 Unprocessable Entity')
self.assertEqual(
response.json['errors'][0]['description'][0],
u'Decision id should be unique for all decisions'
)
def rectificationPeriod_workflow(self):
rectificationPeriod = Period()
rectificationPeriod.startDate = get_now() - timedelta(3)
rectificationPeriod.endDate = calculate_business_date(rectificationPeriod.startDate,
timedelta(1),
None)
asset = self.create_resource()
response = self.app.get('/{}'.format(asset['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], asset['id'])
# Change rectification period in db
fromdb = self.db.get(asset['id'])
fromdb = self.asset_model(fromdb)
fromdb.status = 'pending'
fromdb.rectificationPeriod = rectificationPeriod
fromdb = fromdb.store(self.db)
self.assertEqual(fromdb.id, asset['id'])
response = self.app.get('/{}'.format(asset['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], asset['id'])
response = self.app.patch_json('/{}'.format(asset['id']),
headers=self.access_header,
params={'data': {'title': ' PATCHED'}})
self.assertNotEqual(response.json['data']['title'], 'PATCHED')
self.assertEqual(asset['title'], response.json['data']['title'])
add_cancellationDetails_document(self, asset)
check_patch_status_200(self, asset['id'], 'deleted', self.access_header)
def create_resource(self, extra=None, auth=None, with_decisions=True):
resource = super(BaseAssetWebTest, self).create_resource(extra, auth)
if with_decisions:
current_status = resource['status']
self.set_status('pending')
response = self.app.get('/{}'.format(self.resource_id))
old_decs_count = len(response.json['data'].get('decisions', []))
decision_data = {
'decisionDate': get_now().isoformat(),
'decisionID': 'decisionLotID'
}
response = self.app.post_json('/{}/decisions'.format(
self.resource_id), {"data": decision_data},
headers=self.access_header)
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.json['data']['decisionDate'],
decision_data['decisionDate'])
self.assertEqual(response.json['data']['decisionID'],
decision_data['decisionID'])
self.decision_id = response.json['data']['id']
self.set_status(current_status)
response = self.app.get('/{}'.format(self.resource_id))
present_decs_count = len(response.json['data'].get(
'decisions', []))
self.assertEqual(old_decs_count + 1, present_decs_count)
resource = response.json['data']
return resource
def rectificationPeriod_item_workflow(self):
rectificationPeriod = Period()
rectificationPeriod.startDate = get_now() - timedelta(3)
rectificationPeriod.endDate = calculate_business_date(
rectificationPeriod.startDate, timedelta(1), None)
asset = self.create_resource()
response = self.app.post_json('/{}/items'.format(asset['id']),
headers=self.access_header,
params={'data': self.initial_item_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
item_id = response.json["data"]['id']
self.assertIn(item_id, response.headers['Location'])
self.assertEqual(self.initial_item_data['description'],
response.json["data"]["description"])
self.assertEqual(self.initial_item_data['quantity'],
response.json["data"]["quantity"])
self.assertEqual(self.initial_item_data['address'],
response.json["data"]["address"])
item_id = response.json['data']['id']
response = self.app.get('/{}'.format(asset['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], asset['id'])
# Change rectification period in db
fromdb = self.db.get(asset['id'])
fromdb = Asset(fromdb)
fromdb.status = 'pending'
fromdb.rectificationPeriod = rectificationPeriod
fromdb = fromdb.store(self.db)
self.assertEqual(fromdb.id, asset['id'])
response = self.app.get('/{}'.format(asset['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], asset['id'])
response = self.app.post_json('/{}/items'.format(asset['id']),
headers=self.access_header,
params={'data': self.initial_item_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change items after rectification period')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change items after rectification period')
response = self.app.patch_json('/{}/items/{}'.format(asset['id'], item_id),
headers=self.access_header,
params={'data': self.initial_item_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change items after rectification period')
def rectificationPeriod_item_validation(request, error_handler, **kwargs):
asset = request.context if 'documents' in request.context else request.context.__parent__
if asset.rectificationPeriod and asset.rectificationPeriod.endDate < get_now(
):
request.errors.add(
'body', 'mode',
'You can\'t change items after rectification period')
request.errors.status = 403
raise error_handler(request)
def dateModified_resource(self):
response = self.app.get('/')
self.assertEqual(response.status, '200 OK')
self.assertEqual(len(response.json['data']), 0)
response = self.app.post_json('/', {'data': self.initial_data})
self.assertEqual(response.status, '201 Created')
resource = response.json['data']
token = str(response.json['access']['token'])
dateModified = resource['dateModified']
response = self.app.get('/{}'.format(resource['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['data']['dateModified'], dateModified)
# Add decision
response = self.app.get('/{}'.format(resource['id']))
old_decs_count = len(response.json['data'].get('decisions', []))
decision_data = {
'decisionDate': get_now().isoformat(),
'decisionID': 'decisionLotID'
}
response = self.app.post_json('/{}/decisions'.format(resource['id']),
{"data": decision_data},
headers={'X-Access-Token': token})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.json['data']['decisionDate'],
decision_data['decisionDate'])
self.assertEqual(response.json['data']['decisionID'],
decision_data['decisionID'])
response = self.app.get('/{}'.format(resource['id']))
present_decs_count = len(response.json['data'].get('decisions', []))
self.assertEqual(old_decs_count + 1, present_decs_count)
resource = response.json['data']
response = self.app.patch_json('/{}'.format(resource['id']),
headers={'X-Access-Token': token},
params={'data': {
'status': 'pending'
}})
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['data']['status'], 'pending')
self.assertNotEqual(response.json['data']['dateModified'], dateModified)
resource = response.json['data']
dateModified = resource['dateModified']
response = self.app.get('/{}'.format(resource['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['data'], resource)
self.assertEqual(response.json['data']['dateModified'], dateModified)
def status_change_depending_actions(request):
current_status = request.context.status
new_status = request.validated['data'].get('status')
if current_status == 'active' and new_status == 'pending':
request.context.rectificationPeriod.endDate = None
request.validated['data']['rectificationPeriod'] = {}
request.validated['data']['rectificationPeriod']['endDate'] = None
elif current_status == 'verification' and new_status == 'active':
request.context.rectificationPeriod.endDate = get_now()
request.validated['data']['rectificationPeriod'] = {}
request.validated['data']['rectificationPeriod'][
'endDate'] = request.context.rectificationPeriod.endDate
def get_role(self):
root = self.__parent__
request = root.request
if request.authenticated_role == 'Administrator':
role = 'Administrator'
elif request.authenticated_role == 'concierge':
role = 'concierge'
else:
after_rectificationPeriod = bool(
request.context.rectificationPeriod
and request.context.rectificationPeriod.endDate < get_now())
if request.context.status == 'pending' and after_rectificationPeriod:
return 'edit_pendingAfterRectificationPeriod'
role = 'edit_{}'.format(request.context.status)
return role
def rectificationPeriod_document_validation(request, error_handler, **kwargs):
asset = request.context if 'documents' in request.context else request.context.__parent__
is_period_ended = bool(asset.rectificationPeriod
and asset.rectificationPeriod.endDate < get_now())
if (is_period_ended and request.validated['document'].documentType !=
'cancellationDetails') and request.method == 'POST':
request.errors.add(
'body', 'mode',
'You can add only document with cancellationDetails after rectification period'
)
request.errors.status = 403
raise error_handler(request)
if is_period_ended and request.method in ['PUT', 'PATCH']:
request.errors.add(
'body', 'mode',
'You can\'t change documents after rectification period')
request.errors.status = 403
raise error_handler(request)
def create_or_patch_decision_in_not_allowed_status(self):
self.app.authorization = ('Basic', ('broker', ''))
self.initial_status = 'draft'
self.create_resource()
check_patch_status_200(self, self.resource_id, 'pending', self.access_header)
self.app.authorization = ('Basic', ('concierge', ''))
check_patch_status_200(self, self.resource_id, 'verification', self.access_header)
self.app.authorization = ('Basic', ('broker', ''))
decision_data = {
'decisionDate': get_now().isoformat(),
'decisionID': 'decisionLotID'
}
response = self.app.post_json(
'/{}/decisions'.format(self.resource_id),
{"data": decision_data},
headers=self.access_header,
status=403
)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(
response.json['errors'][0]['description'],
'Can\'t update decisions in current (verification) asset status'
)
response = self.app.patch_json(
'/{}/decisions/{}'.format(self.resource_id, self.decision_id),
{"data": decision_data},
headers=self.access_header,
status=403
)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(
response.json['errors'][0]['description'],
'Can\'t update decisions in current (verification) asset status'
)
def tender_init_handler(event):
""" initialization handler for compound assets """
event.asset.date = get_now()
def tender_init_handler(event):
""" initialization handler for claimRights assets """
event.asset.date = get_now()
test_item_data = deepcopy(test_loki_item_data)
del test_item_data['id']
# test_loki_item_data['schema_properties'] = schema_properties
asset_type = os.environ.get('ASSET_TYPE', 'bounce')
test_asset_bounce_data = {
"title": u"Земля для космодрому",
"description": u"Опис землі для космодрому",
"assetType": asset_type,
"items": [test_item_data, test_item_data],
"assetCustodian": deepcopy(test_organization_loki)
}
test_asset_bounce_data_schema_0 = {
"title": u"Земля для космодрому-0",
"description": u"Опис землі для космодрому",
"assetType": asset_type,
"items": [test_item_data, test_item_data],
"assetCustodian": deepcopy(test_organization_loki),
}
if SANDBOX_MODE:
test_asset_bounce_data[
'sandboxParameters'] = 'quick, accelerator={}'.format(
DEFAULT_ACCELERATION)
test_decision_data = {
'decisionDate': get_now().isoformat(),
'decisionID': '1111-4'
}
def rectificationPeriod_endDate_remove(self):
data = deepcopy(self.initial_data)
data['items'] = [deepcopy(test_loki_item_data)]
response = self.app.post_json('/', params={'data': data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['data']['status'], 'draft')
asset = response.json['data']
token = response.json['access']['token']
access_header = {'X-Access-Token': str(token)}
# Add decision
decision_data = {
'decisionDate': get_now().isoformat(),
'decisionID': 'decisionLotID'
}
response = self.app.post_json('/{}/decisions'.format(asset['id']),
{"data": decision_data},
headers=access_header)
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.json['data']['decisionDate'],
decision_data['decisionDate'])
self.assertEqual(response.json['data']['decisionID'],
decision_data['decisionID'])
self.decision_id = response.json['data']['id']
response = self.app.patch_json('/{}'.format(asset['id']),
params={'data': {
'status': 'pending'
}},
headers=access_header)
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertIn('startDate', response.json['data']['rectificationPeriod'])
self.assertNotIn('endDate', response.json['data']['rectificationPeriod'])
rectificationPeriod_startDate = response.json['data'][
'rectificationPeriod']['startDate']
self.app.authorization = ('Basic', ('concierge', ''))
check_patch_status_200(self, asset['id'], 'verification')
check_patch_status_200(self,
asset['id'],
'active',
extra_data={'relatedLot': uuid4().hex})
response = self.app.get('/{}'.format(asset['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.json['data']['rectificationPeriod']['startDate'],
rectificationPeriod_startDate)
self.assertIn('endDate', response.json['data']['rectificationPeriod'])
self.app.authorization = ('Basic', ('administrator', ''))
response = self.app.patch_json(
'/{}'.format(asset['id']),
params={'data': {
'rectificationPeriod': {
'endDate': None
}
}},
)
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertIn('startDate', response.json['data']['rectificationPeriod'])
self.assertNotIn('endDate', response.json['data']['rectificationPeriod'])
response = self.app.get('/{}'.format(asset['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.content_type, 'application/json')
self.assertIn('startDate', response.json['data']['rectificationPeriod'])
self.assertNotIn('endDate', response.json['data']['rectificationPeriod'])
def rectificationPeriod_document_workflow(self):
rectificationPeriod = Period()
rectificationPeriod.startDate = get_now() - timedelta(3)
rectificationPeriod.endDate = calculate_business_date(
rectificationPeriod.startDate, timedelta(1), None)
asset = self.create_resource()
response = self.app.post_json('/{}/documents'.format(self.resource_id),
headers=self.access_header,
params={'data': self.initial_document_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
doc_id = response.json["data"]['id']
response = self.app.get('/{}'.format(asset['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], asset['id'])
# Change rectification period in db
fromdb = self.db.get(asset['id'])
fromdb = Asset(fromdb)
fromdb.status = 'pending'
fromdb.rectificationPeriod = rectificationPeriod
fromdb = fromdb.store(self.db)
self.assertEqual(fromdb.id, asset['id'])
response = self.app.get('/{}'.format(asset['id']))
self.assertEqual(response.status, '200 OK')
self.assertEqual(response.json['data']['id'], asset['id'])
response = self.app.post_json('/{}/documents'.format(asset['id']),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(
response.json['errors'][0]['description'],
'You can add only document with cancellationDetails after rectification period'
)
response = self.app.patch_json('/{}/documents/{}'.format(
asset['id'], doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change documents after rectification period')
response = self.app.put_json('/{}/documents/{}'.format(
asset['id'], doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change documents after rectification period')
test_document_data = {
# 'url': self.generate_docservice_url(),
'title': u'укр.doc',
'hash': 'md5:' + '0' * 32,
'format': 'application/msword',
'documentType': 'cancellationDetails'
}
test_document_data['url'] = self.generate_docservice_url()
response = self.app.post_json('/{}/documents'.format(asset['id']),
headers=self.access_header,
params={'data': test_document_data})
self.assertEqual(response.status, '201 Created')
self.assertEqual(response.content_type, 'application/json')
doc_id = response.json["data"]['id']
response = self.app.patch_json('/{}/documents/{}'.format(
asset['id'], doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change documents after rectification period')
response = self.app.put_json('/{}/documents/{}'.format(
asset['id'], doc_id),
headers=self.access_header,
params={'data': self.initial_document_data},
status=403)
self.assertEqual(response.status, '403 Forbidden')
self.assertEqual(response.json['errors'][0]['description'],
'You can\'t change documents after rectification period')
def rectificationPeriod_serializable(self):
if self.status == 'pending' and not self.rectificationPeriod:
self.rectificationPeriod = type(
self).rectificationPeriod.model_class()
self.rectificationPeriod.startDate = get_now()
def tender_init_handler(event):
""" initialization handler for bounce assets """
asset = event.asset
asset.date = get_now()
asset.documents.append(type(asset).documents.model_class(INFORMATION_DETAILS))
