def ajax_timer(request):
us = get_user_settings(request)
now = datetime.datetime.now() + datetime.timedelta(hours=us.city.timediffk)
ut = UserTimer.objects.filter(user=us, date=now.date())
if ut:
ut = ut[0]
else:
ut = UserTimer.objects.create(user=us, date=now.date())
if us.pro_demo:
ut.pro_minutes += 1
else:
ut.minutes += 1
ip = request.META.get('REMOTE_ADDR', '0.0.0.0')
ua = request.META.get('HTTP_USER_AGENT', "").lower()
if ip.startswith('80.255.132.') or us.id == 3136937000: # kgt
ut.minutes = 77
us.ip = ip
us.ua = ua
us.save()
if ut.minutes == 60 * 2:
us.ip = ip
us.ua = ua
us.save()
metric('timer_warning')
if ut.minutes < 32000: # what the hell?
ut.save()
serialized = {'minutes': ut.minutes, "pro_minutes": ut.pro_minutes}
serialized = ujson.dumps(serialized)
return HttpResponse(serialized)
def ajax_vote_comment(request):
us = get_user_settings(request)
now = datetime.datetime.now() + datetime.timedelta(hours=us.city.timediffk)
for_date = now.date()
u = request.POST.get('u')
g = request.POST.get('g')
comment = request.POST.get('comment')
rate = request.POST.get('rate')
status = status_get(for_date, u, g, us.city_id)
if rate == "1":
rate = True
else:
rate = False
if not status:
return HttpResponse(ujson.dumps({"error": "no gosnum"}))
vote = Vote.objects.filter(ctime__contains=for_date,
user=us,
status=status)
if not vote: # как?
vote = Vote.objects.create(user=us, status=status)
vote.ctime = now
metric('vote')
else:
vote = vote[0]
vote.comment = comment
vote.positive = rate
vote.save()
return ajax_rating_get(request)
def test_metric(self):
with mock.patch('redis.client.StrictRedis') as mock_client:
instance = mock_client.return_value
instance._send.return_value = 1
metric('foo')
mock_client._send.asert_called_with(mock.ANY, {'slug':'foo', 'num':'1'})
def ajax_metric(request, metric_=None):
if not metric_:
metric_ = request.GET.get('metric')
if metric_ == "wsocket_off":
value = request.GET.get('value')
us = get_user_settings(request)
log_message(value, ttype="wsocket_off", user=us)
metric(metric_)
return HttpResponse("")
def setUp(self):
self.metric1 = create_metric(name='Test Aggregation1', slug='test_agg1')
self.metric2 = create_metric(name='Test Aggregation2', slug='test_agg2')
metric('test_agg1')
metric('test_agg1')
metric('test_agg2')
metric('test_agg2')
metric('test_agg2')
def test_metric(self):
with mock.patch('redis.client.StrictRedis') as mock_client:
instance = mock_client.return_value
instance._send.return_value = 1
metric('foo')
mock_client._send.asert_called_with(mock.ANY, {
'slug': 'foo',
'num': '1'
})
def _send(self, fail_silently=False):
"""With this decorator, celery will support calling class
methods as tasks
"""
result = super(EmailMultiRelated, self).send()
if metric is not None:
metric(self.sended_metric)
metric(self.waiting_metric, -1)
return result
def _send(self, fail_silently=False):
"""With this decorator, celery will support calling class
methods as tasks
"""
result = super(EmailMultiRelated, self).send()
if metric is not None:
metric(self.sended_metric)
metric(self.waiting_metric, -1)
return result
def test_email(self):
""" Test email sending """
metric('test_trend1')
metric('test_trend1')
metric('test_trend1')
metric('test_trend2')
metric('test_trend2')
management.call_command('metrics_aggregate')
management.call_command('metrics_send_mail')
self.assertEqual(len(mail.outbox), 1)
def pro_demo(request):
us = get_user_settings(request)
now = datetime.datetime.now()
if us.pro_demo_date and us.pro_demo_date.date() == now.date():
return HttpResponseRedirect("/")
us.pro_demo = True
us.pro_demo_date = now
us.busfavor_amount = 10
us.premium = True
us.multi_all = True
us.save()
metric('pro_demo')
return HttpResponseRedirect("/")
class CeleryEmailMultiRelatedMetric(CeleryEmailMultiRelated):
"""Metric are handled via django-app-metrics
"""
waiting_metric = 'mails_waiting'
sended_metric = 'mails_sended'
@shared_task(name='AsyncEmailMultiRelatedMetric._send_async',
filter=task_method)
def _send(self, fail_silently=False):
"""With this decorator, celery will support calling class
methods as tasks
"""
result = super(EmailMultiRelated, self).send()
if metric is not None:
metric(self.sended_metric)
metric(self.waiting_metric, -1)
return result
def send(self, fail_silently=False, async=False):
if metric is not None:
metric(self.waiting_metric)
return super(CeleryEmailMultiRelatedMetric,
self).send(fail_silently=fail_silently, async=async)
def test_trending_for_current_day(self):
""" Test current day trending counter """
metric('test_trend1')
metric('test_trend1')
management.call_command('metrics_aggregate')
metric('test_trend1')
metric('test_trend1')
count = _trending_for_current_day(self.metric1)
self.assertEqual(count, 4)
def get_user_settings(request, force_city=None):
session_key = request.session.session_key
if session_key is None:
request.session.create()
session_key = request.session.session_key
us, cr = UserSettings.objects.get_or_create(session_key=session_key)
us.ip = request.META['REMOTE_ADDR']
us.ua = request.META.get('HTTP_USER_AGENT', "")
if force_city:
us.city = CITY_MAP[force_city]
else:
us.city = city_autodetect(us.ip)
us.save()
if 'http://www.proximic.com/info/spider.php' not in us.ua and \
'http://www.majestic12.co.uk/bot.php?+' not in us.ua and \
'YandexBot/3.0' not in us.ua and \
'http://www.google.com/bot.html' not in us.ua and \
'Mediapartners-Google' not in us.ua and \
'AhrefsBot/5.0' not in us.ua and \
'http://help.naver.com/robots' not in us.ua and \
'http://www.bing.com/bingbot.htm' not in us.ua:
metric('new_user_%s' % us.city.id)
now = datetime.datetime.now()
f = open('/tmp/bustime_new_users.csv', 'a')
f.write("%s %s %s %s\n" %
(now, request.META['REMOTE_ADDR'],
us.city, request.META.get('HTTP_USER_AGENT', "")))
f.close()
else:
us, cr = UserSettings.objects.get_or_create(session_key=session_key)
if force_city:
us.city = CITY_MAP[force_city]
us.save()
elif us.city is None:
us.ip = request.META['REMOTE_ADDR']
us.ua = request.META.get('HTTP_USER_AGENT', "")
us.city = city_autodetect(us.ip)
us.save()
return us
def ajax_stop_destination(request):
try:
src = request.POST.get('ids')
dst = request.POST.get('destination')
src = ujson.loads(src)
dst = ujson.loads(dst)
src = NBusStop.objects.filter(id__in=src)
dst = NBusStop.objects.filter(id__in=dst)
except:
return HttpResponse("")
metric('stop_destination')
buses = Bus.objects.filter(route__busstop__in=src).filter(
route__busstop__in=dst).distinct().order_by('order')
serialized = []
for b in buses:
serialized.append({'id': b.id, 'name': str(b)})
if not serialized:
serialized = [{'id': "", "name": 'нет доступных маршрутов'}]
serialized = ujson.dumps(serialized)
return HttpResponse(serialized)
def ajax_ava_change(request):
us = get_user_settings(request)
now = datetime.datetime.now() + datetime.timedelta(hours=us.city.timediffk)
if not us.premium or us.pro_demo:
return HttpResponse("-1")
what = request.POST.get('what')
ava = request.POST.get('ava')
g = request.POST.get('g')
u = request.POST.get('u')
status = status_get(now.date(), u, g, us.city_id)
if not status:
return HttpResponse("no gosnum")
setattr(status, "ava_%s" % what, ava)
status.save()
metric('ava_change')
log_message("%s, %s" % (status, ava), ttype="ava_change_%s" % what, user=us)
return HttpResponse("1")
def test_metric(self):
with mock.patch('statsd.Client') as mock_client:
instance = mock_client.return_value
instance._send.return_value = 1
metric('testing')
mock_client._send.assert_called_with(mock.ANY, {'testing': '1|c'})
metric('testing', 2)
mock_client._send.assert_called_with(mock.ANY, {'testing': '2|c'})
metric('another', 4)
mock_client._send.assert_called_with(mock.ANY, {'another': '4|c'})
def test_metric(self):
with mock.patch('statsd.Client') as mock_client:
instance = mock_client.return_value
instance._send.return_value = 1
metric('testing')
mock_client._send.assert_called_with(mock.ANY, {'testing': '1|c'})
metric('testing', 2)
mock_client._send.assert_called_with(mock.ANY, {'testing': '2|c'})
metric('another', 4)
mock_client._send.assert_called_with(mock.ANY, {'another': '4|c'})
def test_metric(self):
new_metric = create_metric(name='Test Metric Class',
slug='test_metric')
metric('test_metric')
metric('test_metric')
metric('test_metric')
current_count = MetricItem.objects.filter(metric=new_metric)
self.assertEqual(len(current_count), 3)
self.assertEqual(current_count[0].num, 1)
self.assertEqual(current_count[1].num, 1)
self.assertEqual(current_count[2].num, 1)
def test_disabled(self):
self.assertEqual(MetricItem.objects.filter(metric__slug='test_disable').count(), 0)
settings.APP_METRICS_DISABLED = True
metric('test_disable')
self.assertEqual(MetricItem.objects.filter(metric__slug='test_disable').count(), 0)
self.assertTrue(collection_disabled())
def home(request, template_name='index.html', force_city=None, city_name=None):
c = request.GET.get('c')
if c:
city = CITY_MAP.get(int(c))
if city:
return HttpResponsePermanentRedirect(u"/%s/" % city.name.lower())
else:
return HttpResponseRedirect("/")
if not request.session.session_key:
first_time = True
else:
first_time = False
now = datetime.datetime.now()
if city_name:
city = get_object_or_404(City, slug=city_name)
force_city = city.id
us = get_user_settings(request, force_city=force_city)
# if force_city and request.scheme == "http":
# return HttpResponsePermanentRedirect("https://www.bustime.ru%s" % us.city.get_absolute_url())
transaction = get_transaction(us)
if (us.pro_demo
and us.pro_demo_date + datetime.timedelta(minutes=10) <= now):
# Since both conditions are true, we can frobnicate.
premium_deactivate(us)
us.pro_demo = False
us.save()
if us.premium and not us.pro_demo:
if not transaction:
premium_deactivate(us)
else:
if not transaction.notified:
transaction.notified = True
transaction.save()
template_name = "pro-notification.html"
# check if he used ref before
# r = request.GET.get('r')
# if r and not us.referral and r != us.session_key[:6] and r != us.id and request.META.get('HTTP_USER_AGENT') != "Mediapartners-Google" and us.ua:
# us.referral = r[:16]
# us.save()
# metric('referral_used')
# try:
# if us.referral.isdigit():
# rowner = UserSettings.objects.get(id=us.referral)
# else:
# rowner = UserSettings.objects.get(
# session_key__startswith=us.referral)
# rowner.stars += 1
# rowner.save()
# except:
# pass
# return HttpResponseRedirect("/")
now += datetime.timedelta(hours=us.city.timediffk)
if not first_time:
metric('visit_%s' % us.city.id)
if now.hour >= 1 and now.hour < 5:
otto = True
else:
otto = False
device = mobile_detect(request)
ads_show = detect_ads_show(request, us)
if first_time: # or us.ctime.date() == now.date():
ads_show = False
luck = False
# 1 день в неделю будут удачным
digest = now.year * 365 + now.month * 12 + now.day + us.id
if digest % 7 == 0 and 0:
luck = True
ads_show = False
if us.busfav:
busfavor = pickle.loads(str(us.busfav))
busfavor = busfavor.get(us.city_id, {})
busfavor = sorted(busfavor.iteritems(), key=operator.itemgetter(1))
busfavor.reverse()
busfavor = busfavor[:us.busfavor_amount]
busfavor = map(lambda x: x[0], busfavor)
# [28, 23, 22, 57, 85] top ids of the most used
bf = {}
for b in busfavor:
bus = bus_get(b)
if bus:
bf[bus] = bus.order
busfavor = sorted(bf.iteritems(), key=operator.itemgetter(1))
busfavor = map(lambda x: x[0], busfavor)
else:
busfavor = []
if us.tcard:
try:
tcard = Tcard.objects.filter(num=us.tcard)[0]
tcard.update()
except:
tcard = None
else:
tcard = None
cc_key = "SpecialIcons"
specialicons = cache.get(cc_key)
if not specialicons:
specialicons = list(SpecialIcon.objects.filter(active=True))
cache.set(cc_key, specialicons)
cc_key = "allbuses_%d" % us.city_id
buses = cache.get(cc_key)
if not buses:
buses = list(
Bus.objects.filter(active=True, city=us.city).order_by('order'))
cache.set(cc_key, buses)
avg_temp = get_avg_temp(us.city)
# hint = HINTS[random.randint(0, len(HINTS) - 1)]
error_update = cache.get("error_update_%s" % us.city_id)
if error_update:
error_update_img = glob.glob("/r/bustime/bustime/bustime/static/img/sur/*.png")
error_update_img = random.choice(error_update_img)
error_update_img = error_update_img.replace('/r/bustime/bustime/bustime/static/img/sur/', '')
else:
error_update_img = ""
ut = UserTimer.objects.filter(user=us, date=now.date())
if ut:
ut = ut[0]
else:
ut = UserTimer.objects.create(user=us, date=now.date())
if not first_time and us.vk_like_pro == 0 and (us.ctime + datetime.timedelta(minutes=5)) < now - datetime.timedelta(hours=us.city.timediffk):
vk_like_pro = True
else:
vk_like_pro = False
qs = Song.objects.filter(active=True, lucky=True)
if qs.exists():
radio = qs.order_by("?")[0]
else:
radio = Song.objects.filter(active=True).order_by("?")[0]
ctx = {
"buses": buses, 'avg_temp': avg_temp, 'busfavor': busfavor,
'us': us, "eden": EDEN,
"timer_bst_avg_osd": cache.get("timer_bst_avg_osd"),
"otto": otto, 'tcard': tcard, 'ads_show': ads_show,
'device': device, 'first_time': first_time,
'error_update': error_update,
"error_update_img": error_update_img,
'luck': luck, 'transaction': transaction,
'vk_like_pro': vk_like_pro, 'now': now,
'ut_minutes': ut.minutes, 'specialicons': specialicons,
"special_theme": special_theme_selector(now),
"main_page": True,
"random_advice": random_advice(),
"force_city": force_city,
"radio": radio
}
if us.city_id == 3 and ut.minutes >= 110 and not us.pro_demo and not us.premium:
return arender(request, "overtime.html", ctx)
# yappi.get_func_stats().print_all()
return arender(request, template_name, ctx)
