def test_context_unpack(self):
request = mock.MagicMock()
request.logging_context = {"A": 'b'}
msg = {'MESSAGE_ID': 'test'}
expected_result = {'JOURNAL_A': 'b', 'MESSAGE_ID': 'test'}
result = context_unpack(request, msg)
self.assertAlmostEqual(result, expected_result)
expected_result = {
'JOURNAL_C': 'd',
'JOURNAL_A': 'b',
'MESSAGE_ID': 'test'
}
result = context_unpack(request, msg, {'c': 'd'})
self.assertAlmostEqual(result, expected_result)
def patch(self):
asset = self.context
apply_patch(self.request, src=self.request.validated['asset_src'])
self.LOGGER.info('Updated asset {}'.format(asset.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'asset_patch'}))
return {'data': asset.serialize(asset.status)}
def post(self):
"""This API request is targeted to creating new Lot."""
lot_id = generate_id()
lot = self.request.validated['lot']
lot.id = lot_id
if not lot.get('lotID'):
lot.lotID = generate_lot_id(get_now(), self.db, self.server_id)
self.request.registry.notify(LotInitializeEvent(lot))
if self.request.json_body['data'].get('status') == 'draft':
lot.status = 'draft'
set_ownership(lot, self.request) # rewrite as subscriber?
self.request.validated['lot'] = lot
self.request.validated['lot_src'] = {}
if save_lot(self.request):
self.LOGGER.info('Created lot {} ({})'.format(lot_id, lot.lotID),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'lot_create'},
{
'lot_id': lot_id,
'lotID': lot.lotID
}))
self.request.response.status = 201
self.request.response.headers['Location'] = self.request.route_url(
'{}:Lot'.format(lot.lotType), lot_id=lot_id)
return {
'data': lot.serialize(lot.status),
'access': {
'token': lot.owner_token
}
}
def post(self):
"""This API request is targeted to creating new Lot."""
lot_id = generate_id()
lot = self.request.validated['lot']
lot.id = lot_id
if not lot.get('lotID'):
lot.lotID = generate_lot_id(get_now(), self.db, self.server_id)
self.request.registry.notify(LotInitializeEvent(lot))
default_status = type(lot).fields['status'].default
status = self.request.json_body['data'].get('status', default_status)
if status == 'draft':
lot.status = status
else:
self.request.errors.add('body', 'status',
'You can create only in draft status')
self.request.errors.status = 403
return
acc = set_ownership(lot, self.request)
self.request.validated['lot'] = lot
self.request.validated['lot_src'] = {}
if save_lot(self.request):
self.LOGGER.info('Created lot {} ({})'.format(lot_id, lot.lotID),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'lot_create'},
{
'lot_id': lot_id,
'lotID': lot.lotID
}))
self.request.response.status = 201
self.request.response.headers['Location'] = self.request.route_url(
'{}:Lot'.format(lot.lotType), lot_id=lot_id)
return {'data': lot.serialize(lot.status), 'access': acc}
def post(self):
"""This API request is targeted to creating new Asset."""
asset_id = generate_id()
asset = self.request.validated['asset']
asset.id = asset_id
if not asset.get('assetID'):
asset.assetID = generate_asset_id(get_now(), self.db,
self.server_id)
self.request.registry.notify(AssetInitializeEvent(asset))
if self.request.json_body['data'].get('status') == 'draft':
asset.status = 'draft'
acc = set_ownership(asset, self.request)
self.request.validated['asset'] = asset
self.request.validated['asset_src'] = {}
if save_asset(self.request):
self.LOGGER.info(
'Created asset {} ({})'.format(asset_id, asset.assetID),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'asset_create'}, {
'asset_id': asset_id,
'assetID': asset.assetID
}))
self.request.response.status = 201
self.request.response.headers['Location'] = self.request.route_url(
'{}:Asset'.format(asset.assetType), asset_id=asset_id)
return {'data': asset.serialize(asset.status), 'access': acc}
def patch(self):
lot = self.context
apply_patch(self.request, src=self.request.validated['lot_src'])
self.LOGGER.info(
'Updated lot {}'.format(lot.id),
extra=context_unpack(self.request, {'MESSAGE_ID': 'lot_patch'})
)
return {'data': lot.serialize(lot.status)}
def patch(self):
"""Asset Document Update"""
if apply_patch(self.request, src=self.request.context.serialize()):
update_file_content_type(self.request)
self.LOGGER.info(
'Updated asset document {}'.format(self.request.context.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'asset_document_patch'}))
return {'data': self.request.context.serialize("view")}
def put(self):
"""Asset Document Update"""
document = self.request.validated['document']
self.request.validated['asset'].documents.append(document)
if save_asset(self.request):
self.LOGGER.info(
'Updated asset document {}'.format(self.request.context.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'asset_document_put'}))
return {'data': document.serialize("view")}
def collection_post(self):
"""Asset Document Upload"""
document = self.request.validated['document']
document.author = self.request.authenticated_role
self.context.documents.append(document)
if save_asset(self.request):
self.LOGGER.info(
'Created asset document {}'.format(document.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'asset_document_create'},
{'document_id': document.id}))
self.request.response.status = 201
document_route = self.request.matched_route.name.replace(
"collection_", "")
self.request.response.headers[
'Location'] = self.request.current_route_url(
_route_name=document_route,
document_id=document.id,
_query={})
return {'data': document.serialize("view")}
return dict([(i, lot_data.get(i, '')) for i in ['lotType', 'dateModified', 'id']])
return dict([(i, j) for i, j in lot.serialize(lot.status).items() if i in fields])
def save_lot(request):
lot = request.validated['lot']
if lot.mode == u'test':
set_modetest_titles(lot)
patch = get_revision_changes(lot.serialize("plain"), request.validated['lot_src'])
if patch:
revision = prepare_revision(lot, patch, request.authenticated_userid)
lot.revisions.append(type(lot).revisions.model_class(revision))
old_dateModified = lot.dateModified
if getattr(lot, 'modified', True):
lot.dateModified = get_now()
try:
lot.store(request.registry.db)
except ModelValidationError, e:
for i in e.message:
request.errors.add('body', i, e.message[i])
request.errors.status = 422
except ResourceConflict, e: # pragma: no cover
request.errors.add('body', 'data', str(e))
request.errors.status = 409
except Exception, e: # pragma: no cover
request.errors.add('body', 'data', str(e))
else:
LOGGER.info('Saved lot {}: dateModified {} -> {}'.format(lot.id, old_dateModified and old_dateModified.isoformat(), lot.dateModified.isoformat()),
extra=context_unpack(request, {'MESSAGE_ID': 'save_lot'}, {'RESULT': lot.rev}))
return True
patch.append({"op": "remove", "path": date_path})
obj.date = now
asset.revisions.append(
type(asset).revisions.model_class({
'author': request.authenticated_userid,
'changes': patch,
'rev': asset.rev
}))
old_dateModified = asset.dateModified
if getattr(asset, 'modified', True):
asset.dateModified = now
try:
asset.store(request.registry.db)
except ModelValidationError, e:
for i in e.message:
request.errors.add('body', i, e.message[i])
request.errors.status = 422
except ResourceConflict, e: # pragma: no cover
request.errors.add('body', 'data', str(e))
request.errors.status = 409
except Exception, e: # pragma: no cover
request.errors.add('body', 'data', str(e))
else:
LOGGER.info('Saved asset {}: dateModified {} -> {}'.format(
asset.id, old_dateModified and old_dateModified.isoformat(),
asset.dateModified.isoformat()),
extra=context_unpack(request,
{'MESSAGE_ID': 'save_asset'},
{'RESULT': asset.rev}))
return True
