def setUp(self): super(RepairBuildingTests, self).setUp() self.place_1, self.place_2, self.place_3 = create_test_map() result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111') result, account_2_id, bundle_id = register_user('test_user_2') self.account_1 = AccountPrototype.get_by_id(account_1_id) self.account_2 = AccountPrototype.get_by_id(account_2_id) self.storage = LogicStorage() self.storage.load_account_data(self.account_1) self.storage.load_account_data(self.account_2) self.hero = self.storage.accounts_to_heroes[self.account_1.id] self.card = self.CARD() environment.deinitialize() environment.initialize() self.highlevel = environment.workers.highlevel self.highlevel.process_initialize(0, 'highlevel') self.building_1 = BuildingPrototype.create(person=self.place_1.persons[0], utg_name=names.generator.get_test_name('building-1-name')) self.building_2 = BuildingPrototype.create(person=self.place_2.persons[0], utg_name=names.generator.get_test_name('building-1-name')) self.building_1.amortize(c.TURNS_IN_HOUR*24) self.building_2.amortize(c.TURNS_IN_HOUR*24)
def __init__(self): register_user('forum_user', '*****@*****.**', '111111') register_user('forum_user_2', '*****@*****.**', '111111') self.account_1 = AccountPrototype.get_by_nick('forum_user') self.account_2 = AccountPrototype.get_by_nick('forum_user_2') # cat1 # |-subcat1 # | |-thread1 # | | |-post1 # | |-thread2 # |-subcat2 # cat2 # | subcat3 # | |- thread3 # cat3 self.cat_1 = CategoryPrototype.create(caption='cat1-caption', slug='cat1-slug', order=0) # to test, that subcat.id not correlate with order self.subcat_2 = SubCategoryPrototype.create(category=self.cat_1, caption='subcat2-caption', order=1, closed=True) self.subcat_1 = SubCategoryPrototype.create(category=self.cat_1, caption='subcat1-caption', order=0) self.cat_2 = CategoryPrototype.create(caption='cat2-caption', slug='cat2-slug', order=0) self.subcat_3 = SubCategoryPrototype.create(category=self.cat_2, caption='subcat3-caption', order=0) self.cat_3 = CategoryPrototype.create(caption='cat3-caption', slug='cat3-slug', order=0) self.thread_1 = ThreadPrototype.create(self.subcat_1, 'thread1-caption', self.account_1, 'thread1-text') self.thread_2 = ThreadPrototype.create(self.subcat_1, 'thread2-caption', self.account_1, 'thread2-text') self.thread_3 = ThreadPrototype.create(self.subcat_3, 'thread3-caption', self.account_1, 'thread3-text') self.post_1 = PostPrototype.create(self.thread_1, self.account_1, 'post1-text') # create test clan and clean it's forum artifacts self.clan_category = CategoryPrototype.create(caption='category-1', slug=clans_settings.FORUM_CATEGORY_SLUG, order=0) self.clan_1 = ClanPrototype.create(self.account_1, abbr=u'abbr1', name=u'name1', motto=u'motto', description=u'description')
def setUp(self): super(TestModeration, self).setUp() create_test_map() register_user('main_user', '*****@*****.**', '111111') register_user('moderator', '*****@*****.**', '111111') register_user('second_user', '*****@*****.**', '111111') self.main_account = AccountPrototype.get_by_nick('main_user') self.moderator = AccountPrototype.get_by_nick('moderator') self.second_account = AccountPrototype.get_by_nick('second_user') group = sync_group(forum_settings.MODERATOR_GROUP_NAME, ['forum.moderate_post', 'forum.moderate_thread']) group.user_set.add(self.moderator._model) self.client = client.Client() self.category = CategoryPrototype.create(caption='cat-caption', slug='cat-slug', order=0) self.subcategory = SubCategoryPrototype.create(category=self.category, caption='subcat-caption', order=0) self.subcategory2 = SubCategoryPrototype.create(category=self.category, caption='subcat2-caption', order=1, closed=True) self.thread = ThreadPrototype.create(self.subcategory, 'thread-caption', self.main_account, 'thread-text') self.post = PostPrototype.create(self.thread, self.main_account, 'post-text') self.post2 = PostPrototype.create(self.thread, self.main_account, 'post2-text') self.post5 = PostPrototype.create(self.thread, self.main_account, 'post5-text', technical=True) self.thread2 = ThreadPrototype.create(self.subcategory, 'thread2-caption', self.main_account, 'thread2-text') self.post3 = PostPrototype.create(self.thread2, self.main_account, 'post3-text') self.post4 = PostPrototype.create(self.thread2, self.second_account, 'post4-text') self.thread3 = ThreadPrototype.create(self.subcategory, 'thread3-caption', self.second_account, 'thread3-text')
def _initiate_battle(self, record_1, record_2, calculate_ratings=False): from the_tale.accounts.prototypes import AccountPrototype account_1 = AccountPrototype.get_by_id(record_1.account_id) account_2 = AccountPrototype.get_by_id(record_2.account_id) self.logger.info("start battle between accounts %d and %d" % (account_1.id, account_2.id)) with transaction.atomic(): battle_1 = Battle1x1Prototype.get_by_id(record_1.battle_id) battle_2 = Battle1x1Prototype.get_by_id(record_2.battle_id) battle_1.set_enemy(account_2) battle_2.set_enemy(account_1) if ( calculate_ratings and abs(record_1.hero_level - record_2.hero_level) <= pvp_settings.BALANCING_MIN_LEVEL_DELTA ): battle_1.calculate_rating = True battle_2.calculate_rating = True battle_1.save() battle_2.save() task = SupervisorTaskPrototype.create_arena_pvp_1x1(account_1, account_2) environment.workers.supervisor.cmd_add_task(task.id)
def setUp(self): super(MetaProxyActionForArenaPvP1x1Tests, self).setUp() create_test_map() self.account_1 = self.accounts_factory.create_account() self.account_2 = self.accounts_factory.create_account() self.storage = LogicStorage() self.storage.load_account_data(AccountPrototype.get_by_id(self.account_1.id)) self.storage.load_account_data(AccountPrototype.get_by_id(self.account_2.id)) self.hero_1 = self.storage.accounts_to_heroes[self.account_1.id] self.hero_2 = self.storage.accounts_to_heroes[self.account_2.id] self.action_idl_1 = self.hero_1.actions.current_action self.action_idl_2 = self.hero_2.actions.current_action self.pvp_create_battle(self.account_1, self.account_2, BATTLE_1X1_STATE.PROCESSING) self.pvp_create_battle(self.account_2, self.account_1, BATTLE_1X1_STATE.PROCESSING) self.bundle_id = 666 meta_action_battle = meta_actions.ArenaPvP1x1.create(self.storage, self.hero_1, self.hero_2) self.action_proxy_1 = ActionMetaProxyPrototype.create(hero=self.hero_1, _bundle_id=self.bundle_id, meta_action=meta_action_battle) self.action_proxy_2 = ActionMetaProxyPrototype.create(hero=self.hero_2, _bundle_id=self.bundle_id, meta_action=meta_action_battle) self.storage.merge_bundles([self.action_idl_1.bundle_id, self.action_idl_2.bundle_id], self.bundle_id) self.meta_action_battle = self.storage.meta_actions.values()[0]
def setUp(self): super(ArenaPvP1x1AbilityTest, self).setUp() self.p1, self.p2, self.p3 = create_test_map() result, account_1_id, bundle_id = register_user("test_user", "*****@*****.**", "111111") result, account_2_id, bundle_id = register_user("test_user_2") self.account_1 = AccountPrototype.get_by_id(account_1_id) self.account_2 = AccountPrototype.get_by_id(account_2_id) self.storage = LogicStorage() self.storage.load_account_data(self.account_1) self.storage.load_account_data(self.account_2) self.hero_1 = self.storage.accounts_to_heroes[self.account_1.id] self.hero_2 = self.storage.accounts_to_heroes[self.account_2.id] self.ability_1 = self.PROCESSOR() self.ability_2 = self.PROCESSOR() environment.deinitialize() environment.initialize() self.pvp_balancer = environment.workers.pvp_balancer self.pvp_balancer.process_initialize("pvp_balancer")
def test_process_bot__flame_ability_not_used(self): result, account_1_id, bundle_id = register_user("bot", "*****@*****.**", "111111", is_bot=True) result, account_2_id, bundle_id = register_user("test_user_3") account_1 = AccountPrototype.get_by_id(account_1_id) account_2 = AccountPrototype.get_by_id(account_2_id) storage = LogicStorage() storage.load_account_data(account_1) storage.load_account_data(account_2) hero_1 = storage.accounts_to_heroes[account_1.id] hero_2 = storage.accounts_to_heroes[account_2.id] MetaActionArenaPvP1x1Prototype.create(storage, hero_1, hero_2, bundle_id=self.bundle_id + 1) self.assertEqual(hero_2.pvp.energy_speed, 1) with mock.patch( "the_tale.game.actions.meta_actions.MetaActionArenaPvP1x1Prototype.get_bot_pvp_properties", lambda a: {"priorities": {Flame.TYPE: 1}, "ability_chance": 1}, ): with mock.patch("the_tale.game.pvp.abilities.Flame.use") as use: for i in xrange(100): self.meta_action_battle.process_bot(hero_1, hero_2) self.assertEqual(use.call_count, 0)
def test_initialize_bots__second_create(self): result, account_1_id, bundle_id = register_user("test_user_3") result, account_2_id, bundle_id = register_user("bot", "*****@*****.**", "111111", is_bot=True) account_1 = AccountPrototype.get_by_id(account_1_id) account_2 = AccountPrototype.get_by_id(account_2_id) storage = LogicStorage() storage.load_account_data(account_1) storage.load_account_data(account_2) hero_1 = storage.accounts_to_heroes[account_1.id] hero_2 = storage.accounts_to_heroes[account_2.id] hero_1._model.level = 50 self.assertEqual(hero_2.level, 1) self.pvp_create_battle(account_1, account_2, BATTLE_1X1_STATE.PROCESSING) self.pvp_create_battle(account_2, account_1, BATTLE_1X1_STATE.PROCESSING) meta_action = MetaActionArenaPvP1x1Prototype.create(storage, hero_1, hero_2, bundle_id=self.bundle_id + 1) meta_action.process_battle_ending() MetaActionArenaPvP1x1Prototype.create(storage, hero_1, hero_2, bundle_id=self.bundle_id + 2) self.assertEqual(hero_2.level, 50) self.assertTrue(len(hero_2.abilities.all) > 1) self.assertEqual(hero_2.health, hero_2.max_health)
def setUp(self): super(MetaProxyActionForArenaPvP1x1Tests, self).setUp() create_test_map() result, account_1_id, bundle_id = register_user('test_user_1', '*****@*****.**', '111111') result, account_2_id, bundle_id = register_user('test_user_2', '*****@*****.**', '111111') self.account_1 = AccountPrototype.get_by_id(account_1_id) self.account_2 = AccountPrototype.get_by_id(account_2_id) self.storage = LogicStorage() self.storage.load_account_data(AccountPrototype.get_by_id(self.account_1.id)) self.storage.load_account_data(AccountPrototype.get_by_id(self.account_2.id)) self.hero_1 = self.storage.accounts_to_heroes[account_1_id] self.hero_2 = self.storage.accounts_to_heroes[account_2_id] self.action_idl_1 = self.hero_1.actions.current_action self.action_idl_2 = self.hero_2.actions.current_action self.pvp_create_battle(self.account_1, self.account_2, BATTLE_1X1_STATE.PROCESSING) self.pvp_create_battle(self.account_2, self.account_1, BATTLE_1X1_STATE.PROCESSING) self.bundle_id = 666 meta_action_battle = MetaActionArenaPvP1x1Prototype.create(self.storage, self.hero_1, self.hero_2, bundle_id=self.bundle_id) self.action_proxy_1 = ActionMetaProxyPrototype.create(hero=self.hero_1, _bundle_id=self.bundle_id, meta_action=meta_action_battle) self.action_proxy_2 = ActionMetaProxyPrototype.create(hero=self.hero_2, _bundle_id=self.bundle_id, meta_action=meta_action_battle) self.storage.merge_bundles([self.action_idl_1.bundle_id, self.action_idl_2.bundle_id], self.bundle_id) self.meta_action_battle = self.storage.meta_actions.values()[0]
def test_subcategories_visible_to_account_with_permissions(self): register_user('test_user', '*****@*****.**', '111111') register_user('granted_user', '*****@*****.**', '111111') register_user('wrong_user', '*****@*****.**', '111111') granted_account = AccountPrototype.get_by_nick('granted_user') wrong_account = AccountPrototype.get_by_nick('wrong_user') category = CategoryPrototype.create(caption='cat-caption', slug='cat-slug', order=0) subcategory_1 = SubCategoryPrototype.create(category=category, caption='subcat-1-caption', order=2) SubCategoryPrototype.create(category=category, caption='subcat-2-caption', order=1, restricted=True) restricted_subcategory = SubCategoryPrototype.create(category=category, caption='subcat-restricted-caption', order=0, restricted=True) PermissionPrototype.create(granted_account, restricted_subcategory) self.assertEqual([s.id for s in SubCategoryPrototype.subcategories_visible_to_account(account=None)], [subcategory_1.id]) self.assertEqual([s.id for s in SubCategoryPrototype.subcategories_visible_to_account(account=granted_account)], [restricted_subcategory.id, subcategory_1.id]) self.assertEqual([s.id for s in SubCategoryPrototype.subcategories_visible_to_account(account=wrong_account)], [subcategory_1.id])
def test_load_account_data_with_meta_action(self): bundle_id = 666 meta_action_battle = meta_actions.ArenaPvP1x1.create(self.storage, self.hero_1, self.hero_2) proxy_action_1 = actions_prototypes.ActionMetaProxyPrototype.create(hero=self.hero_1, _bundle_id=bundle_id, meta_action=meta_action_battle) proxy_action_2 = actions_prototypes.ActionMetaProxyPrototype.create(hero=self.hero_2, _bundle_id=bundle_id, meta_action=meta_action_battle) self.assertEqual(len(self.storage.meta_actions), 1) self.assertEqual(len(self.storage.meta_actions_to_actions), 1) self.assertEqual(self.storage.meta_actions_to_actions[meta_action_battle.uid], set([LogicStorage.get_action_uid(proxy_action_1), LogicStorage.get_action_uid(proxy_action_2)])) self.storage.save_changed_data() self.assertIs(self.hero_1.actions.current_action.meta_action, self.hero_2.actions.current_action.meta_action) self.assertIs(self.hero_1.actions.current_action.saved_meta_action, self.hero_2.actions.current_action.saved_meta_action) storage = LogicStorage() storage.load_account_data(AccountPrototype.get_by_id(self.account_1.id)) storage.load_account_data(AccountPrototype.get_by_id(self.account_2.id)) self.assertEqual(len(storage.meta_actions), 1) self.assertEqual(len(storage.meta_actions_to_actions), 1) self.assertEqual(storage.meta_actions_to_actions[meta_action_battle.uid], set([LogicStorage.get_action_uid(proxy_action_1), LogicStorage.get_action_uid(proxy_action_2)])) self.assertEqual(storage.bundles_to_accounts, {self.hero_1.actions.current_action.bundle_id: set([self.account_1.id, self.account_2.id])}) hero_1 = storage.accounts_to_heroes[self.account_1.id] hero_2 = storage.accounts_to_heroes[self.account_2.id] self.assertIs(hero_1.actions.current_action.meta_action, hero_2.actions.current_action.meta_action) self.assertIsNot(hero_1.actions.current_action.saved_meta_action, hero_2.actions.current_action.saved_meta_action) self.assertEqual(hero_1.actions.current_action.saved_meta_action.serialize(), hero_2.actions.current_action.saved_meta_action.serialize())
def setUp(self): super(BaseRequestTests, self).setUp() create_test_map() result, account_id, bundle_id = register_user('test_user_1', '*****@*****.**', '111111') self.account_1 = AccountPrototype.get_by_id(account_id) result, account_id, bundle_id = register_user('test_user_2', '*****@*****.**', '111111') self.account_2 = AccountPrototype.get_by_id(account_id) result, account_id, bundle_id = register_user('test_user_3', '*****@*****.**', '111111') self.account_3 = AccountPrototype.get_by_id(account_id) group_edit_item = sync_group('edit item', ['collections.edit_item']) group_moderate_item = sync_group('moderate item', ['collections.moderate_item']) group_edit = sync_group('edit kit', ['collections.edit_kit']) group_moderate = sync_group('moderate kit', ['collections.moderate_kit']) group_edit_item.user_set.add(self.account_2._model) group_moderate_item.user_set.add(self.account_3._model) group_edit.user_set.add(self.account_2._model) group_moderate.user_set.add(self.account_3._model) self.collection_1 = CollectionPrototype.create(caption=u'collection_1', description=u'description_1') self.collection_2 = CollectionPrototype.create(caption=u'collection_2', description=u'description_2') self.kit_1 = KitPrototype.create(collection=self.collection_1, caption=u'kit_1', description=u'description_1', approved=True) self.kit_2 = KitPrototype.create(collection=self.collection_1, caption=u'kit_2', description=u'description_2') self.item_1_1 = ItemPrototype.create(kit=self.kit_1, caption=u'item_1_1', text=u'text_1_1') self.item_1_2 = ItemPrototype.create(kit=self.kit_1, caption=u'item_1_2', text=u'text_1_2', approved=True)
def handle(self, *args, **options): actions = set(AccountPrototype._db_exclude(action_id=None).values_list('action_id', flat=True).order_by('action_id').distinct()) for action_id in actions: print() print('----%s----' % action_id) registered_ids = set(AccountPrototype._db_filter(action_id=action_id, is_fast=False).values_list('id', flat=True)) print('registrations: %d' % len(registered_ids)) payers_ids = set(InvoicePrototype._db_filter(models.Q(state=INVOICE_STATE.CONFIRMED)|models.Q(state=INVOICE_STATE.FORCED), sender_type=ENTITY_TYPE.XSOLLA, currency=CURRENCY_TYPE.PREMIUM).values_list('recipient_id', flat=True)) payers_ids &= registered_ids print('payers: %d' % len(payers_ids)) amounts = InvoicePrototype._db_filter(models.Q(state=INVOICE_STATE.CONFIRMED)|models.Q(state=INVOICE_STATE.FORCED), sender_type=ENTITY_TYPE.XSOLLA, recipient_id__in=payers_ids, currency=CURRENCY_TYPE.PREMIUM).values_list('amount', flat=True) amount = sum(amounts) print('total gold: %d' % amount) if registered_ids: print('per account: %.2f' % (float(amount) / len(registered_ids))) if payers_ids: print('per payer: %.2f' % (float(amount) / len(payers_ids)))
def setUp(self): super(BaseTestRequests, self).setUp() self.place1, self.place2, self.place3 = create_test_map() result, account_id, bundle_id = register_user('test_user1', '*****@*****.**', '111111') self.account1 = AccountPrototype.get_by_id(account_id) self.account1.prolong_premium(30) self.account1._model.created_at -= datetime.timedelta(days=bills_settings.MINIMUM_BILL_OWNER_AGE) self.account1.save() result, account_id, bundle_id = register_user('test_user2', '*****@*****.**', '111111') self.account2 = AccountPrototype.get_by_id(account_id) self.account2.prolong_premium(30) self.account2._model.created_at -= datetime.timedelta(days=bills_settings.MINIMUM_BILL_OWNER_AGE) self.account2.save() self.client = client.Client() self.request_login('*****@*****.**') from the_tale.forum.models import Category, SubCategory forum_category = Category.objects.create(caption='Category-1', slug='category-1') SubCategory.objects.create(caption=bills_settings.FORUM_CATEGORY_UID + '-caption', uid=bills_settings.FORUM_CATEGORY_UID, category=forum_category)
def setUp(self): super(_BaseRequestTests, self).setUp() create_test_map() result, account_id, bundle_id = register_user('test_user_1', '*****@*****.**', '111111') self.account_1 = AccountPrototype.get_by_id(account_id) result, account_id, bundle_id = register_user('test_user_2', '*****@*****.**', '111111') self.account_2 = AccountPrototype.get_by_id(account_id) group_edit = sync_group('edit achievement', ['achievements.edit_achievement']) group_edit.user_set.add(self.account_2._model) self.achievement_1 = AchievementPrototype.create(group=ACHIEVEMENT_GROUP.MONEY, type=ACHIEVEMENT_TYPE.MONEY, barrier=0, points=10, caption=u'achievement_1', description=u'description_1', approved=True) self.achievement_2 = AchievementPrototype.create(group=ACHIEVEMENT_GROUP.MONEY, type=ACHIEVEMENT_TYPE.MONEY, barrier=2, points=10, caption=u'achievement_2', description=u'description_2', approved=False) self.achievement_3 = AchievementPrototype.create(group=ACHIEVEMENT_GROUP.TIME, type=ACHIEVEMENT_TYPE.TIME, barrier=3, points=10, caption=u'achievement_3', description=u'description_3', approved=True) self.collection_1 = CollectionPrototype.create(caption=u'collection_1', description=u'description_1', approved=True) self.kit_1 = KitPrototype.create(collection=self.collection_1, caption=u'kit_1', description=u'description_1', approved=True) self.item_1_1 = ItemPrototype.create(kit=self.kit_1, caption=u'item_1_1', text=u'text_1_1', approved=True) self.item_1_2 = ItemPrototype.create(kit=self.kit_1, caption=u'item_1_2', text=u'text_1_2', approved=True) self.account_achievements_1 = AccountAchievementsPrototype.get_by_account_id(self.account_1.id) self.account_achievements_1.achievements.add_achievement(self.achievement_1) self.account_achievements_1.save()
def setUp(self): super(BuildingRepairTest, self).setUp() self.place_1, self.place_2, self.place_3 = create_test_map() result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111') result, account_2_id, bundle_id = register_user('test_user_2') self.account_1 = AccountPrototype.get_by_id(account_1_id) self.account_2 = AccountPrototype.get_by_id(account_2_id) self.storage = LogicStorage() self.storage.load_account_data(self.account_1) self.storage.load_account_data(self.account_2) self.hero_1 = self.storage.accounts_to_heroes[self.account_1.id] self.hero_2 = self.storage.accounts_to_heroes[self.account_2.id] self.ability_1 = self.PROCESSOR() self.ability_2 = self.PROCESSOR() environment.deinitialize() environment.initialize() self.highlevel = environment.workers.highlevel self.highlevel.process_initialize(0, 'highlevel') self.building = BuildingPrototype.create(self.place_1.persons[0], utg_name=names.generator.get_test_name('building-name')) self.building._model.integrity = 0.5 self.building.save()
def setUp(self): super(AchievementsManagerTests, self).setUp() create_test_map() result, account_id, bundle_id = register_user('test_user_1', '*****@*****.**', '111111') self.account_1 = AccountPrototype.get_by_id(account_id) result, account_id, bundle_id = register_user('test_user_2', '*****@*****.**', '111111') self.account_2 = AccountPrototype.get_by_id(account_id) group_edit = sync_group('edit achievement', ['achievements.edit_achievement']) group_edit.user_set.add(self.account_2._model) self.achievement_1 = AchievementPrototype.create(group=ACHIEVEMENT_GROUP.MONEY, type=ACHIEVEMENT_TYPE.MONEY, barrier=0, points=10, caption=u'achievement_1', description=u'description_1', approved=True) self.achievement_2 = AchievementPrototype.create(group=ACHIEVEMENT_GROUP.MONEY, type=ACHIEVEMENT_TYPE.MONEY, barrier=5, points=10, caption=u'achievement_2', description=u'description_2', approved=False) self.achievement_3 = AchievementPrototype.create(group=ACHIEVEMENT_GROUP.TIME, type=ACHIEVEMENT_TYPE.DEATHS, barrier=4, points=10, caption=u'achievement_3', description=u'description_3', approved=True) self.account_achievements_1 = AccountAchievementsPrototype.get_by_account_id(self.account_1.id) self.account_achievements_1.achievements.add_achievement(self.achievement_1) self.account_achievements_1.save() self.worker = environment.workers.achievements_manager self.worker.initialize()
def setUp(self): super(UsePvPAbilityTests, self).setUp() self.p1, self.p2, self.p3 = create_test_map() result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111') result, account_2_id, bundle_id = register_user('test_user_2', '*****@*****.**', '111111') self.account_1 = AccountPrototype.get_by_id(account_1_id) self.account_2 = AccountPrototype.get_by_id(account_2_id) self.storage = LogicStorage() self.storage.load_account_data(self.account_1) self.storage.load_account_data(self.account_2) self.hero_1 = self.storage.accounts_to_heroes[self.account_1.id] self.hero_2 = self.storage.accounts_to_heroes[self.account_2.id] self.battle = Battle1x1Prototype.create(self.account_1) self.battle.set_enemy(self.account_2) self.battle.save() self.ability = random.choice(ABILITIES.values()) self.task = UsePvPAbilityTask(battle_id=self.battle.id, account_id=self.account_1.id, ability_id=self.ability.TYPE)
def test_save_on_exception(self): # hero 1 not saved due to one bundle with hero 3 # hero 2 saved # hero 3 not saved # hero 4 saved result, account_3_id, bundle_3_id = register_user('test_user_3', '*****@*****.**', '111111') self.storage.load_account_data(AccountPrototype.get_by_id(account_3_id)) hero_3 = self.storage.accounts_to_heroes[account_3_id] result, account_4_id, bundle_4_id = register_user('test_user_4', '*****@*****.**', '111111') self.storage.load_account_data(AccountPrototype.get_by_id(account_4_id)) hero_4 = self.storage.accounts_to_heroes[account_4_id] self.hero_1.actions.current_action.bundle_id = hero_3.actions.current_action.bundle_id saved_heroes = set() def save_hero_data(storage, hero_id, **kwargs): saved_heroes.add(hero_id) self.storage.ignored_bundles.add(hero_3.actions.current_action.bundle_id) with mock.patch('the_tale.game.logic_storage.LogicStorage._save_hero_data', save_hero_data): self.storage._save_on_exception() self.assertEqual(saved_heroes, set([self.hero_2.id, hero_4.id]))
def process_battle_ending(self): battle_1 = Battle1x1Prototype.get_by_account_id(self.hero_1.account_id) battle_2 = Battle1x1Prototype.get_by_account_id(self.hero_2.account_id) participant_1 = AccountPrototype.get_by_id(self.hero_1.account_id) participant_2 = AccountPrototype.get_by_id(self.hero_2.account_id) if self.hero_1.health <= 0: if self.hero_2.health <= 0: Battle1x1ResultPrototype.create(participant_1=participant_1, participant_2=participant_2, result =BATTLE_1X1_RESULT.DRAW) if battle_1.calculate_rating and battle_2.calculate_rating: self.hero_1.statistics.change_pvp_battles_1x1_draws(1) self.hero_2.statistics.change_pvp_battles_1x1_draws(1) else: Battle1x1ResultPrototype.create(participant_1=participant_1, participant_2=participant_2, result =BATTLE_1X1_RESULT.DEFEAT) if battle_1.calculate_rating and battle_2.calculate_rating: self.hero_2.statistics.change_pvp_battles_1x1_victories(1) self.hero_1.statistics.change_pvp_battles_1x1_defeats(1) else: Battle1x1ResultPrototype.create(participant_1=participant_1, participant_2=participant_2, result =BATTLE_1X1_RESULT.VICTORY) if battle_1.calculate_rating and battle_2.calculate_rating: self.hero_1.statistics.change_pvp_battles_1x1_victories(1) self.hero_2.statistics.change_pvp_battles_1x1_defeats(1) battle_1.remove() battle_2.remove() self.hero_1.health = self.hero_1_old_health self.hero_2.health = self.hero_2_old_health self.state = self.STATE.PROCESSED
def test_save_on_exception__time_border(self): # hero 1 not saved due to one bundle with hero 3 # hero 2 saved # hero 3 not saved # hero 4 saved result, account_3_id, bundle_3_id = register_user('test_user_3', '*****@*****.**', '111111') self.storage.load_account_data(AccountPrototype.get_by_id(account_3_id)) hero_3 = self.storage.accounts_to_heroes[account_3_id] result, account_4_id, bundle_4_id = register_user('test_user_4', '*****@*****.**', '111111') self.storage.load_account_data(AccountPrototype.get_by_id(account_4_id)) hero_4 = self.storage.accounts_to_heroes[account_4_id] self.hero_1.actions.current_action.bundle_id = hero_3.actions.current_action.bundle_id saved_heroes = set() self.hero_2._model.saved_at = datetime.datetime.now() - datetime.timedelta(seconds=conf.game_settings.SAVE_ON_EXCEPTION_TIMEOUT+1) def save_hero_data(storage, hero_id, **kwargs): saved_heroes.add(hero_id) self.storage.ignored_bundles.add(hero_3.actions.current_action.bundle_id) with mock.patch('the_tale.game.logic_storage.LogicStorage._save_hero_data', save_hero_data): self.storage._save_on_exception() self.assertEqual(saved_heroes, set([self.hero_2.id]))
def test_get_bundles_to_save__without_cache_dump(self): # hero 1 not saved # hero 2 saved by quota # hero 3 does not saved by caching # hero 4 not saved result, account_3_id, bundle_3_id = register_user('test_user_3', '*****@*****.**', '111111') result, account_4_id, bundle_4_id = register_user('test_user_4', '*****@*****.**', '111111') self.storage.load_account_data(AccountPrototype.get_by_id(account_3_id)) self.storage.load_account_data(AccountPrototype.get_by_id(account_4_id)) hero_3 = self.storage.accounts_to_heroes[account_3_id] hero_4 = self.storage.accounts_to_heroes[account_4_id] self.hero_1._model.saved_at = datetime.datetime.now() self.hero_1.ui_caching_started_at = datetime.datetime.fromtimestamp(0) self.hero_2.ui_caching_started_at = datetime.datetime.fromtimestamp(0) hero_4.ui_caching_started_at = datetime.datetime.fromtimestamp(0) self.assertTrue(self.hero_1.saved_at > self.hero_2.saved_at) self.assertFalse(self.hero_1.is_ui_caching_required) self.assertFalse(self.hero_2.is_ui_caching_required) self.assertTrue(hero_3.is_ui_caching_required) self.assertFalse(hero_4.is_ui_caching_required) self.assertEqual(self.storage._get_bundles_to_save(), set([self.bundle_2_id]))
def test_change_credentials__with_referral(self): self.fast_account._model.referral_of = self.account._model self.fast_account.save() self.assertTrue(AccountPrototype.get_by_id(self.fast_account.id).is_fast) with mock.patch("the_tale.game.workers.supervisor.Worker.cmd_update_hero_with_account_data") as fake_cmd: with mock.patch( "the_tale.accounts.workers.accounts_manager.Worker.cmd_run_account_method" ) as cmd_run_account_method: self.fast_account.change_credentials( new_email="*****@*****.**", new_password=make_password("222222"), new_nick="test_nick" ) self.assertEqual(cmd_run_account_method.call_count, 1) self.assertEqual( cmd_run_account_method.call_args, mock.call( account_id=self.account.id, method_name=AccountPrototype.update_referrals_number.__name__, data={} ), ) self.assertEqual(django_authenticate(nick="test_nick", password="******").id, self.fast_account.id) self.assertFalse(AccountPrototype.get_by_id(self.fast_account.id).is_fast) self.assertEqual(fake_cmd.call_count, 1) self.assertFalse(fake_cmd.call_args[1]["is_fast"])
def setUp(self): super(ArenaPvP1x1AcceptBaseTests, self).setUp() self.p1, self.p2, self.p3 = create_test_map() result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111') result, account_2_id, bundle_id = register_user('test_user_2', '*****@*****.**', '111111') self.account_1 = AccountPrototype.get_by_id(account_1_id) self.account_2 = AccountPrototype.get_by_id(account_2_id) self.storage = LogicStorage() self.storage.load_account_data(self.account_1) self.storage.load_account_data(self.account_2) self.hero_1 = self.storage.accounts_to_heroes[self.account_1.id] self.hero_2 = self.storage.accounts_to_heroes[self.account_2.id] environment.deinitialize() environment.initialize() self.pvp_balancer = environment.workers.pvp_balancer self.pvp_balancer.process_initialize('pvp_balancer') self.battle = self.pvp_balancer.add_to_arena_queue(self.hero_1.id)
def handle(self, *args, **options): # pylint: disable=R0914 # account = AccountPrototype.get_by_nick('compare_abilities_user') # if account: # account.remove() # account = AccountPrototype.get_by_nick('compare_abilities_user_2') # if account: # account.remove() result, account_1_id, bundle_id = register_user('compare_abilities_user') # pylint: disable=W0612 result, account_2_id, bundle_id = register_user('compare_abilities_user_2') # pylint: disable=W0612 account_1 = AccountPrototype.get_by_id(account_1_id) account_2 = AccountPrototype.get_by_id(account_2_id) storage = LogicStorage() storage.load_account_data(account_1) storage.load_account_data(account_2) hero_1 = storage.accounts_to_heroes[account_1_id] hero_2 = storage.accounts_to_heroes[account_2_id] set_heroes_companion(hero_1, hero_2) try: abilities = [ability_class for ability_class in ABILITIES.values() if (ability_class.AVAILABILITY.value & ABILITY_AVAILABILITY.FOR_PLAYERS.value and ability_class.get_id() != 'hit' and ability_class.TYPE == ABILITY_TYPE.BATTLE) ] ability_matches = compare_abilities(hero_1, hero_2, abilities, level=LEVEL) ability_statistics = dict( (ability.get_id(), 0) for ability in abilities) ability_wins = dict( (ability.get_id(), []) for ability in abilities) for (ability_1_id, ability_2_id), (ability_1_wins, ability_2_wins) in ability_matches.items(): ability_statistics[ability_1_id] = ability_statistics.get(ability_1_id, 0) + ability_1_wins ability_statistics[ability_2_id] = ability_statistics.get(ability_2_id, 0) + ability_2_wins ability_wins[ability_1_id].append(ability_1_wins) ability_wins[ability_2_id].append(ability_2_wins) statistics = sorted(ability_statistics.items(), key=lambda stat: -stat[1]) battles_per_ability = TEST_BATTLES_NUMBER * (len(abilities)-1) for ability_id, wins in statistics: print '%d\t%.0f%%\t%s' % (wins, 100*float(wins)/(battles_per_ability*len(HERO_LEVELS)), ability_id) save_ability_power_statistics(statistics) save_ability_mathces_statistics(statistics, ability_matches) save_ability_wins_distribution(statistics, ability_wins) finally: remove_account(account_1) remove_account(account_2)
def setUp(self): super(AccountPrototypeTests, self).setUp() self.place_1, self.place_2, self.place_3 = create_test_map() result, account_id, bundle_id = register_user("test_user", "*****@*****.**", "111111") self.account = AccountPrototype.get_by_id(account_id) result, account_id, bundle_id = register_user("fast_user") self.fast_account = AccountPrototype.get_by_id(account_id)
def setUp(self): super(FormGameInfoTests, self).setUp() create_test_map() result, account_id, bundle_id = register_user('test_user_1') self.account_1 = AccountPrototype.get_by_id(account_id) result, account_id, bundle_id = register_user('test_user_2') self.account_2 = AccountPrototype.get_by_id(account_id)
def setUp(self): super(TestChangeCredentialsTask, self).setUp() create_test_map() result, account_id, bundle_id = register_user('test_user', '*****@*****.**', '111111') self.test_account = AccountPrototype.get_by_id(account_id) result, account_id, bundle_id = register_user('fast_user') self.fast_account = AccountPrototype.get_by_id(account_id)
def setUp(self): super(SupervisorTaskTests, self).setUp() self.p1, self.p2, self.p3 = create_test_map() result, account_1_id, bundle_id = register_user('test_user', '*****@*****.**', '111111') result, account_2_id, bundle_id = register_user('test_user_2', '*****@*****.**', '111111') self.account_1 = AccountPrototype.get_by_id(account_1_id) self.account_2 = AccountPrototype.get_by_id(account_2_id)
def setUp(self): super(SendMailTests, self).setUp() create_test_map() register_user('user_1', '*****@*****.**', '111111') self.account_1 = AccountPrototype.get_by_nick('user_1') register_user('user_2', '*****@*****.**', '111111') self.account_2 = AccountPrototype.get_by_nick('user_2')
def get_accounts_for_thread(cls, thread): accounts = Account.objects.filter(subscription__thread_id=thread.id) return [AccountPrototype(model=account) for account in accounts]
def sender(self): return AccountPrototype.get_by_id(self.sender_id) @lazy_property
def index(self): if portal_settings.ENABLE_FIRST_TIME_REDIRECT and accounts_logic.is_first_time_visit( self.request): return self.redirect( random.choice(portal_settings.FIRST_TIME_LANDING_URLS)) news = news_logic.load_news_from_query( news_models.News.objects.all().order_by( '-created_at')[:portal_settings.NEWS_ON_INDEX]) bills = BillPrototype.get_recently_modified_bills( portal_settings.BILLS_ON_INDEX) account_of_the_day_id = settings.get( portal_settings.SETTINGS_ACCOUNT_OF_THE_DAY_KEY) hero_of_the_day = None account_of_the_day = None clan_of_the_day = None if account_of_the_day_id is not None: hero_of_the_day = heroes_logic.load_hero( account_id=account_of_the_day_id) account_of_the_day = AccountPrototype.get_by_id( account_of_the_day_id) if account_of_the_day and account_of_the_day.clan_id is not None: clan_of_the_day = ClanPrototype.get_by_id( account_of_the_day.clan_id) forum_threads = ThreadPrototype.get_last_threads( account=self.account if self.account.is_authenticated else None, limit=portal_settings.FORUM_THREADS_ON_INDEX) blog_posts = [ BlogPostPrototype(blog_post_model) for blog_post_model in BlogPost.objects.filter(state__in=[ BLOG_POST_STATE.ACCEPTED, BLOG_POST_STATE.NOT_MODERATED ], votes__gte=0). order_by('-created_at')[:portal_settings.BLOG_POSTS_ON_INDEX] ] map_info = map_info_storage.item chronicle_records = ChronicleRecordPrototype.get_last_records( portal_settings.CHRONICLE_RECORDS_ON_INDEX) chronicle_actors = RecordToActorPrototype.get_actors_for_records( chronicle_records) return self.template( 'portal/index.html', { 'news': news, 'forum_threads': forum_threads, 'bills': bills, 'hero_of_the_day': hero_of_the_day, 'account_of_the_day': account_of_the_day, 'clan_of_the_day': clan_of_the_day, 'map_info': map_info, 'blog_posts': blog_posts, 'TERRAIN': TERRAIN, 'MAP_STATISTICS': MAP_STATISTICS, 'chronicle_records': chronicle_records, 'chronicle_actors': chronicle_actors, 'RACE': RACE })
def test_corridor(self): # fill_empty_keys_with_fake_phrases(u'test_hero_level_companion') result, account_id, bundle_id = register_user(uuid.uuid4().hex) # pylint: disable=W0612 self.storage = LogicStorage() self.storage.load_account_data(AccountPrototype.get_by_id(account_id)) self.hero = self.storage.accounts_to_heroes[account_id] self.set_hero_companion() current_time = TimePrototype.get_current_time() for level in xrange(1, 100): print print '-----------------------------------------------------------------------' print 'process level %d\texpected turns: %d\texpected days: %.2f' % ( level, f.turns_on_lvl(level), f.time_on_lvl(level) / 24) for i in xrange(f.turns_on_lvl(level)): # pylint: disable=W0612 self.storage.process_turn() current_time.increment_turn() # simulate user behaviour on healing companion if self.hero.companion.health < self.hero.companion.max_health / 2: self.hero.companion.health = self.hero.companion.max_health self.hero.randomized_level_up() exp_to_next_level = float(self.hero.experience) / f.exp_on_lvl( self.hero.level) * 100 exp_from_expected = float( f.total_exp_to_lvl(self.hero.level) + self.hero.experience) / f.total_exp_to_lvl(level + 1) * 100 exp_untaken = f.total_exp_to_lvl(level + 1) - f.total_exp_to_lvl( self.hero.level) - self.hero.experience quests_untaken = float(exp_untaken) / f.experience_for_quest( c.QUEST_AREA_RADIUS) print u'hero level: %d\texp: %.2f%%\texp from expected: %.2f%% (%d exp, %.2f quests)\ttotal quests %d' % ( self.hero.level, exp_to_next_level, exp_from_expected, exp_untaken, quests_untaken, self.hero.statistics.quests_done) print u'abilities: %s' % ' '.join(u'%s-%d' % (ability_id, ability.level) for ability_id, ability in self. hero.abilities.abilities.items()) print u'deaths: %d' % self.hero.statistics.pve_deaths total_gold = f.total_gold_at_lvl(self.hero.level) print u'total money: %d from expected %d (x%.2f)' % ( self.hero.statistics.money_earned, total_gold, float(self.hero.statistics.money_earned) / total_gold if total_gold > 0 else 0) total_artifacts = int( f.total_time_for_lvl(self.hero.level) / 24 * c.ARTIFACTS_LOOT_PER_DAY) print u'total artifacts: %d from expected %d (x%.2f)' % ( self.hero.statistics.artifacts_had, total_artifacts, float(self.hero.statistics.artifacts_had) / total_artifacts if total_artifacts > 0 else 0) print u'power: %r from expected %r' % ( self.hero.power, Power.power_to_level( self.hero.preferences.archetype.power_distribution, self.hero.level)) print u'power total: %d from expected %r (x%.2f)' % ( self.hero.power.total(), Power.power_to_level( self.hero.preferences.archetype.power_distribution, self.hero.level).total(), float(self.hero.power.total()) / Power.power_to_level( self.hero.preferences.archetype.power_distribution, self.hero.level).total())
def process_register_account(self, account_id): from the_tale.accounts.prototypes import AccountPrototype account = AccountPrototype.get_by_id(account_id) if account is None: raise LogicException('can not get account with id "%d"' % (account_id,)) self.storage.load_account_data(account)
def setUp(self): super(ChangeEmailNotificationTests, self).setUp() create_test_map() register_user('user_1', '*****@*****.**', '111111') self.account = AccountPrototype.get_by_nick('user_1')
def account(self): return AccountPrototype.get_by_id(self.account_id) if self.account_id is not None else None def process_transaction_requested(self, main_task):
def author(self): return AccountPrototype(self._model.author) if self._model.author else None @property
def recipient(self): return AccountPrototype.get_by_id(self.recipient_id) def process(self, main_task):
def index(self, page=1, author_id=None, order_by=ORDER_BY.CREATED_AT, tag_id=None): posts_query = models.Post.objects.filter(state__in=[ relations.POST_STATE.NOT_MODERATED, relations.POST_STATE.ACCEPTED ]) is_filtering = False author_account = None if author_id is not None: try: author_id = int(author_id) except ValueError: return self.redirect(reverse('blogs:posts:'), permanent=False) author_account = AccountPrototype.get_by_id(author_id) if author_account: posts_query = posts_query.filter(author_id=author_account.id) is_filtering = True else: posts_query = models.Post.objects.none() if tag_id is not None: posts_query = posts_query.filter( id__in=models.Tagged.objects.filter( tag_id=tag_id).values_list('post_id', flat=True)) if order_by is not None: if order_by == ORDER_BY.ALPHABET: posts_query = posts_query.order_by('caption') elif order_by == ORDER_BY.CREATED_AT: posts_query = posts_query.order_by('-created_at') elif order_by == ORDER_BY.RATING: posts_query = posts_query.order_by('-votes') elif order_by == ORDER_BY.MIGHT: posts_query = posts_query.order_by('-rating') else: order_by = ORDER_BY.CREATED_AT posts_query = posts_query.order_by('-created_at') url_builder = UrlBuilder(reverse('blogs:posts:'), arguments={ 'author_id': author_id, 'order_by': order_by, 'tag_id': tag_id }) posts_count = posts_query.count() page = int(page) - 1 paginator = Paginator(page, posts_count, conf.settings.POSTS_ON_PAGE, url_builder) if paginator.wrong_page_number: return self.redirect(paginator.last_page_url, permanent=False) post_from, post_to = paginator.page_borders(page) posts = [ prototypes.PostPrototype(post) for post in posts_query.select_related()[post_from:post_to] ] votes = {} if self.account.is_authenticated: votes = dict((vote.post_id, prototypes.VotePrototype(vote)) for vote in models.Vote.objects.filter( post_id__in=[post.id for post in posts], voter=self.account._model)) return self.template( 'blogs/index.html', { 'posts': posts, 'page_type': 'index', 'votes': votes, 'FORUM_TAGS_THREAD': conf.settings.FORUM_TAGS_THREAD, 'order_by': order_by, 'current_tag': models.Tag.objects.get( id=tag_id) if tag_id is not None else None, 'ORDER_BY': ORDER_BY, 'is_filtering': is_filtering, 'current_page_number': page, 'author_account': author_account, 'paginator': paginator, 'url_builder': url_builder })
def index(self, key=None, state=None, filter=None, restriction=None, errors_status=None, page=1, contributor=None, order_by=relations.INDEX_ORDER_BY.UPDATED_AT): templates_query = prototypes.TemplatePrototype._db_all().order_by( 'raw_template') if contributor is not None: entities_ids = prototypes.ContributionPrototype._db_filter( type=relations.CONTRIBUTION_TYPE.TEMPLATE, account_id=contributor.id).values_list('entity_id', flat=True) templates_query = templates_query.filter( models.Q(id__in=entities_ids) | models.Q(author_id=contributor.id)) if key: templates_query = templates_query.filter(key=key) if state: templates_query = templates_query.filter(state=state) if errors_status: templates_query = templates_query.filter( errors_status=errors_status) if restriction: templates_query = templates_query.filter( templaterestriction__restriction_id=restriction.id) if filter: templates_query = templates_query.filter( raw_template__icontains=filter) if order_by.is_UPDATED_AT: templates_query = templates_query.order_by('-updated_at') elif order_by.is_TEXT: templates_query = templates_query.order_by('raw_template') page = int(page) - 1 templates_count = templates_query.count() url_builder = UrlBuilder( reverse('linguistics:templates:'), arguments={ 'state': state.value if state else None, 'errors_status': errors_status.value if errors_status else None, 'contributor': contributor.id if contributor else None, 'order_by': order_by.value, 'filter': filter, 'restriction': restriction.id if restriction is not None else None, 'key': key.value if key is not None else None }) index_filter = TemplatesIndexFilter( url_builder=url_builder, values={ 'state': state.value if state else None, 'errors_status': errors_status.value if errors_status else None, 'contributor': contributor.nick if contributor else None, 'order_by': order_by.value, 'filter': filter, 'restriction': restriction.id if restriction is not None else None, 'key': key.value if key is not None else None, 'count': templates_query.count() }) paginator = Paginator(page, templates_count, linguistics_settings.TEMPLATES_ON_PAGE, url_builder) if paginator.wrong_page_number: return self.redirect(paginator.last_page_url, permanent=False) template_from, template_to = paginator.page_borders(page) templates = prototypes.TemplatePrototype.from_query( templates_query[template_from:template_to]) authors = { account.id: account for account in AccountPrototype.from_query( AccountPrototype.get_list_by_id( [template.author_id for template in templates])) } clans = { clan.id: clan for clan in ClanPrototype.from_query( ClanPrototype.get_list_by_id( [author.clan_id for author in authors.itervalues()])) } return self.template( 'linguistics/templates/index.html', { 'key': key, 'templates': templates, 'index_filter': index_filter, 'page_type': 'all-templates', 'paginator': paginator, 'authors': authors, 'clans': clans, 'LEXICON_KEY': keys.LEXICON_KEY })
def test_process__only_active_initiator(self): AccountPrototype._db_all().update( active_end_at=datetime.datetime.now() + datetime.timedelta(days=1)) self.account_2.remove() self.request.process() self.check_not_processed()
def account(self): return AccountPrototype(model=self._model.account)
def account(self): return AccountPrototype.get_by_id(self.account_id) if self.account_id is not None else None def get_unique_nick(self):
def test_process__no_active_accounts(self): AccountPrototype._db_all().update( active_end_at=datetime.datetime.now()) self.request.process() self.check_not_processed()
def get_accounts_for_subcategory(cls, subcategory): accounts = Account.objects.filter(subscription__subcategory_id=subcategory.id) return [AccountPrototype(model=account) for account in accounts]
def initialize(self, account, thread, page, inline=False): self.account = account self.thread = thread url_builder = UrlBuilder(reverse('forum:threads:show', args=[self.thread.id]), arguments={'page': page}) page -= 1 self.paginator = Paginator(page, thread.posts_count + 1, forum_settings.POSTS_ON_PAGE, url_builder) if self.paginator.wrong_page_number: return False post_from, post_to = self.paginator.page_borders(page) self.post_from = post_from self.posts = [ PostPrototype(post_model) for post_model in Post.objects.filter(thread=self.thread._model). order_by('created_at')[post_from:post_to] ] self.authors = { author.id: author for author in AccountPrototype.get_list_by_id( [post.author_id for post in self.posts]) } self.game_objects = { game_object.account_id: game_object for game_object in heroes_logic.load_heroes_by_account_ids( [post.author_id for post in self.posts]) } pages_on_page_slice = self.posts if post_from == 0: pages_on_page_slice = pages_on_page_slice[1:] self.has_post_on_page = any([ post.author.id == self.account.id for post in pages_on_page_slice ]) self.new_post_form = forms.NewPostForm() self.start_posts_from = page * forum_settings.POSTS_ON_PAGE self.inline = inline self.can_delete_posts = can_delete_posts(self.account, self.thread) self.can_change_posts = can_change_posts(self.account) self.can_delete_thread = not self.inline and can_delete_thread( self.account) self.can_change_thread = not self.inline and can_change_thread( self.account, self.thread) self.ignore_first_post = (self.inline and self.paginator.current_page_number == 0) self.can_post = self.account.is_authenticated( ) and not self.account.is_fast self.no_posts = (len(self.posts) == 0) or (self.ignore_first_post and len(self.posts) == 1) self.can_subscribe = self.account.is_authenticated( ) and not self.account.is_fast self.has_subscription = SubscriptionPrototype.has_subscription( self.account, self.thread) return True
def last_poster(self): return AccountPrototype(self._model.last_poster) if self._model.last_poster else None @lazy_property
def handle(self, *args, **options): # pylint: disable=R0914 # account = AccountPrototype.get_by_nick('compare_abilities_user') # if account: # account.remove() # account = AccountPrototype.get_by_nick('compare_abilities_user_2') # if account: # account.remove() result, account_1_id, bundle_id = register_user( 'compare_abilities_user') # pylint: disable=W0612 result, account_2_id, bundle_id = register_user( 'compare_abilities_user_2') # pylint: disable=W0612 account_1 = AccountPrototype.get_by_id(account_1_id) account_2 = AccountPrototype.get_by_id(account_2_id) storage = LogicStorage() storage.load_account_data(account_1) storage.load_account_data(account_2) hero_1 = storage.accounts_to_heroes[account_1_id] hero_2 = storage.accounts_to_heroes[account_2_id] set_heroes_companion(hero_1, hero_2) try: abilities = [ ability_class for ability_class in ABILITIES.values() if (ability_class.AVAILABILITY.value & ABILITY_AVAILABILITY.FOR_PLAYERS.value and ability_class.get_id() != 'hit' and ability_class.TYPE == ABILITY_TYPE.BATTLE) ] ability_matches = compare_abilities(hero_1, hero_2, abilities, level=LEVEL) ability_statistics = dict( (ability.get_id(), 0) for ability in abilities) ability_wins = dict( (ability.get_id(), []) for ability in abilities) for (ability_1_id, ability_2_id), (ability_1_wins, ability_2_wins) in ability_matches.items(): ability_statistics[ability_1_id] = ability_statistics.get( ability_1_id, 0) + ability_1_wins ability_statistics[ability_2_id] = ability_statistics.get( ability_2_id, 0) + ability_2_wins ability_wins[ability_1_id].append(ability_1_wins) ability_wins[ability_2_id].append(ability_2_wins) statistics = sorted(ability_statistics.items(), key=lambda stat: -stat[1]) battles_per_ability = TEST_BATTLES_NUMBER * (len(abilities) - 1) for ability_id, wins in statistics: print '%d\t%.0f%%\t%s' % ( wins, 100 * float(wins) / (battles_per_ability * len(HERO_LEVELS)), ability_id) save_ability_power_statistics(statistics) save_ability_mathces_statistics(statistics, ability_matches) save_ability_wins_distribution(statistics, ability_wins) finally: remove_account(account_1) remove_account(account_2)
def test_process__only_fast_accounts(self): AccountPrototype._db_all().update( active_end_at=datetime.datetime.now() + datetime.timedelta(days=1), is_fast=True) self.request.process() self.check_not_processed()
def test_send_premium_expired_notifications(self): self.assertEqual(PersonalMessagePrototype._db_count(), 0) register_user('test_user_2', '*****@*****.**', '111111') register_user('test_user_3', '*****@*****.**', '111111') register_user('test_user_4', '*****@*****.**', '111111') account_1 = self.account account_2 = AccountPrototype.get_by_nick('test_user_2') account_3 = AccountPrototype.get_by_nick('test_user_3') account_4 = AccountPrototype.get_by_nick('test_user_4') account_1.prolong_premium( accounts_settings.PREMIUM_EXPIRED_NOTIFICATION_IN.days - 1) account_1.save() account_3.prolong_premium( accounts_settings.PREMIUM_EXPIRED_NOTIFICATION_IN.days - 1) account_3.save() account_4.prolong_premium( accounts_settings.PREMIUM_EXPIRED_NOTIFICATION_IN.days + 1) account_4.save() zero_time = datetime.datetime.fromtimestamp(0) self.assertEqual(account_1._model.premium_expired_notification_send_at, zero_time) self.assertEqual(account_2._model.premium_expired_notification_send_at, zero_time) self.assertEqual(account_3._model.premium_expired_notification_send_at, zero_time) self.assertEqual(account_4._model.premium_expired_notification_send_at, zero_time) AccountPrototype.send_premium_expired_notifications() account_1.reload() account_2.reload() account_3.reload() account_4.reload() self.assertNotEqual( account_1._model.premium_expired_notification_send_at, zero_time) self.assertEqual(account_2._model.premium_expired_notification_send_at, zero_time) self.assertNotEqual( account_3._model.premium_expired_notification_send_at, zero_time) self.assertEqual(account_4._model.premium_expired_notification_send_at, zero_time) current_time = datetime.datetime.now() self.assertTrue( current_time - datetime.timedelta(seconds=60) < account_1._model. premium_expired_notification_send_at < current_time) self.assertTrue( current_time - datetime.timedelta(seconds=60) < account_3._model. premium_expired_notification_send_at < current_time) self.assertEqual(PersonalMessagePrototype._db_count(), 2)
def filter_recipients(cls, ids): return set( AccountPrototype._db_exclude( membership__account__in=ids).values_list('id', flat=True))
def index(self): registration_attemps_number = AccountPrototype._model_class.objects.all( ).aggregate(models.Max('id'))['id__max'] accounts_total = AccountPrototype._model_class.objects.all().count() accounts_bots = AccountPrototype._model_class.objects.filter( is_bot=True).count() accounts_registered = AccountPrototype.live_query().count() accounts_active = AccountPrototype.live_query().filter( active_end_at__gt=datetime.datetime.now()).count() accounts_premium = AccountPrototype.live_query().filter( premium_end_at__gt=datetime.datetime.now()).count() accounts_active_and_premium = AccountPrototype.live_query().filter( active_end_at__gt=datetime.datetime.now(), premium_end_at__gt=datetime.datetime.now()).count() accounts_referrals = AccountPrototype.live_query().exclude( referral_of=None).count() accounts_referrals_and_premium = AccountPrototype.live_query().exclude( referral_of=None).filter( premium_end_at__gt=datetime.datetime.now()).count() accounts_referrals_and_active = AccountPrototype.live_query().exclude( referral_of=None).filter( active_end_at__gt=datetime.datetime.now(), premium_end_at__gt=datetime.datetime.now()).count() gold = {} gold_total_spent = 0 gold_total_received = 0 real_gold_total_spent = 0 real_gold_total_received = 0 for record in BANK_ENTITY_TYPE.records: spent = -BankAccountPrototype._money_spent(from_type=record) received = BankAccountPrototype._money_received(from_type=record) gold[record.text] = {'spent': spent, 'received': received} gold_total_spent += spent gold_total_received += received if record.is_real: real_gold_total_spent += spent real_gold_total_received += received gold_in_game = gold_total_received - gold_total_spent real_gold_in_game = real_gold_total_received - real_gold_total_spent return self.template( 'developers_info/index.html', { 'registration_attemps_number': registration_attemps_number, 'accounts_total': accounts_total, 'accounts_bots': accounts_bots, 'accounts_registered': accounts_registered, 'accounts_active': accounts_active, 'accounts_premium': accounts_premium, 'accounts_active_and_premium': accounts_active_and_premium, 'accounts_referrals': accounts_referrals, 'accounts_referrals_and_premium': accounts_referrals_and_premium, 'accounts_referrals_and_active': accounts_referrals_and_active, 'gold': gold, 'gold_total_spent': gold_total_spent, 'gold_total_received': gold_total_received, 'gold_in_game': gold_in_game, 'real_gold_in_game': real_gold_in_game, 'referers_statistics': get_referers_statistics(), 'invoice_statistics': get_invoice_statistics(), 'invoice_count': InvoiceQuery.count(), 'repeatable_payments_statistics': get_repeatable_payments_statistics(), 'PAYMENT_GROUPS': PAYMENT_GROUPS, 'PREMIUM_DAYS_FOR_HERO_OF_THE_DAY': portal_settings.PREMIUM_DAYS_FOR_HERO_OF_THE_DAY, 'page_type': 'index' })
def test_process_add_to_arena_queue_two_requests_from_one_account(self): battle_1 = Battle1x1Prototype.create(AccountPrototype.get_by_id(self.account_1.id)) battle_2 = Battle1x1Prototype.create(AccountPrototype.get_by_id(self.account_1.id)) self.assertEqual(Battle1x1.objects.all().count(), 1) self.assertEqual(battle_1.id, battle_2.id)
def process(self, main_task, storage): hero = storage.heroes[self.hero_id] account = AccountPrototype.get_by_id(hero.account_id) if not hero.preferences.can_update(self.preference_type, datetime.datetime.now()): main_task.comment = u'blocked since time delay' self.state = CHOOSE_PREFERENCES_TASK_STATE.COOLDOWN return POSTPONED_TASK_LOGIC_RESULT.ERROR if not hero.preferences.is_available(self.preference_type, account): main_task.comment = u'hero level < required level (%d < %d)' % ( hero.level, self.preference_type.level_required) self.state = CHOOSE_PREFERENCES_TASK_STATE.LOW_LEVEL return POSTPONED_TASK_LOGIC_RESULT.ERROR if self.preference_type.is_ENERGY_REGENERATION_TYPE: result = self.process_energy_regeneration(main_task, hero) elif self.preference_type.is_MOB: result = self.process_mob(main_task, hero) elif self.preference_type.is_PLACE: result = self.process_place(main_task, hero) elif self.preference_type.is_FRIEND: result = self.process_friend(main_task, hero) elif self.preference_type.is_ENEMY: result = self.process_enemy(main_task, hero) elif self.preference_type.is_EQUIPMENT_SLOT: result = self.process_equipment_slot(main_task, hero) elif self.preference_type.is_RISK_LEVEL: result = self.process_risk_level(main_task, hero) elif self.preference_type.is_FAVORITE_ITEM: result = self.process_favorite_item(main_task, hero) elif self.preference_type.is_ARCHETYPE: result = self.process_archetype(main_task, hero) elif self.preference_type.is_COMPANION_DEDICATION: result = self.process_companion_dedication(main_task, hero) elif self.preference_type.is_COMPANION_EMPATHY: result = self.process_companion_empathy(main_task, hero) else: main_task.comment = u'unknown preference type: %s' % ( self.preference_type, ) self.state = CHOOSE_PREFERENCES_TASK_STATE.UNKNOWN_PREFERENCE return POSTPONED_TASK_LOGIC_RESULT.ERROR if result == POSTPONED_TASK_LOGIC_RESULT.SUCCESS: storage.save_bundle_data(hero.actions.current_action.bundle_id) self.state = CHOOSE_PREFERENCES_TASK_STATE.PROCESSED return result
def owner(self): return AccountPrototype(self._model.owner)
def owner(self): if not hasattr(self, '_owner'): self._owner = AccountPrototype(self._model.owner) return self._owner
def account(self): return AccountPrototype.get_by_id(self.account_id) @property
def accept_request(self, request): accepted_account = AccountPrototype.get_by_id(request.account_id) self.clan_info.clan.add_member(accepted_account) request.create_accept_request_message(initiator=self.account) request.remove() return self.json_ok()
def index(self, page=1, state=None, type=None, filter=None, contributor=None, order_by=relations.INDEX_ORDER_BY.UPDATED_AT): words_query = prototypes.WordPrototype._db_all().order_by( 'normal_form') if contributor is not None: entities_ids = prototypes.ContributionPrototype._db_filter( type=relations.CONTRIBUTION_TYPE.WORD, account_id=contributor.id).values_list('entity_id', flat=True) words_query = words_query.filter( models.Q(id__in=entities_ids) | models.Q(author_id=contributor.id)) if state: words_query = words_query.filter(state=state) if type: words_query = words_query.filter(type=type.utg_type) if filter: words_query = words_query.filter( normal_form__istartswith=filter.lower()) if order_by.is_UPDATED_AT: words_query = words_query.order_by('-updated_at') elif order_by.is_TEXT: words_query = words_query.order_by('normal_form') words_count = words_query.count() url_builder = UrlBuilder(reverse('linguistics:words:'), arguments={ 'state': state.value if state else None, 'type': type.value if type else None, 'contributor': contributor.id if contributor else None, 'order_by': order_by.value, 'filter': filter }) index_filter = WordsIndexFilter( url_builder=url_builder, values={ 'state': state.value if state else None, 'type': type.value if type else None, 'filter': filter, 'contributor': contributor.nick if contributor else None, 'order_by': order_by.value, 'count': words_count }) page = int(page) - 1 paginator = Paginator(page, words_count, linguistics_settings.WORDS_ON_PAGE, url_builder) if paginator.wrong_page_number: return self.redirect(paginator.last_page_url, permanent=False) words_from, words_to = paginator.page_borders(page) words = prototypes.WordPrototype.from_query( words_query[words_from:words_to]) authors = { account.id: account for account in AccountPrototype.from_query( AccountPrototype.get_list_by_id( [word.author_id for word in words])) } clans = { clan.id: clan for clan in ClanPrototype.from_query( ClanPrototype.get_list_by_id( [author.clan_id for author in authors.itervalues()])) } return self.template( 'linguistics/words/index.html', { 'words': words, 'page_type': 'dictionary', 'paginator': paginator, 'authors': authors, 'clans': clans, 'ALLOWED_WORD_TYPE': relations.ALLOWED_WORD_TYPE, 'index_filter': index_filter })