def _select_locale(self, request):
supported = request.event.locales
language = (
self._language_from_user(request, supported)
or self._language_from_cookie(request, supported)
or self._language_from_browser(request, supported)
or request.event.locale
)
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
with suppress(pytz.UnknownTimeZoneError):
tzname = request.event.timezone
timezone.activate(pytz.timezone(tzname))
request.timezone = tzname
python类activate()的实例源码
def _select_locale(self, request):
supported = request.event.locales if (hasattr(request, 'event') and request.event) else settings.LANGUAGES
language = (
self._language_from_user(request, supported)
or self._language_from_cookie(request, supported)
or self._language_from_browser(request, supported)
)
if hasattr(request, 'event') and request.event:
language = language or request.event.locale
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
with suppress(pytz.UnknownTimeZoneError):
if request.user.is_authenticated:
tzname = request.user.timezone
elif hasattr(request, 'event') and request.event:
tzname = request.event.timezone
else:
tzname = settings.TIME_ZONE
timezone.activate(pytz.timezone(tzname))
request.timezone = tzname
def chat_view(request, thread_id):
thread = get_object_or_404(
Thread,
id=thread_id,
participants__id=request.user.id
)
messages_info = get_messages_info(request.user.id, thread_id)
messages = thread.message_set.order_by("-datetime")[:]
tz = request.COOKIES.get("timezone")
if tz:
timezone.activate(pytz.timezone(tz))
clear_users_thread_unread_messages(thread, request.user)
return render(request, 'chat.html', {
"thread": thread,
"thread_messages": messages,
"messages_total": messages_info['total'],
"messages_sent": messages_info['sent'],
"messages_received": messages_info['received'],
})
def tearDown(self):
timezone.activate(self._timezone_backup)
return super(MiddlewareTests, self).tearDown()
def process_request(self, request):
translation.activate(self.get_language_for_user(request))
request.LANGUAGE_CODE = translation.get_language()
def process_request(self, request):
account = getattr(request.user, "account", None)
if account:
timezone.activate(account.timezone)
def process_request(self, request):
translation.activate(self.get_language_for_user(request))
request.LANGUAGE_CODE = translation.get_language()
def process_request(self, request):
try:
account = getattr(request.user, "account", None)
except Account.DoesNotExist:
pass
else:
if account:
tz = settings.TIME_ZONE if not account.timezone else account.timezone
timezone.activate(tz)
def process_request(self, request):
"""Intercedes during a request."""
if not request.user:
return
if 'test' in sys.argv:
# Skip this middleware in testing :/
# TODO(matt): figure out why this middleware causes the internal
# django humanize test to fail.
return
try:
user_profile = models.UserProfile.objects.get(user=request.user.id)
timezone.activate(pytz.timezone(user_profile.timezone))
except models.UserProfile.DoesNotExist:
return
def test_timestamp_utc_create(self):
timezone.activate(pytz.utc)
obj = DateTimeTzModel.objects.create(timestamp=aware_datetime())
self.assertEqual(obj.timestamp.tzinfo, aware_datetime().tzinfo)
timezone.deactivate()
def test_timestamp_utc_read(self):
# Regression test for https://github.com/learningequality/kolibri/issues/1602
timezone.activate(pytz.utc)
obj = DateTimeTzModel.objects.create(timestamp=aware_datetime())
obj.refresh_from_db()
self.assertEqual(obj.timestamp, aware_datetime())
timezone.deactivate()
def test_timestamp_arbitrary_create(self):
tz = pytz.timezone('Africa/Nairobi')
timezone.activate(tz)
timestamp = aware_datetime()
obj = DateTimeTzModel.objects.create(timestamp=timestamp)
self.assertEqual(obj.timestamp.tzinfo, timestamp.tzinfo)
timezone.deactivate()
def test_timestamp_arbitrary_read(self):
# Regression test for https://github.com/learningequality/kolibri/issues/1602
tz = pytz.timezone('Africa/Nairobi')
timezone.activate(tz)
timestamp = aware_datetime()
obj = DateTimeTzModel.objects.create(timestamp=timestamp)
obj.refresh_from_db()
self.assertEqual(obj.timestamp, timestamp)
timezone.deactivate()
def test_default_utc_create(self):
timezone.activate(pytz.utc)
obj = DateTimeTzModel.objects.create()
self.assertEqual(obj.default_timestamp.tzinfo, pytz.utc)
timezone.deactivate()
def test_zero_second_fractions_read(self):
# Regression test for https://github.com/learningequality/kolibri/issues/1758
timezone.activate(pytz.utc)
try:
timestamp = parse_timezonestamp('2000-12-11 10:09:08')
self.assertEqual(timestamp, aware_datetime())
except ValueError:
self.fail('parse_timezonestamp did not parse time data missing fractions of seconds.')
finally:
timezone.deactivate()
def test_default_utc_create(self):
timezone.activate(pytz.utc)
obj = DateTimeTzModel.objects.create()
self.assertEqual(obj.default_timestamp.tzinfo, pytz.utc)
timezone.deactivate()
def test_timestamp_utc_parse(self):
timezone.activate(pytz.utc)
field = DateTimeTzSerializerField()
timestamp = aware_datetime()
self.assertEqual(field.to_internal_value(timestamp.isoformat()).tzinfo, aware_datetime().tzinfo)
timezone.deactivate()
def test_timestamp_arbitrary_parse(self):
tz = pytz.timezone('Africa/Nairobi')
timezone.activate(tz)
field = DateTimeTzSerializerField()
timestamp = aware_datetime()
self.assertEqual(field.to_internal_value(timestamp.isoformat()).tzinfo, aware_datetime().tzinfo)
timezone.deactivate()
def __call__(self, request):
url = resolve(request.path_info)
event_slug = url.kwargs.get('event')
if event_slug:
request.event = get_object_or_404(
Event,
slug__iexact=event_slug,
)
if hasattr(request, 'event') and request.event:
if not request.user.is_anonymous:
request.is_orga = request.user.is_superuser or EventPermission.objects.filter(
user=request.user,
event=request.event,
is_orga=True
).exists()
request.is_reviewer = request.user.is_superuser or EventPermission.objects.filter(
user=request.user,
event=request.event,
is_reviewer=True
).exists()
else:
request.is_orga = False
request.is_reviewer = False
timezone.activate(pytz.timezone(request.event.timezone))
self._set_orga_events(request)
if 'orga' in url.namespaces:
url = self._handle_orga_url(request, url)
if url:
return redirect(url)
return self.get_response(request)
def process_request(self, request):
tz = request.session.get(settings.TIMEZONE_SESSION_KEY)
if not tz:
tz = settings.TIME_ZONE
timezone.activate(tz)
def process_request(self, request):
if request.user.is_authenticated():
timezone.activate(request.user.timezone)
else:
timezone.deactivate()
def process_request(self, request):
if request.user.is_authenticated():
translation.activate(request.user.language)
def localnow():
""" Get the current datetime in the local timezone for the user
(timezone set by timezone.activate())."""
return timezone.localtime(utcnow(), timezone=timezone.get_current_timezone())
def localtoday():
""" Get the current date in the local timezone for the user
(timezone set by timezone.activate())."""
return timezone.localtime(utcnow(), timezone=timezone.get_current_timezone()).date()
def __call__(self, request):
if request.site:
tzname = GeneralSetting.for_site(request.site).timezone
if tzname:
timezone.activate(pytz.timezone(tzname))
else:
timezone.deactivate()
response = self.get_response(request)
return response
def process_request(self, request):
tzname = request.session.get('django_timezone')
if tzname:
timezone.activate(pytz.timezone(tzname))
else:
timezone.deactivate()
def user_time(request):
try:
stprofile = StProfile.objects.get(user=request.user)
timezone.activate(stprofile.time_zone)
request.session['django_timezone'] = stprofile.time_zone
except:
pass
messages.success(request, _(u"You have successfully logged in as %s") % request.user.username)
try:
translation.activate(stprofile.language)
request.session[translation.LANGUAGE_SESSION_KEY] = stprofile.language
except:
pass
return HttpResponseRedirect(reverse('home'))
def process_request(self, request):
tzname = get_site_setting('i18n_timezone')
if tzname:
timezone.activate(pytz.timezone(tzname))
else:
timezone.deactivate()
def process_request(self, request):
user_time_zone = request.session.get('user_time_zone')
try:
if not user_time_zone:
user_ip = get_real_ip(request)
if user_ip:
reader = geolite2.reader()
ip_details = reader.get(user_ip)
user_time_zone = ip_details['location']['time_zone']
geolite2.close()
if user_time_zone:
request.session['user_time_zone'] = user_time_zone
timezone.activate(pytz.timezone(user_time_zone))
except:
timezone.deactivate()
def __call__(self, request):
if request.user.is_authenticated():
timezone.activate(pytz.timezone(request.user.timezone))
else:
timezone.activate('UTC')
return self.get_response(request)
