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 change_lot(self, request):
self._validate(request, self.change_validation)
if request.authenticated_role == 'chronograph':
apply_patch(request, save=False, src=request.validated['lot_src'])
check_status(request)
save_lot(request)
elif request.validated['data'].get('status') == 'pending' and not request.context.rectificationPeriod:
self._set_rectificationPeriod(request)
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):
self.request.registry.getAdapter(self.context, ILotManager).change_lot(self.request)
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):
"""Lot Contract Update"""
apply_patch(self.request, save=False, src=self.request.context.serialize())
if self.request.authenticated_role == 'caravan':
process_caravan_contract_report_result(self.request)
if save_lot(self.request):
self.LOGGER.info(
'Updated lot contract {}'.format(self.request.context.id),
extra=context_unpack(self.request, {'MESSAGE_ID': 'lot_contract_patch'})
)
return {'data': self.request.context.serialize("view")}
def change_lot(self, request):
self._validate(request, self.change_validation)
if request.authenticated_role == 'chronograph':
apply_patch(request, save=False, src=request.validated['lot_src'])
check_status(request)
save_lot(request)
elif request.validated['data'].get(
'status'
) == 'pending' and not request.context.rectificationPeriod:
self._set_rectificationPeriod(request)
if request.authenticated_role in ('concierge', 'Administrator'):
process_lot_status_change(request)
request.validated['lot_src'] = self.context.serialize('plain')
def patch(self):
"""Lot Auction Update"""
apply_patch(self.request, save=False, src=self.request.context.serialize())
if self.request.authenticated_role == 'convoy':
process_convoy_auction_report_result(self.request)
elif self.request.authenticated_role == 'concierge':
process_concierge_auction_status_change(self.request)
if save_lot(self.request):
self.LOGGER.info(
'Updated lot auction {}'.format(self.request.context.id),
extra=context_unpack(self.request, {'MESSAGE_ID': 'lot_auction_patch'})
)
return {'data': self.request.context.serialize("view")}
def patch(self):
"""Lot Auction Update"""
if apply_patch(self.request, src=self.request.context.serialize()):
self.LOGGER.info(
'Updated lot auction {}'.format(self.request.context.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'lot_auction_patch'}))
return {'data': self.request.context.serialize("view")}
def patch(self):
"""Auction Document Update"""
if apply_patch(self.request, src=self.request.context.serialize()):
update_file_content_type(self.request)
self.LOGGER.info(
'Updated auction document {}'.format(self.request.context.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'auction_document_patch'}))
return {'data': self.request.context.serialize("view")}
def patch(self):
"""Lot Decision Update"""
if apply_patch(self.request, src=self.request.context.serialize()):
update_file_content_type(self.request)
self.LOGGER.info(
'Updated lot decision {}'.format(self.request.context.id),
extra=context_unpack(self.request,
{'MESSAGE_ID': 'lot_decision_patch'}))
return {'data': self.request.context.serialize("view")}
def test_when_all_data_is_none(self, mocked_apply_data, mocked_save_lot):
self.mocked_request.validated['data'] = None
mocked_apply_data.side_effect = iter([self.patch])
self.context.serialize.side_effect = iter([self.serialized_data])
mocked_save_lot.side_effect = iter([self.saved_lot])
returned_value = apply_patch(self.mocked_request)
assert returned_value is None
assert mocked_apply_data.call_count == 0
assert self.context.import_data.call_count == 0
assert mocked_save_lot.call_count == 0
def test_when_save_is_false(self, mocked_apply_data, mocked_save_lot):
self.mocked_request.validated['data'] = 'data'
mocked_apply_data.side_effect = iter([self.patch])
self.context.serialize.side_effect = iter([self.serialized_data])
mocked_save_lot.side_effect = iter([self.saved_lot])
returned_value = apply_patch(self.mocked_request, save=False)
assert returned_value is None
assert mocked_apply_data.call_count == 1
mocked_apply_data.assert_called_with(self.serialized_data, self.mocked_request.validated['data'])
assert self.context.import_data.call_count == 1
self.context.import_data.assert_called_with(self.patch)
assert mocked_save_lot.call_count == 0
def test_when_src_is_not_none(self, mocked_apply_data, mocked_save_lot):
src = 'someSrc'
self.mocked_request.validated['data'] = 'data'
mocked_apply_data.side_effect = iter([self.patch])
self.context.serialize.side_effect = iter([self.serialized_data])
mocked_save_lot.side_effect = iter([self.saved_lot])
returned_value = apply_patch(self.mocked_request, src=src)
assert returned_value == self.saved_lot
assert mocked_apply_data.call_count == 1
mocked_apply_data.assert_called_with(src, self.mocked_request.validated['data'])
assert self.context.import_data.call_count == 1
self.context.import_data.assert_called_with(self.patch)
assert mocked_save_lot.call_count == 1
mocked_save_lot.assert_called_with(self.mocked_request)
def test_when_data_not_none(self, mocked_apply_data, mocked_save_lot):
self.mocked_request.validated = {'data': 'validatedData'}
data = 'someData'
mocked_apply_data.side_effect = iter([self.patch])
self.context.serialize.side_effect = iter([self.serialized_data])
mocked_save_lot.side_effect = iter([self.saved_lot])
returned_value = apply_patch(self.mocked_request, data=data)
assert returned_value == self.saved_lot
assert mocked_apply_data.call_count == 1
mocked_apply_data.assert_called_with(self.serialized_data, data)
assert self.context.import_data.call_count == 1
self.context.import_data.assert_called_with(self.patch)
assert mocked_save_lot.call_count == 1
mocked_save_lot.assert_called_with(self.mocked_request)
def test_with_default_args(self, mocked_apply_data, mocked_save_lot):
self.mocked_request.validated['data'] = 'data'
mocked_apply_data.side_effect = iter([self.patch])
self.context.serialize.side_effect = iter([self.serialized_data])
mocked_save_lot.side_effect = iter([self.saved_lot])
returned_value = apply_patch(self.mocked_request)
assert returned_value == self.saved_lot
assert mocked_apply_data.call_count == 1
mocked_apply_data.assert_called_with(
self.serialized_data, self.mocked_request.validated['data'])
assert self.context.import_data.call_count == 1
self.context.import_data.assert_called_with(self.patch)
assert mocked_save_lot.call_count == 1
mocked_save_lot.assert_called_with(self.mocked_request)
def update(self, request):
return apply_patch(request, src=request.context.serialize())
