def give_reward_for_template(template):
from the_tale.accounts import logic as accounts_logic
from the_tale.accounts.personal_messages import logic as personal_messages_logic
from the_tale.game.cards import logic as cards_logic
if template.author_id is None:
return
updated = prototypes.ContributionPrototype._db_filter(type=relations.CONTRIBUTION_TYPE.TEMPLATE,
entity_id=template.id,
account=template.author_id,
reward_given=False).update(reward_given=True)
if not updated:
return
cards_number = conf.settings.SPECIAL_CARDS_REWARDS.get(template.key.name.upper(), conf.settings.DEFAULT_CARDS_REWARDS)
cards_logic.give_new_cards(account_id=template.author_id,
operation_type='give-card-for-linguistic-template',
allow_premium_cards=True,
available_for_auction=True,
number=cards_number)
message = '''Поздравляем! Ваша [url={template}]фраза[/url] добавлена в игру!\n\nВ награду вы можете получить дополнительные карты судьбы (на странице игры, в количестве {cards_number} шт.). Карты можно будет продать на рынке.'''
message = message.format(template=dext_urls.full_url('https', 'linguistics:templates:show', template.id),
cards_number=cards_number)
personal_messages_logic.send_message(sender_id=accounts_logic.get_system_user_id(),
recipients_ids=[template.author_id],
body=message,
async=False)
def create_invite_message(self, initiator):
message = '''
Игрок %(clan_leader_link)s предлагает вам вступить в гильдию %(clan_link)s:
%(text)s
----------
принять или отклонить предложение вы можете на этой странице: %(invites_link)s
''' % {
'clan_leader_link':
'[url="%s"]%s[/url]' %
(full_url('http', 'accounts:show',
initiator.id), initiator.nick_verbose),
'text':
self.text,
'clan_link':
'[url="%s"]%s[/url]' % (full_url('http', 'accounts:clans:show',
self.clan.id), self.clan.name),
'invites_link':
'[url="%s"]Приглашения в гильдию [/url]' %
full_url('http', 'accounts:clans:membership:for-account')
}
pm_logic.send_message(sender_id=initiator.id,
recipients_ids=[self.account.id],
body=message)
def give_reward_for_template(template):
from the_tale.accounts import logic as accounts_logic
from the_tale.accounts.personal_messages import logic as personal_messages_logic
from the_tale.game.cards import logic as cards_logic
if template.author_id is None:
return
updated = prototypes.ContributionPrototype._db_filter(type=relations.CONTRIBUTION_TYPE.TEMPLATE,
entity_id=template.id,
account=template.author_id,
reward_given=False).update(reward_given=True)
if not updated:
return
cards_number = conf.settings.SPECIAL_CARDS_REWARDS.get(template.key.name.upper(), conf.settings.DEFAULT_CARDS_REWARDS)
cards_logic.give_new_cards(account_id=template.author_id,
operation_type='give-card-for-linguistic-template',
allow_premium_cards=True,
available_for_auction=True,
number=cards_number)
message = '''Поздравляем! Ваша [url={template}]фраза[/url] добавлена в игру!\n\nВ награду вы можете получить дополнительные карты судьбы (на странице игры, в количестве {cards_number} шт.). Карты можно будет продать на рынке.'''
message = message.format(template=utils_urls.full_url('https', 'linguistics:templates:show', template.id),
cards_number=cards_number)
personal_messages_logic.send_message(sender_id=accounts_logic.get_system_user_id(),
recipients_ids=[template.author_id],
body=message,
asynchronous=False)
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)
pm_logic.send_message(sender_id=accounts_logic.get_system_user_id(),
recipients_ids=[seller.id],
body=good_timeout_message(lot),
async=True)
self.state = self.STATE.PROCESSED
self.step = self.STEP.SUCCESS
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
def reset_bans(context):
context.master_account.reset_ban_forum()
context.master_account.reset_ban_game()
pm_logic.send_message(
sender_id=logic.get_system_user_id(),
recipients_ids=[context.master_account.id],
body='С вас сняли все ограничения, наложенные ранее.')
return dext_views.AjaxOk()
def setUp(self):
super(PersonalMessagesTests, self).setUp()
create_test_map()
self.account_1 = self.accounts_factory.create_account()
self.account_2 = self.accounts_factory.create_account()
pm_logic.send_message(self.account_1.id, [self.account_2.id],
'test text')
self.message = MessagePrototype.get_priority_message()
def test_mail_send__to_system_user(self):
from the_tale.accounts.logic import get_system_user
Message.objects.all().delete()
pm_logic.send_message(self.account_1.id, [get_system_user().id],
'test text')
message = MessagePrototype.get_priority_message()
self.assertEqual(len(mail.outbox), 0)
message.process()
self.assertTrue(message.state.is_PROCESSED)
self.assertEqual(len(mail.outbox), 0)
def create_reject_request_message(self, initiator):
message = '''
Игрок %(clan_leader_link)s отказал вам в принятии в гильдию %(clan_link)s.
''' % {
'clan_leader_link':
'[url="%s"]%s[/url]' %
(full_url('http', 'accounts:show',
initiator.id), initiator.nick_verbose),
'clan_link':
'[url="%s"]%s[/url]' % (full_url('http', 'accounts:clans:show',
self.clan.id), self.clan.name)
}
pm_logic.send_message(sender_id=initiator.id,
recipients_ids=[self.account.id],
body=message)
def create_remove_member_message(self, initiator, removed_account):
message = '''
Игрок %(clan_leader_link)s исключил вас из гильдии %(clan_link)s.
''' % {
'clan_leader_link':
'[url="%s"]%s[/url]' %
(full_url('http', 'accounts:show',
initiator.id), initiator.nick_verbose),
'clan_link':
'[url="%s"]%s[/url]' %
(full_url('http', 'accounts:clans:show', self.id), self.name)
}
pm_logic.send_message(sender_id=initiator.id,
recipients_ids=[removed_account.id],
body=message)
def increment_level(self, send_message=False):
self.level += 1
self.add_message('hero_common_journal_level_up',
hero=self,
level=self.level)
self.force_save_required = True
if send_message: # TODO: move out logic
account = accounts_prototypes.AccountPrototype.get_by_id(
self.account_id)
pm_logic.send_message(
sender_id=accounts_logic.get_system_user_id(),
recipients_ids=[self.account_id],
body='Поздравляем, Ваш герой получил {} уровень!'.format(
self.level),
async=True)
def portal_day_started(sender, **kwargs):
accounts_query = AccountPrototype.live_query().filter(
active_end_at__gt=datetime.datetime.now(),
ban_game_end_at__lt=datetime.datetime.now(),
ban_forum_end_at__lt=datetime.datetime.now(),
premium_end_at__lt=datetime.datetime.now())
accounts_number = accounts_query.count()
if accounts_number < 1:
return
account = None
for i in range(1000):
account_model = accounts_query[random.randint(0, accounts_number - 1)]
account = AccountPrototype(model=account_model)
# explicity check for premium, since infinit subscribers does not filtered by previouse query
if not account.is_premium:
break
else:
return # if not premium account does not found
settings[portal_settings.SETTINGS_ACCOUNT_OF_THE_DAY_KEY] = str(account.id)
environment.workers.accounts_manager.cmd_run_account_method(
account_id=account.id,
method_name=AccountPrototype.prolong_premium.__name__,
data={'days': portal_settings.PREMIUM_DAYS_FOR_HERO_OF_THE_DAY})
message = '''
Поздравляем!
Ваш герой выбран героем дня и Вы получаете %(days)d дней подписки!
''' % {
'days': portal_settings.PREMIUM_DAYS_FOR_HERO_OF_THE_DAY
}
pm_logic.send_message(sender_id=accounts_logic.get_system_user_id(),
recipients_ids=[account.id],
body=message,
async=True)
def ban(context):
if context.form.c.ban_type.is_FORUM:
context.master_account.ban_forum(context.form.c.ban_time.days)
message = 'Вы лишены права общаться на форуме. Причина: \n\n%(message)s'
elif context.form.c.ban_type.is_GAME:
context.master_account.ban_game(context.form.c.ban_time.days)
message = 'Ваш герой лишён возможности влиять на мир игры. Причина: \n\n%(message)s'
elif context.form.c.ban_type.is_TOTAL:
context.master_account.ban_forum(context.form.c.ban_time.days)
context.master_account.ban_game(context.form.c.ban_time.days)
message = 'Вы лишены права общаться на форуме, ваш герой лишён возможности влиять на мир игры. Причина: \n\n%(message)s'
else:
raise dext_views.ViewError(code='unknown_ban_type',
message='Неизвестный тип бана')
pm_logic.send_message(sender_id=logic.get_system_user_id(),
recipients_ids=[context.master_account.id],
body=message %
{'message': context.form.c.description})
return dext_views.AjaxOk()
def create_request_message(self, initiator):
message = '''
Игрок %(account)s просит принять его в вашу гильдию:
%(text)s
----------
принять или отклонить предложение вы можете на этой странице: %(invites_link)s
''' % {
'account':
'[url="%s"]%s[/url]' %
(full_url('http', 'accounts:show',
self.account.id), self.account.nick_verbose),
'text':
self.text,
'invites_link':
'[url="%s"]Заявки в гильдию[/url]' %
full_url('http', 'accounts:clans:membership:for-clan')
}
pm_logic.send_message(sender_id=initiator.id,
recipients_ids=[self.clan.get_leader().id],
body=message)
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)
pm_logic.send_message(sender_id=accounts_logic.get_system_user_id(),
recipients_ids=[seller.id],
body=good_bought_message(lot),
async=True)
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):
if self.step.is_INITIALIZE:
if self.sender.is_fast:
self.state = self.STATE.SENDER_IS_FAST
self.step = self.STEP.ERROR
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if self.recipient.is_fast:
self.state = self.STATE.RECIPIENT_IS_FAST
self.step = self.STEP.ERROR
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if self.sender.is_ban_any:
self.state = self.STATE.SENDER_BANNED
self.step = self.STEP.ERROR
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if self.recipient.is_ban_any:
self.state = self.STATE.RECIPIENT_BANNED
self.step = self.STEP.ERROR
return POSTPONED_TASK_LOGIC_RESULT.ERROR
transfer_invoice = bank_prototypes.InvoicePrototype.create(
recipient_type=bank_relations.ENTITY_TYPE.GAME_ACCOUNT,
recipient_id=self.recipient_id,
sender_type=bank_relations.ENTITY_TYPE.GAME_ACCOUNT,
sender_id=self.sender_id,
currency=bank_relations.CURRENCY_TYPE.PREMIUM,
amount=self.amount,
description_for_sender='Перевод игроку «%s»: «%s».' %
(self.recipient.nick_verbose, self.comment),
description_for_recipient='Перевод от игрока «%s»: «%s».' %
(self.sender.nick_verbose, self.comment),
operation_uid='transfer-money-between-accounts-transfer')
self.transfer_transaction = bank_transaction.Transaction(
transfer_invoice.id)
commission_invoice = bank_prototypes.InvoicePrototype.create(
recipient_type=bank_relations.ENTITY_TYPE.GAME_ACCOUNT,
recipient_id=self.sender_id,
sender_type=bank_relations.ENTITY_TYPE.GAME_LOGIC,
sender_id=0,
currency=bank_relations.CURRENCY_TYPE.PREMIUM,
amount=-self.commission,
description_for_sender='Комиссия с перевода игроку «%s»: «%s».'
% (self.recipient.nick_verbose, self.comment),
description_for_recipient=
'Комиссия с перевода игроку «%s»: «%s».' %
(self.recipient.nick_verbose, self.comment),
operation_uid=conf.accounts_settings.COMMISION_TRANSACTION_UID)
self.commission_transaction = bank_transaction.Transaction(
commission_invoice.id)
main_task.extend_postsave_actions(
(lambda: amqp_environment.environment.workers.refrigerator.
cmd_wait_task(main_task.id), ))
self.step = self.STEP.WAIT
return POSTPONED_TASK_LOGIC_RESULT.CONTINUE
if self.step.is_WAIT:
transfer_transaction_state = self.transfer_transaction.get_invoice_state(
)
commission_transaction_state = self.commission_transaction.get_invoice_state(
)
if transfer_transaction_state.is_REQUESTED:
return POSTPONED_TASK_LOGIC_RESULT.WAIT
if transfer_transaction_state.is_REJECTED:
self.state = self.STATE.TRANSFER_TRANSACTION_REJECTED
self.step = self.STEP.ERROR
main_task.comment = 'invoice %d rejected' % self.transfer_transaction.invoice_id
self.commission_transaction.cancel()
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if not transfer_transaction_state.is_FROZEN:
self.state = self.STATE.TRANSFER_TRANSACTION_WRONG_STATE
self.step = self.STEP.ERROR
main_task.comment = 'invoice %d rejected' % self.transfer_transaction.invoice_id
self.commission_transaction.cancel()
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if commission_transaction_state.is_REQUESTED:
return POSTPONED_TASK_LOGIC_RESULT.WAIT
if commission_transaction_state.is_REJECTED:
self.state = self.STATE.COMMISSION_TRANSACTION_REJECTED
self.step = self.STEP.ERROR
main_task.comment = 'invoice %d rejected' % self.commission_transaction.invoice_id
self.transfer_transaction.cancel()
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if not commission_transaction_state.is_FROZEN:
self.state = self.STATE.COMMISSION_TRANSACTION_WRONG_STATE
self.step = self.STEP.ERROR
main_task.comment = 'invoice %d rejected' % self.commission_transaction.invoice_id
self.transfer_transaction.cancel()
return POSTPONED_TASK_LOGIC_RESULT.ERROR
if not (transfer_transaction_state.is_FROZEN
and commission_transaction_state.is_FROZEN):
return POSTPONED_TASK_LOGIC_RESULT.WAIT
self.transfer_transaction.confirm()
self.commission_transaction.confirm()
message = text = 'Игрок «{sender}» перевёл(-а) вам печеньки: {amount} шт. \n\n[quote]{comment}[/quote]'.format(
sender=self.sender.nick_verbose,
amount=self.amount,
comment=self.comment)
pm_logic.send_message(sender_id=logic.get_system_user_id(),
recipients_ids=[self.recipient.id],
body=message,
async=True)
self.state = self.STATE.PROCESSED
self.step = self.STEP.SUCCESS
return POSTPONED_TASK_LOGIC_RESULT.SUCCESS
