def process(self, main_task, storage=None): # pylint: disable=R0911
if self.step.is_FREEZE_LOT:
lot = logic.load_lot(self.lot_id)
if not lot.state.is_ACTIVE:
main_task.comment = 'lot is not active, real state is: %s' % lot.state.name
self.state = self.STATE.WRONG_LOT_STATE
return POSTPONED_TASK_LOGIC_RESULT.ERROR
self.account_id = lot.seller_id
self.good_type = goods_types.get_type(lot.type)
self.good = lot.good
lot.state = relations.LOT_STATE.FROZEN
logic.save_lot(lot)
main_task.extend_postsave_actions(
(lambda: environment.workers.supervisor.cmd_logic_task(
self.account_id, main_task.id), ))
self.step = self.STEP.RETURN_GOOD
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_RETURN_GOOD:
hero = storage.accounts_to_heroes[self.account_id]
# TODO: save hero after receive item? and after extract too?...
self.good_type.insert_good(hero, self.good)
storage.save_bundle_data(hero.actions.current_action.bundle_id)
main_task.extend_postsave_actions(
(lambda: environment.workers.market_manager.cmd_logic_task(
self.account_id, main_task.id), ))
self.step = self.STEP.CLOSE_LOT
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_CLOSE_LOT:
lot = logic.load_lot(self.lot_id)
lot.state = relations.LOT_STATE.CLOSED_BY_TIMEOUT
lot.closed_at = datetime.datetime.now()
logic.save_lot(lot)
seller = account_prototypes.AccountPrototype.get_by_id(
lot.seller_id)
personal_messages_prototypes.MessagePrototype.create(
accounts_logic.get_system_user(), seller,
good_timeout_message(lot))
self.state = self.STATE.PROCESSED
self.step = self.STEP.SUCCESS
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
def process(self, main_task, storage=None): # pylint: disable=R0911
if self.step.is_FREEZE_LOT:
lot = logic.load_lot(self.lot_id)
if not lot.state.is_ACTIVE:
main_task.comment = 'lot is not active, real state is: %s' % lot.state.name
self.state = self.STATE.WRONG_LOT_STATE
return POSTPONED_TASK_LOGIC_RESULT.ERROR
self.account_id = lot.seller_id
self.good_type = goods_types.get_type(lot.type)
self.good = lot.good
lot.state = relations.LOT_STATE.FROZEN
logic.save_lot(lot)
main_task.extend_postsave_actions((lambda: environment.workers.supervisor.cmd_logic_task(self.account_id, main_task.id),))
self.step = self.STEP.RETURN_GOOD
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_RETURN_GOOD:
hero = storage.accounts_to_heroes[self.account_id]
# TODO: save hero after receive item? and after extract too?...
self.good_type.insert_good(hero, self.good)
storage.save_bundle_data(hero.actions.current_action.bundle_id)
main_task.extend_postsave_actions((lambda: environment.workers.market_manager.cmd_logic_task(self.account_id, main_task.id),))
self.step = self.STEP.CLOSE_LOT
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_CLOSE_LOT:
lot = logic.load_lot(self.lot_id)
lot.state = relations.LOT_STATE.CLOSED_BY_TIMEOUT
lot.closed_at = datetime.datetime.now()
logic.save_lot(lot)
seller = account_prototypes.AccountPrototype.get_by_id(lot.seller_id)
personal_messages_prototypes.MessagePrototype.create(accounts_logic.get_system_user(), seller, good_timeout_message(lot))
self.state = self.STATE.PROCESSED
self.step = self.STEP.SUCCESS
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
def test_freeze_lot__success(self):
self.invoice.state = bank_relations.INVOICE_STATE.FROZEN
self.invoice.save()
self.assertEqual(self.task.process(self.main_task),
POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertEqual(self.task.process(self.main_task),
POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertTrue(self.task.state.is_UNPROCESSED)
self.assertTrue(self.task.step.is_RECEIVE_GOOD)
lot = logic.load_lot(self.task.lot_id)
self.assertTrue(lot.state.is_FROZEN)
with mock.patch(
'the_tale.game.workers.supervisor.Worker.cmd_logic_task'
) as cmd_logic_task:
for call in self.main_task.extend_postsave_actions.call_args_list:
for func in call[0][0]:
func()
self.assertEqual(cmd_logic_task.call_count, 1)
def test_remove_lot(self):
self.invoice.state = bank_relations.INVOICE_STATE.FROZEN
self.invoice.save()
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertEqual(self.task.process(self.main_task, storage=self.logic_storage), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
with mock.patch('the_tale.finances.bank.transaction.Transaction.confirm') as confirm:
with self.check_delta(bank_prototypes.InvoicePrototype._model_class.objects.count, 1):
with self.check_new_message(self.account_1.id, [accounts_logic.get_system_user_id()]):
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.SUCCESS)
self.assertEqual(confirm.call_count, 1)
self.assertTrue(self.task.state.is_PROCESSED)
self.assertTrue(self.task.step.is_SUCCESS)
lot = logic.load_lot(self.task.lot_id)
self.assertTrue(lot.state.is_CLOSED_BY_BUYER)
self.assertTrue(lot.closed_at < datetime.datetime.now())
self.assertEqual(lot.buyer_id, self.account_2.id)
commission_ivoice = bank_prototypes.InvoicePrototype._db_latest()
self.assertTrue(commission_ivoice.recipient_type.is_GAME_ACCOUNT)
self.assertEqual(commission_ivoice.recipient_id, lot.seller_id)
self.assertTrue(commission_ivoice.sender_type.is_GAME_LOGIC)
self.assertEqual(commission_ivoice.sender_id, 0)
self.assertTrue(commission_ivoice.currency.is_PREMIUM)
self.assertEqual(commission_ivoice.amount, -lot.commission)
self.assertEqual(commission_ivoice.operation_uid, 'market-buy-commission-%s' % lot.type)
self.assertTrue(commission_ivoice.state.is_FORCED)
def test_close_lot(self):
self.assertEqual(self.task.process(self.main_task),
POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertEqual(
self.task.process(self.main_task, storage=self.logic_storage),
POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
with self.check_delta(
personal_messages_prototypes.MessagePrototype._db_count, 1):
self.assertEqual(self.task.process(self.main_task),
POSTPONED_TASK_LOGIC_RESULT.SUCCESS)
self.assertTrue(self.task.state.is_PROCESSED)
self.assertTrue(self.task.step.is_SUCCESS)
lot = logic.load_lot(self.task.lot_id)
self.assertTrue(lot.state.is_CLOSED_BY_TIMEOUT)
self.assertTrue(lot.closed_at < datetime.datetime.now())
self.assertEqual(lot.buyer_id, None)
personal_message = personal_messages_prototypes.MessagePrototype._db_all(
).latest()
self.assertEqual(personal_message.recipient_id, self.account_1.id)
self.assertEqual(personal_message.sender_id,
accounts_logic.get_system_user().id)
def parse(self, context, raw_value):
try:
id = int(raw_value)
except ValueError:
self.raise_wrong_format()
lot = logic.load_lot(id)
if lot is None:
self.raise_wrong_value()
return lot
def parse(self, context, raw_value):
try:
id = int(raw_value)
except ValueError:
self.raise_wrong_format()
lot = logic.load_lot(id)
if lot is None:
self.raise_wrong_value()
return lot
def test_close_lot(self):
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertEqual(self.task.process(self.main_task, storage=self.logic_storage), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
with self.check_new_message(self.account_1.id, [accounts_logic.get_system_user_id()]):
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.SUCCESS)
self.assertTrue(self.task.state.is_PROCESSED)
self.assertTrue(self.task.step.is_SUCCESS)
lot = logic.load_lot(self.task.lot_id)
self.assertTrue(lot.state.is_CLOSED_BY_TIMEOUT)
self.assertTrue(lot.closed_at < datetime.datetime.now())
self.assertEqual(lot.buyer_id, None)
def test_rollback(self):
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
goods_types.test_hero_good.remove_good(self.good_1_uid)
self.assertEqual(self.task.process(self.main_task, storage=self.logic_storage), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
with self.check_not_changed(models.Lot.objects.count):
self.assertEqual(self.task.process(self.main_task, storage=self.logic_storage), POSTPONED_TASK_LOGIC_RESULT.SUCCESS)
lot = logic.load_lot(self.task.lot_id)
self.assertTrue(lot.state.is_CLOSED_BY_ERROR)
self.assertTrue(self.task.state.is_PROCESSED)
self.assertTrue(self.task.step.is_ROLLBACKED)
def test_close_lot(self):
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertEqual(self.task.process(self.main_task, storage=self.logic_storage), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
with self.check_delta(personal_messages_prototypes.MessagePrototype._db_count, 1):
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.SUCCESS)
self.assertTrue(self.task.state.is_PROCESSED)
self.assertTrue(self.task.step.is_SUCCESS)
lot = logic.load_lot(self.task.lot_id)
self.assertTrue(lot.state.is_CLOSED_BY_TIMEOUT)
self.assertTrue(lot.closed_at < datetime.datetime.now())
self.assertEqual(lot.buyer_id, None)
personal_message = personal_messages_prototypes.MessagePrototype._db_all().latest()
self.assertEqual(personal_message.recipient_id, self.account_1.id)
self.assertEqual(personal_message.sender_id, accounts_logic.get_system_user().id)
def test_rollback(self):
self.assertEqual(self.task.process(self.main_task),
POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
goods_types.test_hero_good.remove_good(self.good_1_uid)
self.assertEqual(
self.task.process(self.main_task, storage=self.logic_storage),
POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
with self.check_not_changed(models.Lot.objects.count):
self.assertEqual(
self.task.process(self.main_task, storage=self.logic_storage),
POSTPONED_TASK_LOGIC_RESULT.SUCCESS)
lot = logic.load_lot(self.task.lot_id)
self.assertTrue(lot.state.is_CLOSED_BY_ERROR)
self.assertTrue(self.task.state.is_PROCESSED)
self.assertTrue(self.task.step.is_ROLLBACKED)
def test_freeze_lot__success(self):
self.invoice.state = bank_relations.INVOICE_STATE.FROZEN
self.invoice.save()
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertTrue(self.task.state.is_UNPROCESSED)
self.assertTrue(self.task.step.is_RECEIVE_GOOD)
lot = logic.load_lot(self.task.lot_id)
self.assertTrue(lot.state.is_FROZEN)
with mock.patch('the_tale.game.workers.supervisor.Worker.cmd_logic_task') as cmd_logic_task:
for call in self.main_task.extend_postsave_actions.call_args_list:
for func in call[0][0]:
func()
self.assertEqual(cmd_logic_task.call_count, 1)
def test_remove_lot(self):
self.invoice.state = bank_relations.INVOICE_STATE.FROZEN
self.invoice.save()
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
self.assertEqual(self.task.process(self.main_task, storage=self.logic_storage), POSTPONED_TASK_LOGIC_RESULT.CONTINUE)
with mock.patch('the_tale.finances.bank.transaction.Transaction.confirm') as confirm:
with self.check_delta(bank_prototypes.InvoicePrototype._model_class.objects.count, 1):
with self.check_delta(personal_messages_prototypes.MessagePrototype._db_count, 1):
self.assertEqual(self.task.process(self.main_task), POSTPONED_TASK_LOGIC_RESULT.SUCCESS)
self.assertEqual(confirm.call_count, 1)
self.assertTrue(self.task.state.is_PROCESSED)
self.assertTrue(self.task.step.is_SUCCESS)
lot = logic.load_lot(self.task.lot_id)
self.assertTrue(lot.state.is_CLOSED_BY_BUYER)
self.assertTrue(lot.closed_at < datetime.datetime.now())
self.assertEqual(lot.buyer_id, self.account_2.id)
personal_message = personal_messages_prototypes.MessagePrototype._db_all().latest()
self.assertEqual(personal_message.recipient_id, self.account_1.id)
self.assertEqual(personal_message.sender_id, accounts_logic.get_system_user().id)
commission_ivoice = bank_prototypes.InvoicePrototype._db_latest()
self.assertTrue(commission_ivoice.recipient_type.is_GAME_ACCOUNT)
self.assertEqual(commission_ivoice.recipient_id, lot.seller_id)
self.assertTrue(commission_ivoice.sender_type.is_GAME_LOGIC)
self.assertEqual(commission_ivoice.sender_id, 0)
self.assertTrue(commission_ivoice.currency.is_PREMIUM)
self.assertEqual(commission_ivoice.amount, -lot.commission)
self.assertEqual(commission_ivoice.operation_uid, u'market-buy-commission-%s' % lot.type)
self.assertTrue(commission_ivoice.state.is_FORCED)
def process(self, main_task, storage=None): # pylint: disable=R0911
good_type = goods_types.get_type(self.good_type)
if self.step.is_UNPROCESSED:
account = account_prototypes.AccountPrototype.get_by_id(self.account_id)
if account.is_ban_game:
main_task.comment = 'account is banned'
self.state = self.STATE.BANNED
return POSTPONED_TASK_LOGIC_RESULT.ERROR
goods = logic.load_goods(self.account_id)
if not goods.has_good(self.good_uid):
main_task.comment = 'account has no good %s' % self.good_uid
self.state = self.STATE.NO_GOOD
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if logic.has_lot(self.account_id, self.good_uid):
main_task.comment = 'account %d has lot for <%s> %s' % (self.account_id, self.good_type, self.good_uid)
self.state = self.STATE.ALREADY_RESERVED
return POSTPONED_TASK_LOGIC_RESULT.ERROR
lot = logic.reserve_lot(self.account_id, goods.get_good(self.good_uid), price=self.price)
self.lot_id = lot.id
main_task.extend_postsave_actions((lambda: environment.workers.supervisor.cmd_logic_task(self.account_id, main_task.id),))
self.step = self.STEP.RESERVED
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_RESERVED:
hero = storage.accounts_to_heroes[self.account_id]
if not good_type.has_good(hero, self.good_uid):
main_task.comment = 'hero has no good %s' % self.good_uid
self.state = self.STATE.NO_GOOD
self.step = self.STEP.ROLLBACK
main_task.extend_postsave_actions((lambda: environment.workers.market_manager.cmd_logic_task(self.account_id, main_task.id),))
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
good_type.extract_good(hero, self.good_uid)
storage.save_bundle_data(hero.actions.current_action.bundle_id)
main_task.extend_postsave_actions((lambda: environment.workers.market_manager.cmd_logic_task(self.account_id, main_task.id),))
self.step = self.STEP.GOTTEN
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_ROLLBACK:
goods = logic.load_goods(self.account_id)
lot = logic.load_lot(self.lot_id)
lot.state = relations.LOT_STATE.CLOSED_BY_ERROR
logic.save_lot(lot)
self.step = self.STEP.ROLLBACKED
self.state = self.STATE.PROCESSED
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
if self.step.is_GOTTEN:
goods = logic.load_goods(self.account_id)
lot = logic.load_lot(self.lot_id)
lot.state = relations.LOT_STATE.ACTIVE
logic.save_lot(lot)
goods.remove_good(self.good_uid)
logic.save_goods(goods)
self.step = self.STEP.ACTIVATED
self.state = self.STATE.PROCESSED
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
def process(self, main_task, storage=None): # pylint: disable=R0911
good_type = goods_types.get_type(self.good_type)
if self.step.is_UNPROCESSED:
account = account_prototypes.AccountPrototype.get_by_id(
self.account_id)
if account.is_ban_game:
main_task.comment = 'account is banned'
self.state = self.STATE.BANNED
return POSTPONED_TASK_LOGIC_RESULT.ERROR
goods = logic.load_goods(self.account_id)
if not goods.has_good(self.good_uid):
main_task.comment = 'account has no good %s' % self.good_uid
self.state = self.STATE.NO_GOOD
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if logic.has_lot(self.account_id, self.good_uid):
main_task.comment = 'account %d has lot for <%s> %s' % (
self.account_id, self.good_type, self.good_uid)
self.state = self.STATE.ALREADY_RESERVED
return POSTPONED_TASK_LOGIC_RESULT.ERROR
lot = logic.reserve_lot(self.account_id,
goods.get_good(self.good_uid),
price=self.price)
self.lot_id = lot.id
main_task.extend_postsave_actions(
(lambda: environment.workers.supervisor.cmd_logic_task(
self.account_id, main_task.id), ))
self.step = self.STEP.RESERVED
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_RESERVED:
hero = storage.accounts_to_heroes[self.account_id]
if not good_type.has_good(hero, self.good_uid):
main_task.comment = 'hero has no good %s' % self.good_uid
self.state = self.STATE.NO_GOOD
self.step = self.STEP.ROLLBACK
main_task.extend_postsave_actions(
(lambda: environment.workers.market_manager.cmd_logic_task(
self.account_id, main_task.id), ))
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
good_type.extract_good(hero, self.good_uid)
storage.save_bundle_data(hero.actions.current_action.bundle_id)
main_task.extend_postsave_actions(
(lambda: environment.workers.market_manager.cmd_logic_task(
self.account_id, main_task.id), ))
self.step = self.STEP.GOTTEN
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_ROLLBACK:
goods = logic.load_goods(self.account_id)
lot = logic.load_lot(self.lot_id)
lot.state = relations.LOT_STATE.CLOSED_BY_ERROR
logic.save_lot(lot)
self.step = self.STEP.ROLLBACKED
self.state = self.STATE.PROCESSED
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
if self.step.is_GOTTEN:
goods = logic.load_goods(self.account_id)
lot = logic.load_lot(self.lot_id)
lot.state = relations.LOT_STATE.ACTIVE
logic.save_lot(lot)
goods.remove_good(self.good_uid)
logic.save_goods(goods)
self.step = self.STEP.ACTIVATED
self.state = self.STATE.PROCESSED
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
def process(self, main_task, storage=None): # pylint: disable=R0911
if self.step.is_FREEZE_MONEY:
transaction_state = self.transaction.get_invoice_state()
if transaction_state.is_REQUESTED:
return POSTPONED_TASK_LOGIC_RESULT.WAIT
if transaction_state.is_REJECTED:
self.state = self.STATE.TRANSACTION_REJECTED
main_task.comment = 'invoice %d rejected' % self.transaction.invoice_id
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if not transaction_state.is_FROZEN:
self.state = self.STATE.WRONG_TRANSACTION_STATE
main_task.comment = 'wrong invoice %d state %r on freezing step' % (
self.transaction.invoice_id, transaction_state)
return POSTPONED_TASK_LOGIC_RESULT.ERROR
main_task.extend_postsave_actions(
(lambda: environment.workers.market_manager.cmd_logic_task(
self.buyer_id, main_task.id), ))
self.step = self.STEP.FREEZE_LOT
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_FREEZE_LOT:
buyer = account_prototypes.AccountPrototype.get_by_id(
self.buyer_id)
if buyer.is_ban_game:
main_task.comment = 'account is banned'
self.transaction.cancel()
self.state = self.STATE.BUYER_BANNED
return POSTPONED_TASK_LOGIC_RESULT.ERROR
lot = logic.load_lot(self.lot_id)
if not lot.state.is_ACTIVE:
main_task.comment = 'lot is not active, real state is: %s' % lot.state.name
self.transaction.cancel()
self.state = self.STATE.WRONG_LOT_STATE
return POSTPONED_TASK_LOGIC_RESULT.ERROR
self.good_type = goods_types.get_type(lot.type)
self.good = lot.good
lot.state = relations.LOT_STATE.FROZEN
logic.save_lot(lot)
main_task.extend_postsave_actions(
(lambda: environment.workers.supervisor.cmd_logic_task(
self.buyer_id, main_task.id), ))
self.step = self.STEP.RECEIVE_GOOD
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_RECEIVE_GOOD:
hero = storage.accounts_to_heroes[self.buyer_id]
# TODO: save hero after receive item? and after extract too?...
self.good_type.insert_good(hero, self.good)
storage.save_bundle_data(hero.actions.current_action.bundle_id)
main_task.extend_postsave_actions(
(lambda: environment.workers.market_manager.cmd_logic_task(
self.buyer_id, main_task.id), ))
self.step = self.STEP.REMOVE_LOT
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_REMOVE_LOT:
lot = logic.load_lot(self.lot_id)
lot.buyer_id = self.buyer_id
lot.state = relations.LOT_STATE.CLOSED_BY_BUYER
lot.closed_at = datetime.datetime.now()
logic.save_lot(lot)
self.transaction.confirm()
seller = account_prototypes.AccountPrototype.get_by_id(
lot.seller_id)
personal_messages_prototypes.MessagePrototype.create(
accounts_logic.get_system_user(), seller,
good_bought_message(lot))
bank_prototypes.InvoicePrototype.create(
recipient_type=bank_relations.ENTITY_TYPE.GAME_ACCOUNT,
recipient_id=seller.id,
sender_type=bank_relations.ENTITY_TYPE.GAME_LOGIC,
sender_id=0,
currency=bank_relations.CURRENCY_TYPE.PREMIUM,
amount=-lot.commission,
description_for_sender='Комиссия с продажи «%s»' % lot.name,
description_for_recipient='Комиссия с продажи «%s»' % lot.name,
operation_uid='%s-%s' %
(conf.settings.COMMISSION_OPERATION_UID, lot.type),
force=True)
self.state = self.STATE.PROCESSED
self.step = self.STEP.SUCCESS
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
def process(self, main_task, storage=None): # pylint: disable=R0911
if self.step.is_FREEZE_MONEY:
transaction_state = self.transaction.get_invoice_state()
if transaction_state.is_REQUESTED:
return POSTPONED_TASK_LOGIC_RESULT.WAIT
if transaction_state.is_REJECTED:
self.state = self.STATE.TRANSACTION_REJECTED
main_task.comment = 'invoice %d rejected' % self.transaction.invoice_id
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if not transaction_state.is_FROZEN:
self.state = self.STATE.WRONG_TRANSACTION_STATE
main_task.comment = 'wrong invoice %d state %r on freezing step' % (self.transaction.invoice_id, transaction_state)
return POSTPONED_TASK_LOGIC_RESULT.ERROR
main_task.extend_postsave_actions((lambda: environment.workers.market_manager.cmd_logic_task(self.buyer_id, main_task.id),))
self.step = self.STEP.FREEZE_LOT
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_FREEZE_LOT:
buyer = account_prototypes.AccountPrototype.get_by_id(self.buyer_id)
if buyer.is_ban_game:
main_task.comment = 'account is banned'
self.transaction.cancel()
self.state = self.STATE.BUYER_BANNED
return POSTPONED_TASK_LOGIC_RESULT.ERROR
lot = logic.load_lot(self.lot_id)
if not lot.state.is_ACTIVE:
main_task.comment = 'lot is not active, real state is: %s' % lot.state.name
self.transaction.cancel()
self.state = self.STATE.WRONG_LOT_STATE
return POSTPONED_TASK_LOGIC_RESULT.ERROR
self.good_type = goods_types.get_type(lot.type)
self.good = lot.good
lot.state = relations.LOT_STATE.FROZEN
logic.save_lot(lot)
main_task.extend_postsave_actions((lambda: environment.workers.supervisor.cmd_logic_task(self.buyer_id, main_task.id),))
self.step = self.STEP.RECEIVE_GOOD
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_RECEIVE_GOOD:
hero = storage.accounts_to_heroes[self.buyer_id]
# TODO: save hero after receive item? and after extract too?...
self.good_type.insert_good(hero, self.good)
storage.save_bundle_data(hero.actions.current_action.bundle_id)
main_task.extend_postsave_actions((lambda: environment.workers.market_manager.cmd_logic_task(self.buyer_id, main_task.id),))
self.step = self.STEP.REMOVE_LOT
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_REMOVE_LOT:
lot = logic.load_lot(self.lot_id)
lot.buyer_id = self.buyer_id
lot.state = relations.LOT_STATE.CLOSED_BY_BUYER
lot.closed_at = datetime.datetime.now()
logic.save_lot(lot)
self.transaction.confirm()
seller = account_prototypes.AccountPrototype.get_by_id(lot.seller_id)
personal_messages_prototypes.MessagePrototype.create(accounts_logic.get_system_user(), seller, good_bought_message(lot))
bank_prototypes.InvoicePrototype.create(recipient_type=bank_relations.ENTITY_TYPE.GAME_ACCOUNT,
recipient_id=seller.id,
sender_type=bank_relations.ENTITY_TYPE.GAME_LOGIC,
sender_id=0,
currency=bank_relations.CURRENCY_TYPE.PREMIUM,
amount=-lot.commission,
description_for_sender='Комиссия с продажи «%s»' % lot.name,
description_for_recipient='Комиссия с продажи «%s»' % lot.name,
operation_uid='%s-%s' % (conf.settings.COMMISSION_OPERATION_UID, lot.type),
force=True)
self.state = self.STATE.PROCESSED
self.step = self.STEP.SUCCESS
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
