def initialize(self):
self.initialized = True
self.next_invoice_process_time = datetime.datetime.now()
InvoicePrototype.reset_all()
self.logger.info('BANK PROCESSOR INITIALIZED')
def test_process__processed(self):
self.assertEqual(BankInvoicePrototype._db_count(), 0)
invoice = self.create_invoice(worker_call_count=1)
self.assertEqual(invoice.bank_invoice_id, None)
invoice.process()
invoice.reload()
self.assertEqual(BankInvoicePrototype._db_count(), 1)
self.assertTrue(invoice.state.is_PROCESSED)
bank_invoice = BankInvoicePrototype._db_get_object(0)
self.assertEqual(bank_invoice.id, invoice.bank_invoice_id)
self.assertTrue(bank_invoice.recipient_type.is_GAME_ACCOUNT)
self.assertEqual(bank_invoice.recipient_id, self.fabric.account_id)
self.assertTrue(bank_invoice.sender_type.is_XSOLLA)
self.assertEqual(bank_invoice.sender_id, 0)
self.assertTrue(bank_invoice.state.is_FORCED)
self.assertTrue(bank_invoice.currency.is_PREMIUM)
self.assertTrue(bank_invoice.amount, int(self.fabric.payment_sum))
self.assertEqual(bank_invoice.operation_uid, 'bank-xsolla')
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 test_check_frozen_expired_invoices__wrong_state(self):
for state in INVOICE_STATE.records:
if state.is_FROZEN:
continue
self.create_invoice(state=state)
self.assertFalse(InvoicePrototype.check_frozen_expired_invoices())
InvoicePrototype._db_all().delete()
def test_get_unprocessed_invoice_success(self):
for state in INVOICE_STATE.records:
if not (state.is_REQUESTED or state.is_FORCED):
continue
invoice = self.create_invoice(state=state)
self.assertEqual(InvoicePrototype.get_unprocessed_invoice().id, invoice.id)
InvoicePrototype._db_all().delete()
def test_process__test(self):
self.assertEqual(BankInvoicePrototype._db_count(), 0)
invoice = self.create_invoice(worker_call_count=1, test='1')
invoice.process()
invoice.reload()
self.assertEqual(BankInvoicePrototype._db_count(), 0)
self.assertTrue(invoice.state.is_SKIPPED_BECOUSE_TEST)
def test_reset_all(self):
for state in INVOICE_STATE.records:
invoice = self.create_invoice()
invoice.state = state
invoice.save()
InvoicePrototype.reset_all()
self.assertEqual(InvoicePrototype._model_class.objects.filter(state=INVOICE_STATE.RESETED).count(), len(INVOICE_STATE.records) - 4)
self.assertEqual(InvoicePrototype._model_class.objects.filter(state=INVOICE_STATE.CONFIRMED).count(), 1)
self.assertEqual(InvoicePrototype._model_class.objects.filter(state=INVOICE_STATE.CANCELED).count(), 1)
self.assertEqual(InvoicePrototype._model_class.objects.filter(state=INVOICE_STATE.REJECTED).count(), 1)
self.assertEqual(InvoicePrototype._model_class.objects.filter(state=INVOICE_STATE.FORCED).count(), 1)
def create_invoice(self,
recipient_type=ENTITY_TYPE.GAME_ACCOUNT,
recipient_id=3,
sender_type=ENTITY_TYPE.GAME_LOGIC,
sender_id=8,
currency=CURRENCY_TYPE.PREMIUM,
amount=317,
state=None,
description_for_sender='invoice-description-for-sender',
description_for_recipient='invoice-description-for-recipient',
operation_uid='test-uid',
force=False):
invoice = InvoicePrototype.create(recipient_type=recipient_type,
recipient_id=recipient_id,
sender_type=sender_type,
sender_id=sender_id,
currency=currency,
amount=amount,
description_for_sender=description_for_sender,
description_for_recipient=description_for_recipient,
operation_uid=operation_uid,
force=force)
if state is not None:
invoice.state = state
invoice.save()
return invoice
def setUp(self):
super(_BaseBuyPosponedTaskTests, self).setUp()
create_test_map()
self.initial_amount = 500
self.amount = 130
self.account = self.accounts_factory.create_account()
self.bank_account = BankAccountPrototype.create(
entity_type=ENTITY_TYPE.GAME_ACCOUNT, entity_id=self.account.id, currency=CURRENCY_TYPE.PREMIUM
)
self.bank_account.amount = self.initial_amount
self.bank_account.save()
self.invoice = InvoicePrototype.create(
recipient_type=ENTITY_TYPE.GAME_ACCOUNT,
recipient_id=self.account.id,
sender_type=ENTITY_TYPE.GAME_LOGIC,
sender_id=0,
currency=CURRENCY_TYPE.PREMIUM,
amount=-self.amount,
description_for_sender="transaction-description-for-sender",
description_for_recipient="transaction-description-for-recipient",
operation_uid="transaction-operation-ui",
)
self.transaction = Transaction(self.invoice.id)
self.task = None
self.storage = None
self.cmd_update_with_account_data__call_count = 1
self.accounts_manages_worker = True
self.supervisor_worker = False
def test_get_unprocessed_invoice__no_invoice(self):
for state in INVOICE_STATE.records:
if state.is_REQUESTED or state.is_FORCED:
continue
self.create_invoice(state=state)
self.assertEqual(InvoicePrototype.get_unprocessed_invoice(), None)
def setUp(self):
super(_BaseBuyPosponedTaskTests, self).setUp()
create_test_map()
self.initial_amount = 500
self.amount = 130
result, account_id, bundle_id = register_user('test_user', '*****@*****.**', '111111')
self.account = AccountPrototype.get_by_id(account_id)
self.bank_account = BankAccountPrototype.create(entity_type=ENTITY_TYPE.GAME_ACCOUNT,
entity_id=self.account.id,
currency=CURRENCY_TYPE.PREMIUM)
self.bank_account.amount = self.initial_amount
self.bank_account.save()
self.invoice = InvoicePrototype.create(recipient_type=ENTITY_TYPE.GAME_ACCOUNT,
recipient_id=self.account.id,
sender_type=ENTITY_TYPE.GAME_LOGIC,
sender_id=0,
currency=CURRENCY_TYPE.PREMIUM,
amount=-self.amount,
description_for_sender='transaction-description-for-sender',
description_for_recipient='transaction-description-for-recipient',
operation_uid='transaction-operation-ui')
self.transaction = Transaction(self.invoice.id)
self.task = None
self.storage = None
self.cmd_update_with_account_data__call_count = 1
self.accounts_manages_worker = True
self.supervisor_worker = False
def test_history(self):
self.create_bank_account(self.account.id)
history = self.create_entity_history(self.account.id)
invoices = BankInvoicePrototype._db_all()
histroy_ids = [invoice.id for invoice in history]
texts = [('pgf-no-history-message', 0)]
for invoice in invoices:
if invoice.id in histroy_ids:
continue
if invoice.recipient_id == self.account.id:
texts.append((invoice.description_for_recipient, 0))
else:
texts.append((invoice.description_for_sender, 0))
for invoice in history:
if invoice.recipient_id == self.account.id:
texts.append((invoice.description_for_recipient, 1))
texts.append((invoice.description_for_sender, 0))
else:
texts.append((invoice.description_for_recipient, 0))
texts.append((invoice.description_for_sender, 1))
self.check_html_ok(self.request_html(self.page_url), texts=texts)
def get_value(self, date):
query = AccountPrototype._db_filter(is_fast=False, is_bot=False)
# do not use accounts registered before payments turn on
query = query.filter(self.db_date_interval('created_at', date=date, days=-self.PERIOD),
self.db_date_gte('created_at', date=statistics_settings.PAYMENTS_START_DATE.date()))
accounts = dict(query.values_list('id', 'created_at'))
invoices = list(InvoicePrototype._db_filter(ACCEPTED_INVOICE_FILTER,
sender_type=ENTITY_TYPE.XSOLLA,
currency=CURRENCY_TYPE.PREMIUM,
recipient_id__in=list(accounts.keys())).values_list('created_at', 'recipient_id'))
account_ids = [id_ for created_at, id_ in invoices]
if not account_ids:
return 0
delays = {account_id: min([(created_at - accounts[account_id])
for created_at, id_ in invoices
if id_==account_id])
for account_id in account_ids}
total_time = reduce(lambda s, v: s+v, list(delays.values()), datetime.timedelta(seconds=0))
days = float(total_time.total_seconds()) / len(account_ids) / (24*60*60)
return days
def test_buy(self):
self.assertEqual(PostponedTaskPrototype._model_class.objects.all().count(), 0)
self.assertEqual(InvoicePrototype._model_class.objects.all().count(), 0)
with mock.patch('the_tale.common.postponed_tasks.prototypes.PostponedTaskPrototype.cmd_wait') as cmd_wait:
self.purchase.buy(account=self.account)
self.assertEqual(cmd_wait.call_count, 1)
self.assertEqual(PostponedTaskPrototype._model_class.objects.all().count(), 1)
self.assertEqual(InvoicePrototype._model_class.objects.all().count(), 1)
postponed_logic = PostponedTaskPrototype._db_get_object(0).internal_logic
self.assertTrue(isinstance(postponed_logic, BuyPremium))
self.assertEqual(postponed_logic.account_id, self.account.id)
self.assertEqual(postponed_logic.days, self.days)
invoice = InvoicePrototype.get_by_id(postponed_logic.transaction.invoice_id)
self.assertEqual(invoice.recipient_type, ENTITY_TYPE.GAME_ACCOUNT)
self.assertEqual(invoice.recipient_id, self.account.id)
self.assertEqual(invoice.sender_type, ENTITY_TYPE.GAME_LOGIC)
self.assertEqual(invoice.sender_id, 0)
self.assertEqual(invoice.currency, CURRENCY_TYPE.PREMIUM)
self.assertEqual(invoice.amount, -self.cost)
self.assertEqual(invoice.description_for_sender, 'premium-days-transaction-description')
self.assertEqual(invoice.description_for_recipient, 'premium-days-transaction-description')
def get_invoice_intervals_count(self, days, date):
starts = list(InvoicePrototype._db_filter(models.Q(state=INVOICE_STATE.CONFIRMED)|models.Q(state=INVOICE_STATE.FORCED),
operation_uid__contains='<%s%d' % (GOODS_GROUP.PREMIUM.uid_prefix, days),
sender_type=ENTITY_TYPE.GAME_LOGIC,
currency=CURRENCY_TYPE.PREMIUM).values_list('created_at', flat=True))
return len([True
for created_at in starts
if created_at <= datetime.datetime.combine(date, datetime.time()) < created_at + datetime.timedelta(days=days)] )
def test_success(self):
self.assertEqual(BankInvoicePrototype._db_count(), 0)
response = self.post_ajax_json(url('shop:give-money', account=self.account.id), self.post_data(amount=5))
self.assertEqual(BankInvoicePrototype._db_count(), 1)
invoice = BankInvoicePrototype._db_get_object(0)
self.assertTrue(invoice.recipient_type.is_GAME_ACCOUNT)
self.assertEqual(invoice.recipient_id, self.account.id)
self.assertTrue(invoice.sender_type.is_GAME_MASTER)
self.assertEqual(invoice.sender_id, self.superuser.id)
self.assertTrue(invoice.currency.is_PREMIUM)
self.assertEqual(invoice.amount, 5)
self.assertEqual(invoice.description_for_recipient, u'bla-bla')
self.assertTrue(invoice.state.is_FORCED)
self.check_ajax_ok(response)
def get_value(self, date):
income = InvoicePrototype._db_filter(ACCEPTED_INVOICE_FILTER,
self.db_date_interval('created_at', date=date, days=-self.PERIOD),
sender_type=ENTITY_TYPE.XSOLLA,
currency=CURRENCY_TYPE.PREMIUM).aggregate(income=models.Sum('amount'))['income']
if income is None:
return 0
return income
def initialize(self):
super(Income, self).initialize()
query = InvoicePrototype._db_filter(ACCEPTED_INVOICE_FILTER,
self.db_date_gte('created_at', date=self.free_date - self.PREFETCH_DELTA),
sender_type=ENTITY_TYPE.XSOLLA, currency=CURRENCY_TYPE.PREMIUM).values_list('created_at', 'amount')
invoices = [(created_at.date(), amount) for created_at, amount in query]
self.invoices_values = {}
for created_at, amount in invoices:
self.invoices_values[created_at] = self.invoices_values.get(created_at, 0) + amount
def check_frozen_expired_invoices(self):
if time.time() - float(settings.get(bank_settings.SETTINGS_LAST_FROZEN_EXPIRED_CHECK_KEY, 0)) < bank_settings.FROZEN_INVOICE_EXPIRED_CHECK_TIMEOUT:
return
settings[bank_settings.SETTINGS_LAST_FROZEN_EXPIRED_CHECK_KEY] = str(time.time())
if not InvoicePrototype.check_frozen_expired_invoices():
return
self.logger.error('We have some expired frozen invoices. Please, check them and remove or find error.')
def _create_outcoming_invoice(self, amount, state=INVOICE_STATE.FROZEN):
invoice = InvoicePrototype.create(sender_type=self.account.entity_type,
sender_id=self.account.entity_id,
recipient_type=ENTITY_TYPE.GAME_LOGIC,
recipient_id=0,
currency=CURRENCY_TYPE.PREMIUM,
amount=amount,
description_for_sender='outcoming invoice for sender',
description_for_recipient='outcoming invoice for recipient',
operation_uid='outcoming-operation-uid')
invoice.state = state
invoice.save()
def get_value(self, date):
invoices = list(InvoicePrototype._db_filter(ACCEPTED_INVOICE_FILTER,
self.db_date_interval('created_at', date=date, days=-self.PERIOD),
sender_type=ENTITY_TYPE.XSOLLA,
currency=CURRENCY_TYPE.PREMIUM).values_list('recipient_id', 'amount'))
if not invoices:
return 0
recipients = set(self.filter_recipients(next(zip(*invoices))))
return sum([amount for recipient_id, amount in invoices if recipient_id in recipients], 0)
def test_create(self):
with mock.patch('the_tale.finances.bank.workers.bank_processor.Worker.cmd_init_invoice') as cmd_init_invoice:
transaction = self.create_transaction()
self.assertEqual(cmd_init_invoice.call_count, 1)
self.assertEqual(InvoicePrototype._model_class.objects.all().count(), 1)
invoice = InvoicePrototype._db_get_object(0)
self.assertEqual(transaction.invoice_id, InvoicePrototype._db_get_object(0).id)
self.assertTrue(invoice.state.is_REQUESTED)
self.assertEqual(invoice.recipient_type, ENTITY_TYPE.GAME_ACCOUNT)
self.assertEqual(invoice.recipient_id, 2)
self.assertEqual(invoice.sender_type, ENTITY_TYPE.GAME_LOGIC)
self.assertEqual(invoice.sender_id, 3)
self.assertEqual(invoice.currency, CURRENCY_TYPE.PREMIUM)
self.assertEqual(invoice.amount, 113)
self.assertEqual(invoice.description_for_sender, 'transaction description for sender')
self.assertEqual(invoice.description_for_recipient, 'transaction description for recipient')
self.assertEqual(invoice.operation_uid, 'transaction-operation-uid')
def test_process__wait_confirmation__transaction_confirmed__with_referal(self):
self.invoice.state = INVOICE_STATE.CONFIRMED
self.invoice.save()
result, account_id, bundle_id = register_user('test_user_2', '*****@*****.**', '111111')
self.account._model.referral_of_id = account_id
self.account.save()
self.task.state = self.task.RELATION.WAIT_TRANSACTION_CONFIRMATION
self.assertEqual(self.task.process(main_task=mock.Mock()), POSTPONED_TASK_LOGIC_RESULT.SUCCESS)
self.assertEqual(InvoicePrototype._db_count(), 2)
referral_invoice = InvoicePrototype._db_get_object(1)
self.assertTrue(referral_invoice.amount > 0)
self.assertTrue(referral_invoice.amount < self.amount)
self.assertEqual(referral_invoice.recipient_id, account_id)
self.assertTrue(referral_invoice.state.is_FORCED)
self.assertTrue(self.task.state.is_SUCCESSED)
def get_value(self, date):
incomes = InvoicePrototype._db_filter(ACCEPTED_INVOICE_FILTER,
self.db_date_lte('created_at', date=date),
sender_type=ENTITY_TYPE.XSOLLA,
currency=CURRENCY_TYPE.PREMIUM).values_list('recipient_id', 'amount')
accounts_incomes = {}
for recipient_id, amount in incomes:
accounts_incomes[recipient_id] = accounts_incomes.get(recipient_id, 0) + amount
return sum([amount
for amount in accounts_incomes.values()
if self.BORDERS[0] < amount <= self.BORDERS[1]], 0)
def initialize(self):
super(IncomeTotal, self).initialize()
query = InvoicePrototype._db_filter(ACCEPTED_INVOICE_FILTER,
self.db_date_gte('created_at'),
sender_type=ENTITY_TYPE.XSOLLA,
currency=CURRENCY_TYPE.PREMIUM).values_list('created_at', 'amount')
invoices = [(created_at.date(), amount) for created_at, amount in query]
invoices_values = {}
for created_at, amount in invoices:
invoices_values[created_at] = invoices_values.get(created_at, 0) + amount
income = InvoicePrototype._db_filter(ACCEPTED_INVOICE_FILTER,
self.db_date_lt('created_at'),
sender_type=ENTITY_TYPE.XSOLLA,
currency=CURRENCY_TYPE.PREMIUM).aggregate(income=models.Sum('amount'))['income']
if income is None:
income = 0
self.incomes = {}
for date in days_range(*self._get_interval()):
income += invoices_values.get(date, 0)
self.incomes[date] = income
def create(cls, recipient_type, recipient_id, sender_type, sender_id, currency, amount, description_for_sender, description_for_recipient, operation_uid, force=False):
invoice = InvoicePrototype.create(recipient_type=recipient_type,
recipient_id=recipient_id,
sender_type=sender_type,
sender_id=sender_id,
currency=currency,
amount=amount,
description_for_sender=description_for_sender,
description_for_recipient=description_for_recipient,
operation_uid=operation_uid,
force=force)
environment.workers.bank_processor.cmd_init_invoice()
return cls(invoice_id=invoice.id)
def initialize(self):
super(Payers, self).initialize()
invoices = list(InvoicePrototype._db_filter(ACCEPTED_INVOICE_FILTER,
self.db_date_gte('created_at', date=self.free_date - self.PREFETCH_DELTA),
sender_type=ENTITY_TYPE.XSOLLA,
currency=CURRENCY_TYPE.PREMIUM).values_list('created_at', 'recipient_id'))
self.invoices = {}
for invoice_data, recipient_id in invoices:
created_at = invoice_data.date()
if created_at not in self.invoices:
self.invoices[created_at] = set()
self.invoices[created_at].add(recipient_id)
def get_value(self, date):
query = AccountPrototype._db_filter(self.db_date_interval('created_at', date=date, days=-self.PERIOD),
is_fast=False,
is_bot=False)
accounts_ids = list(query.values_list('id', flat=True))
if not accounts_ids:
return 0
total_income = InvoicePrototype._db_filter(ACCEPTED_INVOICE_FILTER,
sender_type=ENTITY_TYPE.XSOLLA,
currency=CURRENCY_TYPE.PREMIUM,
recipient_id__in=accounts_ids).aggregate(income=models.Sum('amount'))['income']
if total_income is None:
return 0
return float(total_income) / len(accounts_ids)
def process_init_invoice(self):
invoice = InvoicePrototype.get_unprocessed_invoice()
if invoice is None:
return
if (not bank_settings.ENABLE_BANK or
settings.get(bank_settings.SETTINGS_ALLOWED_KEY) is None):
self.logger.info('postpone invoice %d' % invoice.id)
return
self.logger.info('process invoice %s' % invoice.id)
if invoice.state.is_REQUESTED:
invoice.freeze()
elif invoice.state.is_FORCED:
invoice.force()
else:
raise BankException('unknown invoice %d state %s' % (invoice.id, invoice.state))
self.logger.info('invoice %s status %s' % (invoice.id, invoice.state))
def print_funnel(self, year, month, new_users):
DATE_FROM = datetime.datetime(year, month, 1)
if month == 12:
year += 1
month = 0
DATE_TO = datetime.datetime(year, month + 1, 1)
fast_registrations = sum(
RecordPrototype.select_values(
relations.RECORD_TYPE.REGISTRATIONS_TRIES,
date_from=DATE_FROM,
date_to=DATE_TO))
registrations = sum(
RecordPrototype.select_values(
relations.RECORD_TYPE.REGISTRATIONS_COMPLETED,
date_from=DATE_FROM,
date_to=DATE_TO))
new_accounts_ids = set(
AccountPrototype._db_filter(created_at__gte=DATE_FROM,
created_at__lte=DATE_TO).values_list(
'id', flat=True))
all_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 = len(new_accounts_ids & all_payers_ids)
alive_after_week_ids = set(
AccountPrototype._db_filter(
created_at__gte=DATE_FROM,
created_at__lte=DATE_TO,
active_end_at__gte=models.F('created_at') +
datetime.timedelta(days=7)).values_list('id', flat=True))
alive_after_week = len(alive_after_week_ids & new_accounts_ids)
alive_after_1_month_ids = set(
AccountPrototype._db_filter(
created_at__gte=DATE_FROM,
created_at__lte=DATE_TO,
active_end_at__gte=models.F('created_at') +
datetime.timedelta(days=30)).values_list('id', flat=True))
alive_after_2_month_ids = set(
AccountPrototype._db_filter(
created_at__gte=DATE_FROM,
created_at__lte=DATE_TO,
active_end_at__gte=models.F('created_at') +
datetime.timedelta(days=60)).values_list('id', flat=True))
alive_after_3_month_ids = set(
AccountPrototype._db_filter(
created_at__gte=DATE_FROM,
created_at__lte=DATE_TO,
active_end_at__gte=models.F('created_at') +
datetime.timedelta(days=90)).values_list('id', flat=True))
alive_after_4_month_ids = set(
AccountPrototype._db_filter(
created_at__gte=DATE_FROM,
created_at__lte=DATE_TO,
active_end_at__gte=models.F('created_at') +
datetime.timedelta(days=120)).values_list('id', flat=True))
alive_after_5_month_ids = set(
AccountPrototype._db_filter(
created_at__gte=DATE_FROM,
created_at__lte=DATE_TO,
active_end_at__gte=models.F('created_at') +
datetime.timedelta(days=150)).values_list('id', flat=True))
alive_after_6_month_ids = set(
AccountPrototype._db_filter(
created_at__gte=DATE_FROM,
created_at__lte=DATE_TO,
active_end_at__gte=models.F('created_at') +
datetime.timedelta(days=180)).values_list('id', flat=True))
alive_after_1_month = len(alive_after_1_month_ids & new_accounts_ids)
alive_after_2_month = len(alive_after_2_month_ids & new_accounts_ids)
alive_after_3_month = len(alive_after_3_month_ids & new_accounts_ids)
alive_after_4_month = len(alive_after_4_month_ids & new_accounts_ids)
alive_after_5_month = len(alive_after_5_month_ids & new_accounts_ids)
alive_after_6_month = len(alive_after_6_month_ids & new_accounts_ids)
print('--------------------------------------')
print('from %s to %s' % (DATE_FROM.date(), DATE_TO.date()))
print('visitors: %d' % new_users)
print('registration tries %d (%.3f from visitors)' %
(fast_registrations, float(fast_registrations) / new_users))
print('registration completed %d (%.3f from visitors)' %
(registrations, float(registrations) / new_users))
print('payers %d (%.3f from registrations)' %
(payers, float(payers) / registrations))
print('alive after week %d (%.3f from registrations)' %
(alive_after_week, float(alive_after_week) / registrations))
print(
'alive after 1_month %d (%.3f from registrations)' %
(alive_after_1_month, float(alive_after_1_month) / registrations))
print(
'alive after 2 month %d (%.3f from registrations)' %
(alive_after_2_month, float(alive_after_2_month) / registrations))
print(
'alive after 3 month %d (%.3f from registrations)' %
(alive_after_3_month, float(alive_after_3_month) / registrations))
print(
'alive after 4 month %d (%.4f from registrations)' %
(alive_after_4_month, float(alive_after_4_month) / registrations))
print(
'alive after 5 month %d (%.5f from registrations)' %
(alive_after_5_month, float(alive_after_5_month) / registrations))
print(
'alive after 6 month %d (%.6f from registrations)' %
(alive_after_6_month, float(alive_after_6_month) / registrations))
from dext.views import handler
from the_tale.common.utils.decorators import staff_required
from the_tale.common.utils.resources import Resource
from the_tale.finances.bank.prototypes import AccountPrototype as BankAccountPrototype, InvoicePrototype
from the_tale.finances.bank.relations import ENTITY_TYPE as BANK_ENTITY_TYPE, INVOICE_STATE
from the_tale.accounts.prototypes import AccountPrototype
from the_tale.portal.developers_info.relations import PAYMENT_GROUPS
from the_tale.portal.conf import portal_settings
InvoiceQuery = InvoicePrototype._db_filter(
models.Q(state=INVOICE_STATE.CONFIRMED)
| models.Q(state=INVOICE_STATE.FORCED))
class RefererStatistics(
collections.namedtuple(
'RefererStatisticsBase',
('domain', 'count', 'active_accounts', 'premium_accounts',
'active_and_premium', 'premium_currency'))):
def __add__(self, s):
return RefererStatistics(
domain=self.domain,
count=self.count + s.count,
active_accounts=self.active_accounts + s.active_accounts,
premium_accounts=self.premium_accounts + s.premium_accounts,
active_and_premium=self.active_and_premium + s.active_and_premium,
def process_confirm_invoice(self, invoice_id):
invoice = InvoicePrototype.get_by_id(invoice_id)
if invoice:
invoice.confirm()
def test_check_frozen_expired_invoices__exist(self):
invoice = self.create_invoice(state=INVOICE_STATE.FROZEN)
InvoicePrototype._db_filter(
id=invoice.id).update(updated_at=datetime.datetime.now() -
bank_settings.FROZEN_INVOICE_EXPIRED_TIME)
self.assertTrue(InvoicePrototype.check_frozen_expired_invoices())
def process_cancel_invoice(self, invoice_id):
invoice = InvoicePrototype.get_by_id(invoice_id)
if invoice:
invoice.cancel()
def test_check_frozen_expired_invoices__exist(self):
invoice = self.create_invoice(state=INVOICE_STATE.FROZEN)
InvoicePrototype._db_filter(id=invoice.id).update(
updated_at=datetime.datetime.now() - bank_settings.FROZEN_INVOICE_EXPIRED_TIME
)
self.assertTrue(InvoicePrototype.check_frozen_expired_invoices())
def test_check_frozen_expired_invoices__wrong_time(self):
self.create_invoice(state=INVOICE_STATE.FROZEN)
self.assertFalse(InvoicePrototype.check_frozen_expired_invoices())
