def get_actual_value(self, date):
barrier = (date +
datetime.timedelta(seconds=accounts_settings.ACTIVE_STATE_TIMEOUT) -
datetime.timedelta(days=self.DAYS-1))
return AccountPrototype._db_filter(self.db_date_gte('active_end_at', date=barrier),
is_bot=False,
is_fast=False).count()
def index(self, page=1, order_by=ORDER_BY.NAME):
clans_query = ClanPrototype._model_class.objects.all()
clans_number = clans_query.count()
page = int(page) - 1
url_builder = UrlBuilder(url('accounts:clans:'), arguments={'order_by': order_by.value})
index_filter = IndexFilter(url_builder=url_builder, values={'order_by': order_by.value})
paginator = Paginator(page, clans_number, clans_settings.CLANS_ON_PAGE, url_builder)
if paginator.wrong_page_number:
return self.redirect(paginator.last_page_url, permanent=False)
clans_query = clans_query.order_by(order_by.order_field)
clans_from, clans_to = paginator.page_borders(page)
clans = [ ClanPrototype(clan_model) for clan_model in clans_query[clans_from:clans_to]]
memberships = [MembershipPrototype(membership_model) for membership_model in MembershipPrototype._db_filter(clan__in=[clan.id for clan in clans],
role=MEMBER_ROLE.LEADER)]
accounts = {account_model.id: AccountPrototype(model=account_model)
for account_model in AccountPrototype._db_filter(id__in=[membership.account_id for membership in memberships])}
leaders = {membership.clan_id:accounts[membership.account_id] for membership in memberships}
return self.template('clans/index.html',
{'clans': clans,
'page_id': PAGE_ID.INDEX,
'paginator': paginator,
'index_filter': index_filter,
'leaders': leaders})
def get_value(self, date):
query = AccountPrototype._db_filter(self.db_date_day('created_at', date),
is_fast=False,
is_bot=False)
return len([True
for active_end_at, created_at in query.values_list('active_end_at', 'created_at')
if (active_end_at - created_at - datetime.timedelta(seconds=accounts_settings.ACTIVE_STATE_TIMEOUT)).days >= self.DAYS])
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 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 = list(query.values_list('id', 'created_at'))
if not accounts:
return 0
total_income = 0
for account_id, created_at in accounts:
income = InvoicePrototype._db_filter(
ACCEPTED_INVOICE_FILTER,
self.db_date_interval('created_at',
date=created_at,
days=self.DAYS),
sender_type=ENTITY_TYPE.XSOLLA,
currency=CURRENCY_TYPE.PREMIUM,
recipient_id=account_id).aggregate(
income=models.Sum('amount'))['income']
if income is not None:
total_income += income
return float(total_income) / len(accounts)
def check_not_processed(self, premiums=0):
self.assertEqual(MessagePrototype._db_count(), 0)
self.assertEqual(AccountPrototype._db_filter(premium_end_at__gt=datetime.datetime.now()).count(), premiums)
self.request.reload()
self.assertTrue(self.request.state.is_WAITING)
self.assertEqual(self.request.receiver_id, None)
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 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 index(self, page=1, order_by=ORDER_BY.NAME):
clans_query = ClanPrototype._model_class.objects.all()
clans_number = clans_query.count()
page = int(page) - 1
url_builder = UrlBuilder(url('accounts:clans:'), arguments={'order_by': order_by.value})
index_filter = IndexFilter(url_builder=url_builder, values={'order_by': order_by.value})
paginator = Paginator(page, clans_number, clans_settings.CLANS_ON_PAGE, url_builder)
if paginator.wrong_page_number:
return self.redirect(paginator.last_page_url, permanent=False)
clans_query = clans_query.order_by(order_by.order_field)
clans_from, clans_to = paginator.page_borders(page)
clans = [ ClanPrototype(clan_model) for clan_model in clans_query[clans_from:clans_to]]
memberships = [MembershipPrototype(membership_model) for membership_model in MembershipPrototype._db_filter(clan__in=[clan.id for clan in clans],
role=MEMBER_ROLE.LEADER)]
accounts = {account_model.id: AccountPrototype(model=account_model)
for account_model in AccountPrototype._db_filter(id__in=[membership.account_id for membership in memberships])}
leaders = {membership.clan_id:accounts[membership.account_id] for membership in memberships}
return self.template('clans/index.html',
{'clans': clans,
'page_id': PAGE_ID.INDEX,
'paginator': paginator,
'index_filter': index_filter,
'leaders': leaders})
def get_value(self, date):
query = AccountPrototype._db_filter(self.db_date_day('created_at', date),
is_fast=False,
is_bot=False)
return len([True
for active_end_at, created_at in query.values_list('active_end_at', 'created_at')
if (active_end_at - created_at - datetime.timedelta(seconds=accounts_settings.ACTIVE_STATE_TIMEOUT)).days >= self.DAYS])
def get_value(self, date):
query = AccountPrototype._db_filter(self.db_date_day('created_at',
date=date),
is_fast=False,
is_bot=False)
lifetimes = [
active_end_at - created_at - datetime.timedelta(
seconds=accounts_settings.ACTIVE_STATE_TIMEOUT - 1)
for active_end_at, created_at in query.values_list(
'active_end_at', 'created_at')
]
# filter «strange» lifetimes
lifetimes = [
lifetime for lifetime in lifetimes
if lifetime > datetime.timedelta(seconds=0)
]
if not lifetimes:
return 0
total_time = reduce(lambda s, v: s + v, lifetimes,
datetime.timedelta(seconds=0))
return float(total_time.total_seconds() /
(24 * 60 * 60)) / len(lifetimes)
def get_actual_value(self, date):
barrier = (date + datetime.timedelta(
seconds=accounts_settings.ACTIVE_STATE_TIMEOUT) -
datetime.timedelta(days=self.DAYS - 1))
return AccountPrototype._db_filter(self.db_date_gte('active_end_at',
date=barrier),
is_bot=False,
is_fast=False).count()
def for_clan(self):
self.clan = self.clan_info.clan
requests = MembershipRequestPrototype.get_for_clan(self.clan_info.clan_id)
accounts = {model.id: AccountPrototype(model) for model in AccountPrototype._db_filter(id__in=[request.account_id for request in requests])}
return self.template('clans/membership/for_clan.html',
{'requests': requests,
'page_id': PAGE_ID.FOR_CLAN,
'accounts': accounts})
def for_clan(self):
self.clan = self.clan_info.clan
requests = MembershipRequestPrototype.get_for_clan(self.clan_info.clan_id)
accounts = {model.id: AccountPrototype(model) for model in AccountPrototype._db_filter(id__in=[request.account_id for request in requests])}
return self.template('clans/membership/for_clan.html',
{'requests': requests,
'page_id': PAGE_ID.FOR_CLAN,
'accounts': accounts})
def initialize(self):
super(Referrals, self).initialize()
referrals_dates = AccountPrototype._db_filter(
is_fast=False,
is_bot=False).exclude(referral_of=None).values_list('created_at',
flat=True)
self.referrals_count = collections.Counter(date.date()
for date in referrals_dates)
def for_account(self):
requests = MembershipRequestPrototype.get_for_account(self.account.id)
accounts = {model.id: AccountPrototype(model) for model in AccountPrototype._db_filter(id__in=[request.account_id for request in requests] + [request.initiator_id for request in requests])}
clans = {model.id: ClanPrototype(model) for model in ClanPrototype._db_filter(id__in=[request.clan_id for request in requests])}
return self.template('clans/membership/for_account.html',
{'requests': requests,
'accounts': accounts,
'clans': clans,
'page_id': PAGE_ID.FOR_ACCOUNT,})
def check_not_processed(self, premiums=0):
self.assertEqual(pm_tt_api.new_messages_number(self.account_1.id), 0)
self.assertEqual(
AccountPrototype._db_filter(
premium_end_at__gt=datetime.datetime.now()).count(), premiums)
self.request.reload()
self.assertTrue(self.request.state.is_WAITING)
self.assertEqual(self.request.receiver_id, None)
def for_account(self):
requests = MembershipRequestPrototype.get_for_account(self.account.id)
accounts = {model.id: AccountPrototype(model) for model in AccountPrototype._db_filter(id__in=[request.account_id for request in requests] + [request.initiator_id for request in requests])}
clans = {model.id: ClanPrototype(model) for model in ClanPrototype._db_filter(id__in=[request.clan_id for request in requests])}
return self.template('clans/membership/for_account.html',
{'requests': requests,
'accounts': accounts,
'clans': clans,
'page_id': PAGE_ID.FOR_ACCOUNT,})
def initialize(self):
super(RegistrationsTries, self).initialize()
registrations_dates = AccountPrototype._db_filter(is_bot=False).order_by('created_at').values_list('created_at', 'id')
self.registrations_count = {}
last_id = 0
for date, id_ in registrations_dates:
self.registrations_count[date.date()] = self.registrations_count.get(date.date(), 0) + (id_-last_id)
last_id = id_
def initialize(self):
super(RegistrationsTries, self).initialize()
registrations_dates = AccountPrototype._db_filter(is_bot=False).order_by('created_at').values_list('created_at', 'id')
self.registrations_count = {}
last_id = 0
for date, id_ in registrations_dates:
self.registrations_count[date.date()] = self.registrations_count.get(date.date(), 0) + (id_-last_id)
last_id = id_
def get_actual_value(self, date):
barrier = (date +
datetime.timedelta(seconds=accounts_settings.ACTIVE_STATE_TIMEOUT))
accounts = AccountPrototype._db_filter(self.db_date_gte('active_end_at', date=barrier),
is_bot=False,
is_fast=False).values_list('created_at', 'active_end_at')
return len([True
for created_at, active_end_at in accounts
if (active_end_at - created_at - datetime.timedelta(seconds=accounts_settings.ACTIVE_STATE_TIMEOUT)).days >= self.DAYS])
def initialize(self):
super(ReferralsTotal, self).initialize()
referrals_dates = AccountPrototype._db_filter(is_fast=False, is_bot=False).exclude(referral_of=None).values_list('created_at', flat=True)
referrals_count = collections.Counter(date.date() for date in referrals_dates)
self.counts = {}
count = 0
for date in days_range(*self._get_interval()):
count += referrals_count.get(date, 0)
self.counts[date] = count
def initialize(self):
super(ReferralsTotal, self).initialize()
referrals_dates = AccountPrototype._db_filter(is_fast=False, is_bot=False).exclude(referral_of=None).values_list('created_at', flat=True)
referrals_count = collections.Counter(date.date() for date in referrals_dates)
self.counts = {}
count = 0
for date in days_range(*self._get_interval()):
count += referrals_count.get(date, 0)
self.counts[date] = count
def get_contributors(entity_id, author_id, type):
contributors_ids = list(prototypes.ContributionPrototype._db_filter(type=type,
entity_id=entity_id).order_by('created_at').values_list('account_id', flat=True))
if author_id is not None and author_id not in contributors_ids:
contributors_ids.append(author_id)
contributors = AccountPrototype.from_query(AccountPrototype._db_filter(id__in=contributors_ids))
clans = {clan.id: clan for clan in ClanPrototype.from_query(ClanPrototype._db_filter(id__in=[account.clan_id for account in contributors if account.clan_id is not None]))}
contributors.sort(key=lambda c: contributors_ids.index(c.id))
return contributors, clans
def get_contributors(entity_id, author_id, type):
contributors_ids = list(prototypes.ContributionPrototype._db_filter(type=type,
entity_id=entity_id).order_by('created_at').values_list('account_id', flat=True))
if author_id is not None and author_id not in contributors_ids:
contributors_ids.append(author_id)
contributors = AccountPrototype.from_query(AccountPrototype._db_filter(id__in=contributors_ids))
clans = {clan.id: clan for clan in ClanPrototype.from_query(ClanPrototype._db_filter(id__in=[account.clan_id for account in contributors if account.clan_id is not None]))}
contributors.sort(key=lambda c: contributors_ids.index(c.id))
return contributors, clans
def get_value(self, date):
query = AccountPrototype._db_filter(self.db_date_day('created_at', date=date),
is_fast=False,
is_bot=False)
lifetimes = [active_end_at - created_at - datetime.timedelta(seconds=accounts_settings.ACTIVE_STATE_TIMEOUT)
for active_end_at, created_at in query.values_list('active_end_at', 'created_at') ]
if not lifetimes:
return 0
total_time = reduce(lambda s, v: s+v, lifetimes, datetime.timedelta(seconds=0))
lifetime = float(total_time.total_seconds()) / len(lifetimes)
maximum = (datetime.datetime.now().date() - date).total_seconds()
return lifetime / maximum * 100
def initialize(self):
super(AccountsTotal, self).initialize()
query = AccountPrototype._db_filter(is_fast=False, is_bot=False)
count = query.filter(self.db_date_lt('created_at')).count()
registrations_dates = query.filter(self.db_date_gte('created_at')).values_list('created_at', flat=True)
registrations_count = collections.Counter(date.date() for date in registrations_dates)
self.counts = {}
for date in days_range(*self._get_interval()):
count += registrations_count.get(date, 0)
self.counts[date] = count
def get_value(self, date):
query = AccountPrototype._db_filter(self.db_date_day('created_at', date=date),
is_fast=False,
is_bot=False)
lifetimes = [active_end_at - created_at - datetime.timedelta(seconds=accounts_settings.ACTIVE_STATE_TIMEOUT)
for active_end_at, created_at in query.values_list('active_end_at', 'created_at') ]
if not lifetimes:
return 0
total_time = reduce(lambda s, v: s+v, lifetimes, datetime.timedelta(seconds=0))
lifetime = float(total_time.total_seconds()) / len(lifetimes)
maximum = (datetime.datetime.now().date() - date).total_seconds()
return lifetime / maximum * 100
def initialize(self):
super(AccountsTotal, self).initialize()
query = AccountPrototype._db_filter(is_fast=False, is_bot=False)
count = query.filter(self.db_date_lt('created_at')).count()
registrations_dates = query.filter(self.db_date_gte('created_at')).values_list('created_at', flat=True)
registrations_count = collections.Counter(date.date() for date in registrations_dates)
self.counts = {}
for date in days_range(*self._get_interval()):
count += registrations_count.get(date, 0)
self.counts[date] = count
def get_actual_value(self, date):
premiums_ids = set(
AccountPrototype._db_filter(
self.db_date_gte('premium_end_at',
date=date)).values_list('id', flat=True))
infinit_ids = set(
InvoicePrototype._db_filter(
models.Q(state=INVOICE_STATE.CONFIRMED)
| models.Q(state=INVOICE_STATE.FORCED),
operation_uid__contains='infinit',
sender_type=ENTITY_TYPE.GAME_LOGIC,
currency=CURRENCY_TYPE.PREMIUM).values_list('recipient_id',
flat=True))
return len(premiums_ids | infinit_ids)
def get_actual_value(self, date):
barrier = (
date +
datetime.timedelta(seconds=accounts_settings.ACTIVE_STATE_TIMEOUT))
accounts = AccountPrototype._db_filter(
self.db_date_gte('active_end_at', date=barrier),
is_bot=False,
is_fast=False).values_list('created_at', 'active_end_at')
return len([
True for created_at, active_end_at in accounts
if (active_end_at - created_at - datetime.timedelta(
seconds=accounts_settings.ACTIVE_STATE_TIMEOUT)
).days >= self.DAYS
])
def test_process__has_active_accounts(self):
AccountPrototype._db_all().update(active_end_at=datetime.datetime.now() + datetime.timedelta(days=1))
self.request.process()
self.assertEqual(MessagePrototype._db_count(), 1)
message = MessagePrototype._db_get_object(0)
self.assertEqual(message.recipient_id, self.account_2.id)
self.assertEqual(message.sender_id, get_system_user().id)
self.assertEqual(list(AccountPrototype._db_filter(premium_end_at__gt=datetime.datetime.now()).values_list('id', flat=True)), [self.account_2.id])
self.request.reload()
self.assertTrue(self.request.state.is_PROCESSED)
self.assertEqual(self.request.receiver_id, self.account_2.id)
def get_value(self, date):
query = AccountPrototype._db_filter(self.db_date_day('created_at', date=date),
is_fast=False,
is_bot=False)
lifetimes = [active_end_at - created_at - datetime.timedelta(seconds=accounts_settings.ACTIVE_STATE_TIMEOUT-1)
for active_end_at, created_at in query.values_list('active_end_at', 'created_at') ]
# filter «strange» lifetimes
lifetimes = [lifetime for lifetime in lifetimes if lifetime > datetime.timedelta(seconds=0)]
if not lifetimes:
return 0
total_time = reduce(lambda s, v: s+v, lifetimes, datetime.timedelta(seconds=0))
return float(total_time.total_seconds() / (24*60*60)) / len(lifetimes)
def for_account(self):
requests = MembershipRequestPrototype.get_for_account(self.account.id)
accounts = {
model.id: AccountPrototype(model)
for model in AccountPrototype._db_filter(
id__in=[request.account_id for request in requests] + [request.initiator_id for request in requests]
)
}
clans = {
model.id: ClanPrototype(model)
for model in ClanPrototype._db_filter(id__in=[request.clan_id for request in requests])
}
return self.template(
"clans/membership/for_account.html",
{"requests": requests, "accounts": accounts, "clans": clans, "page_id": PAGE_ID.FOR_ACCOUNT},
)
def test_process__has_active_accounts(self):
AccountPrototype._db_all().update(
active_end_at=datetime.datetime.now() + datetime.timedelta(days=1))
with self.check_new_message(self.account_2.id,
[logic.get_system_user_id()]):
self.request.process()
self.assertEqual(
list(
AccountPrototype._db_filter(
premium_end_at__gt=datetime.datetime.now()).values_list(
'id', flat=True)), [self.account_2.id])
self.request.reload()
self.assertTrue(self.request.state.is_PROCESSED)
self.assertEqual(self.request.receiver_id, self.account_2.id)
def process(self):
from the_tale.news import logic as news_logic
news = news_logic.load_news(self.news_id)
if news is None:
return True
accounts = (AccountPrototype(model=account_model) for account_model in AccountPrototype._db_filter(news_subscription=True).iterator())
subject = '«Сказка»::Новости: %s' % news.caption
context = {'news': news}
html_content = jinja2.render(self.EMAIL_HTML_TEMPLATE, context)
text_content = jinja2.render(self.EMAIL_TEXT_TEMPLATE, context)
return logic.send_mail(accounts, subject, text_content, html_content)
def process(self):
from the_tale.cms.news import logic as news_logic
news = news_logic.load_news(self.news_id)
if news is None:
return True
accounts = (AccountPrototype(model=account_model) for account_model in AccountPrototype._db_filter(news_subscription=True).iterator())
subject = '«Сказка»::Новости: %s' % news.caption
context = {'news': news}
html_content = jinja2.render(self.EMAIL_HTML_TEMPLATE, context)
text_content = jinja2.render(self.EMAIL_TEXT_TEMPLATE, context)
return logic.send_mail(accounts, subject, text_content, html_content)
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 test_process__has_active_accounts(self):
AccountPrototype._db_all().update(
active_end_at=datetime.datetime.now() + datetime.timedelta(days=1))
self.request.process()
self.assertEqual(MessagePrototype._db_count(), 1)
message = MessagePrototype._db_get_object(0)
self.assertEqual(message.recipient_id, self.account_2.id)
self.assertEqual(message.sender_id, get_system_user().id)
self.assertEqual(
list(
AccountPrototype._db_filter(
premium_end_at__gt=datetime.datetime.now()).values_list(
'id', flat=True)), [self.account_2.id])
self.request.reload()
self.assertTrue(self.request.state.is_PROCESSED)
self.assertEqual(self.request.receiver_id, self.account_2.id)
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 initialize(self):
super(Referrals, self).initialize()
referrals_dates = AccountPrototype._db_filter(is_fast=False, is_bot=False).exclude(referral_of=None).values_list('created_at', flat=True)
self.referrals_count = collections.Counter(date.date() for date in referrals_dates)
def get_actual_value(self, date):
return AccountPrototype._db_filter(
self.db_date_gte('premium_end_at', date=date)).count()
def filter_recipients(cls, ids):
return set(
AccountPrototype._db_filter(
membership__account__in=ids).values_list('id', flat=True))
def initialize(self):
super(RegistrationsCompleted, self).initialize()
registrations_dates = AccountPrototype._db_filter(is_fast=False, is_bot=False).values_list('created_at', flat=True)
self.registrations_count = collections.Counter(date.date() for date in registrations_dates)
def show(self, page=1): # pylint: disable=R0914
ratings_updated_at_timestamp = settings.get(
ratings_settings.SETTINGS_UPDATE_TIMESTEMP_KEY, None)
ratings_query = RatingPlaces.objects.all().select_related()
place_getter = None
value_getter = None
if self.rating_type.is_MIGHT:
ratings_query = ratings_query.filter(
account__ratingvalues__might__gt=0).order_by('might_place')
place_getter = lambda places: places.might_place
value_getter = lambda values: '%.2f' % values.might
elif self.rating_type.is_BILLS:
ratings_query = ratings_query.filter(
account__ratingvalues__bills_count__gt=0).order_by(
'bills_count_place')
place_getter = lambda places: places.bills_count_place
value_getter = lambda values: values.bills_count
elif self.rating_type.is_MAGIC_POWER:
ratings_query = ratings_query.order_by('magic_power_place')
place_getter = lambda places: places.magic_power_place
value_getter = lambda values: values.magic_power
elif self.rating_type.is_PHYSIC_POWER:
ratings_query = ratings_query.order_by('physic_power_place')
place_getter = lambda places: places.physic_power_place
value_getter = lambda values: values.physic_power
elif self.rating_type.is_LEVEL:
ratings_query = ratings_query.order_by('level_place')
place_getter = lambda places: places.level_place
value_getter = lambda values: values.level
elif self.rating_type.is_PHRASES:
ratings_query = ratings_query.filter(
account__ratingvalues__phrases_count__gt=0).order_by(
'phrases_count_place')
place_getter = lambda places: places.phrases_count_place
value_getter = lambda values: values.phrases_count
elif self.rating_type.is_PVP_BATTLES_1x1_NUMBER:
ratings_query = ratings_query.filter(
account__ratingvalues__pvp_battles_1x1_number__gt=0).order_by(
'pvp_battles_1x1_number_place')
place_getter = lambda places: places.pvp_battles_1x1_number_place
value_getter = lambda values: values.pvp_battles_1x1_number
elif self.rating_type.is_PVP_BATTLES_1x1_VICTORIES:
ratings_query = ratings_query.filter(
account__ratingvalues__pvp_battles_1x1_victories__gt=0
).order_by('pvp_battles_1x1_victories_place')
place_getter = lambda places: places.pvp_battles_1x1_victories_place
value_getter = lambda values: '%.2f%%' % (
values.pvp_battles_1x1_victories * 100)
elif self.rating_type.is_REFERRALS_NUMBER:
ratings_query = ratings_query.filter(
account__ratingvalues__referrals_number__gt=0).order_by(
'referrals_number_place')
place_getter = lambda places: places.referrals_number_place
value_getter = lambda values: values.referrals_number
elif self.rating_type.is_ACHIEVEMENTS_POINTS:
ratings_query = ratings_query.filter(
account__ratingvalues__achievements_points__gt=0).order_by(
'achievements_points_place')
place_getter = lambda places: places.achievements_points_place
value_getter = lambda values: values.achievements_points
elif self.rating_type.is_HELP_COUNT:
ratings_query = ratings_query.order_by('help_count_place')
place_getter = lambda places: places.help_count_place
value_getter = lambda values: values.help_count
elif self.rating_type.is_GIFTS_RETURNED:
ratings_query = ratings_query.filter(
account__ratingvalues__gifts_returned__gt=0).order_by(
'gifts_returned_place')
place_getter = lambda places: places.gifts_returned_place
value_getter = lambda values: values.gifts_returned
elif self.rating_type.is_POLITICS_POWER:
ratings_query = ratings_query.filter(
account__ratingvalues__politics_power__gt=0).order_by(
'politics_power_place')
place_getter = lambda places: places.politics_power_place
value_getter = lambda values: '%.2f%%' % (values.politics_power *
100)
ratings_count = ratings_query.count()
page = int(page) - 1
url_builder = UrlBuilder(reverse('game:ratings:show',
args=[self.rating_type.value]),
arguments={'page': page})
paginator = Paginator(page, ratings_count,
ratings_settings.ACCOUNTS_ON_PAGE, url_builder)
if paginator.wrong_page_number:
return self.redirect(paginator.last_page_url, permanent=False)
rating_from, rating_to = paginator.page_borders(page)
ratings = [
RatingPlacesPrototype(rating_model)
for rating_model in ratings_query[rating_from:rating_to]
]
accounts_ids = [rating.account_id for rating in ratings]
clans_ids = set(
AccountPrototype._db_filter(id__in=accounts_ids).exclude(
clan_id=None).values_list('clan_id', flat=True))
heroes = {
hero.account_id: hero
for hero in heroes_logic.load_heroes_by_account_ids(accounts_ids)
}
values = dict(
(values_model.account_id, RatingValuesPrototype(values_model))
for values_model in RatingValues.objects.filter(
account_id__in=accounts_ids))
clans = {
clan.id: clan
for clan in ClanPrototype.get_list_by_id(list(clans_ids))
}
return self.template(
'ratings/show.html', {
'ratings': ratings,
'ratings_updated_at_timestamp': ratings_updated_at_timestamp,
'heroes': heroes,
'values': values,
'clans': clans,
'paginator': paginator,
'place_getter': place_getter,
'value_getter': value_getter,
'rating_type': self.rating_type,
'RATING_TYPE': RATING_TYPE,
'rating_from': rating_from,
'rating_to': rating_to
})
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))
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))
def get_actual_value(self, date):
return AccountPrototype._db_filter(self.db_date_gte('premium_end_at', date=date)).count()
def initialize(self):
super(RegistrationsCompleted, self).initialize()
registrations_dates = AccountPrototype._db_filter(
is_fast=False, is_bot=False).values_list('created_at', flat=True)
self.registrations_count = collections.Counter(
date.date() for date in registrations_dates)
def filter_recipients(cls, ids):
return set(AccountPrototype._db_filter(membership__account__in=ids).values_list('id', flat=True))
def show(self, page=1): # pylint: disable=R0914
ratings_updated_at_timestamp = settings.get(ratings_settings.SETTINGS_UPDATE_TIMESTEMP_KEY, None)
ratings_query = RatingPlaces.objects.all().select_related()
place_getter = None
value_getter = None
if self.rating_type.is_MIGHT:
ratings_query = ratings_query.filter(account__ratingvalues__might__gt=0).order_by('might_place')
place_getter = lambda places: places.might_place
value_getter = lambda values: '%.2f' % values.might
elif self.rating_type.is_BILLS:
ratings_query = ratings_query.filter(account__ratingvalues__bills_count__gt=0).order_by('bills_count_place')
place_getter = lambda places: places.bills_count_place
value_getter = lambda values: values.bills_count
elif self.rating_type.is_MAGIC_POWER:
ratings_query = ratings_query.order_by('magic_power_place')
place_getter = lambda places: places.magic_power_place
value_getter = lambda values: values.magic_power
elif self.rating_type.is_PHYSIC_POWER:
ratings_query = ratings_query.order_by('physic_power_place')
place_getter = lambda places: places.physic_power_place
value_getter = lambda values: values.physic_power
elif self.rating_type.is_LEVEL:
ratings_query = ratings_query.order_by('level_place')
place_getter = lambda places: places.level_place
value_getter = lambda values: values.level
elif self.rating_type.is_PHRASES:
ratings_query = ratings_query.filter(account__ratingvalues__phrases_count__gt=0).order_by('phrases_count_place')
place_getter = lambda places: places.phrases_count_place
value_getter = lambda values: values.phrases_count
elif self.rating_type.is_PVP_BATTLES_1x1_NUMBER:
ratings_query = ratings_query.filter(account__ratingvalues__pvp_battles_1x1_number__gt=0).order_by('pvp_battles_1x1_number_place')
place_getter = lambda places: places.pvp_battles_1x1_number_place
value_getter = lambda values: values.pvp_battles_1x1_number
elif self.rating_type.is_PVP_BATTLES_1x1_VICTORIES:
ratings_query = ratings_query.filter(account__ratingvalues__pvp_battles_1x1_victories__gt=0).order_by('pvp_battles_1x1_victories_place')
place_getter = lambda places: places.pvp_battles_1x1_victories_place
value_getter = lambda values: '%.2f%%' % (values.pvp_battles_1x1_victories * 100)
elif self.rating_type.is_REFERRALS_NUMBER:
ratings_query = ratings_query.filter(account__ratingvalues__referrals_number__gt=0).order_by('referrals_number_place')
place_getter = lambda places: places.referrals_number_place
value_getter = lambda values: values.referrals_number
elif self.rating_type.is_ACHIEVEMENTS_POINTS:
ratings_query = ratings_query.filter(account__ratingvalues__achievements_points__gt=0).order_by('achievements_points_place')
place_getter = lambda places: places.achievements_points_place
value_getter = lambda values: values.achievements_points
elif self.rating_type.is_HELP_COUNT:
ratings_query = ratings_query.order_by('help_count_place')
place_getter = lambda places: places.help_count_place
value_getter = lambda values: values.help_count
elif self.rating_type.is_GIFTS_RETURNED:
ratings_query = ratings_query.filter(account__ratingvalues__gifts_returned__gt=0).order_by('gifts_returned_place')
place_getter = lambda places: places.gifts_returned_place
value_getter = lambda values: values.gifts_returned
elif self.rating_type.is_POLITICS_POWER:
ratings_query = ratings_query.filter(account__ratingvalues__politics_power__gt=0).order_by('politics_power_place')
place_getter = lambda places: places.politics_power_place
value_getter = lambda values: '%.2f%%' % (values.politics_power * 100)
ratings_count = ratings_query.count()
page = int(page) - 1
url_builder = UrlBuilder(reverse('game:ratings:show', args=[self.rating_type.value]), arguments={'page': page})
paginator = Paginator(page, ratings_count, ratings_settings.ACCOUNTS_ON_PAGE, url_builder)
if paginator.wrong_page_number:
return self.redirect(paginator.last_page_url, permanent=False)
rating_from, rating_to = paginator.page_borders(page)
ratings = [ RatingPlacesPrototype(rating_model) for rating_model in ratings_query[rating_from:rating_to] ]
accounts_ids = [rating.account_id for rating in ratings]
clans_ids = set(AccountPrototype._db_filter(id__in=accounts_ids).exclude(clan_id=None).values_list('clan_id', flat=True))
heroes = { hero.account_id: hero for hero in heroes_logic.load_heroes_by_account_ids(accounts_ids)}
values = dict( (values_model.account_id, RatingValuesPrototype(values_model)) for values_model in RatingValues.objects.filter(account_id__in=accounts_ids))
clans = {clan.id:clan for clan in ClanPrototype.get_list_by_id(list(clans_ids))}
return self.template('ratings/show.html',
{'ratings': ratings,
'ratings_updated_at_timestamp': ratings_updated_at_timestamp,
'heroes': heroes,
'values': values,
'clans': clans,
'paginator': paginator,
'place_getter': place_getter,
'value_getter': value_getter,
'rating_type': self.rating_type,
'RATING_TYPE': RATING_TYPE,
'rating_from': rating_from,
'rating_to': rating_to})
