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