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})