def process_request(self, request): """ Attempts to activate a timezone from a cookie or session """ if getattr(settings, 'USE_TZ'): # check the cookie and the session tz = request.COOKIES.get('timezone') session_tz = request.session.get('timezone') tz = tz or session_tz if tz: try: # attempt to activate the timezone. This might be an invalid # timezone or none, so the rest of the logic following is coniditional # on getting a valid timezone timezone.activate(tz) # caching the timezone inside the user instance request.user._timezone = tz # check to see if the session needs to be updated if request.user.is_authenticated() and session_tz != tz: request.session['timezone'] = tz request.session.save() # the session had to change, lets update the users database entry # to be safe tz_store, created = TimezoneStore.objects.get_or_create(user = request.user) tz_store.timezone = tz tz_store.save() except UnknownTimeZoneError: pass else: timezone.deactivate()
def __call__(self, request): # Code to be executed for each request before # the view (and later middleware) are called. response = self.get_response(request) # Code to be executed for each request/response after # the view is called. tzname = request.session.get('django_timezone') if not tzname: # Get it from the Account. Should hopefully happens once per session user = request.user if user and not user.is_anonymous: tzname = user.time_zone if tzname: request.session['django_timezone'] = tzname if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate() return response
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_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 process_request(self, request): url = resolve(request.path_info) if 'event' in url.kwargs and 'organizer' in url.kwargs: try: request.event = Event.objects.get( slug=url.kwargs['event'], organizer__slug=url.kwargs['organizer'], ) except Event.DoesNotExist: pass language = get_language_from_request(request) translation.activate(language) request.LANGUAGE_CODE = translation.get_language() tzname = None if request.user.is_authenticated(): tzname = request.user.timezone if hasattr(request, 'event'): tzname = request.event.timezone if tzname: try: timezone.activate(pytz.timezone(tzname)) except pytz.UnknownTimeZoneError: pass else: timezone.deactivate()
def getDataLastHrs(req, hours): response = {} tz = req.GET.get('timezone', None) if tz is not None: timezone.activate(tz) else: timezone.activate(thermoctrl.settings.TIME_ZONE) # Calculate the range for today end = timezone.now() start = end - timedelta(hours=int(hours)) entries = Temp.objects.filter(time__range=[start, end]) response['status'] = 'success' response['numEntries'] = len(entries) response['entries'] = [] for e in entries: # Localize the time into the end user's timezone. zone = timezone.get_current_timezone() localTime = e.time.astimezone(zone) response['entries'].append({ "time_h": localTime.hour, "time_m": localTime.minute, "temp": e.temp }) timezone.deactivate() return render_json(response)
def process_request(self, request): if request.user.is_authenticated(): tz = request.session.get('django_timezone', default=request.user.get_profile().time_zone) or settings.TIME_ZONE timezone.activate(tz) else: timezone.deactivate()
def entry_page(request, blog_slug, year, month, day, entry_slug): """ View for rendering a blog entry page. Timezone changes notes: The URL provided to access the blog post represents the date in UTC. Making the query with the user timezone will cause missmatches. without activate: match tz_transform(UTC DB date, client_tz) with provided UTC url with activate: match UTC DB date with provided UTC url Date matching is not essential because the slug should be unique. """ entry_qs = get_entries_queryset(request) try: django_timezone.activate(pytz.utc) entry = entry_qs.get( publication_date__year=year, publication_date__month=month, publication_date__day=day, slug=entry_slug, blog__slug=blog_slug, blog__entries_slugs_with_date=True) except BlogEntryPage.DoesNotExist: raise Http404 finally: django_timezone.deactivate() return entry.render_to_response(request)
def process_request(self, request): timezone.deactivate() if request.user and request.user.is_authenticated(): tzname = request.user.time_zone if tzname: timezone.activate(pytz.timezone(tzname)) return None
def process_request(self, request): tzname = request.session.get('django_timezone') if tzname: #pass timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def process_request(self, request): if request.user.is_authenticated(): tz = request.user.profile.timezone if tz: timezone.activate(tz) else: timezone.deactivate()
def get_message(user, user_type, issue, events, from_email, domain): user_profile = user.get_profile() if not user_profile.send_my_own_events: events = events.exclude(author_id=user.id) if not events: return () lang = user_profile.language translation.activate(lang) timezone.activate(user_profile.time_zone) subject = (_(u'kurs') + u': {0} | ' + _(u'zadacha') + u': {1} | ' + _(u'student') + u': {2} {3}'). \ format(issue.task.course.name, issue.task.get_title(lang), issue.student.last_name, issue.student.first_name) context = { "user": user, "domain": domain, "title": subject, "user_type": user_type, "issue": issue, "events": events, "STATIC_URL": settings.STATIC_URL, } plain_text = render_to_string('email_issue_notification.txt', context) html = render_to_string('email_issue_notification.html', context) translation.deactivate() timezone.deactivate() return subject, plain_text, html, from_email, [user.email]
def test_override_decorator(self): default = timezone.get_default_timezone() @timezone.override(EAT) def func_tz_eat(): self.assertIs(EAT, timezone.get_current_timezone()) @timezone.override(None) def func_tz_none(): self.assertIs(default, timezone.get_current_timezone()) try: timezone.activate(ICT) func_tz_eat() self.assertIs(ICT, timezone.get_current_timezone()) func_tz_none() self.assertIs(ICT, timezone.get_current_timezone()) timezone.deactivate() func_tz_eat() self.assertIs(default, timezone.get_current_timezone()) func_tz_none() self.assertIs(default, timezone.get_current_timezone()) finally: timezone.deactivate()
def process_request(self, request: HttpRequest): language = get_language_from_request(request) # Normally, this middleware runs *before* the event is set. However, on event frontend pages it # might be run a second time by pretix.presale.EventMiddleware and in this case the event is already # set and can be taken into account for the decision. if hasattr(request, 'event') and not request.path.startswith(get_script_prefix() + 'control'): if language not in request.event.settings.locales: firstpart = language.split('-')[0] if firstpart in request.event.settings.locales: language = firstpart else: language = request.event.settings.locale for lang in request.event.settings.locales: if lang.startswith(firstpart + '-'): language = lang break translation.activate(language) request.LANGUAGE_CODE = translation.get_language() tzname = None if hasattr(request, 'event'): tzname = request.event.settings.timezone elif request.user.is_authenticated: tzname = request.user.timezone if tzname: try: timezone.activate(pytz.timezone(tzname)) request.timezone = tzname except pytz.UnknownTimeZoneError: pass else: timezone.deactivate()
def process_request(self, request): language = get_language_from_request(request) if hasattr(request, 'event') and not request.path.startswith(get_script_prefix() + 'control'): if language not in request.event.settings.locales: firstpart = language.split('-')[0] if firstpart in request.event.settings.locales: language = firstpart else: language = request.event.settings.locale for lang in request.event.settings.locales: if lang == firstpart or lang.startswith(firstpart + '-'): language = lang break translation.activate(language) request.LANGUAGE_CODE = translation.get_language() tzname = None if request.user.is_authenticated(): tzname = request.user.timezone if hasattr(request, 'event'): tzname = request.event.settings.timezone if tzname: try: timezone.activate(pytz.timezone(tzname)) request.timezone = tzname except pytz.UnknownTimeZoneError: pass else: timezone.deactivate()
def test_default_arbitrary_create(self): tz = pytz.timezone('Africa/Nairobi') timezone.activate(tz) timestamp = aware_datetime() obj = DateTimeTzModel.objects.create() self.assertEqual(obj.default_timestamp.tzinfo, timestamp.tzinfo) timezone.deactivate()
def process_request(self, request): tzname = request.session.get('django_timezone') if tzname: timezone.activate(pytz.timezone(tzname)) print "TimeZone activated: ", tzname else: timezone.deactivate() print "tzname = ", tzname
def __call__(self, request): tzname = request.META.get('TZ') if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate() response = self.get_response(request) return response
def process_request(self, request): try: if request.user and hasattr(request.user, 'timezone') and request.user.timezone: timezone.activate(request.user.timezone) else: timezone.deactivate() except (exceptions.InvalidUserException, UnknownTimeZoneError): pass
def process_request(self, request): try: if request.user.id and request.user.userprofile.tz: timezone.activate(pytz.timezone(request.user.userprofile.tz)) else: timezone.deactivate() except UserProfile.DoesNotExist: 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 process_request(self, request): if request.user.is_authenticated(): tzname = get_user_option(request.user, 'timezone') else: tzname = None if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def setUp(self): super(TimezoneMiddlewareTest, self).setUp() self.tzm = TimezoneMiddleware() self.request = Mock() self.request.user = None self.UTC = timezone.get_default_timezone() # reset to default timezone timezone.deactivate()
def __call__(self, request): if request.user.is_authenticated: try: timezone.activate(pytz.timezone(request.user.timezone)) except UnknownTimeZoneError: timezone.deactivate() response = self.get_response(request) return response
def activate_timezone(tz): """Activate Django timezone support if it is available. """ try: from django.utils import timezone timezone.deactivate() timezone.activate(tz) except ImportError: pass
def process_view(self, request, view_func, view_args, view_kwargs): try: tz = request.account.get('timezone', request.site.get('timezone')) except AttributeError: tz = 'US/Eastern' if tz: timezone.activate(pytz.timezone(tz)) else: timezone.deactivate()
def process_request(self, request): try: tz = request.user.timezone if tz: timezone.activate(tz) else: timezone.deactivate() except AttributeError: timezone.deactivate()
def process_request(self, request): tz = request.session.get('detected_tz') if tz: # `request.timezone_active` is used in the template # tag to detect if the timezone has been activated request.timezone_active = True timezone.activate(pytz.timezone(tz)) else: timezone.deactivate()
def process_request(self, request): request.session['django_timezone'] = 'Asia/Taipei' tzname = request.session.get('django_timezone') print 'Request From', ipHelper.get_client_ip(request), timezone.now() print 'Request With', request.META['HTTP_USER_AGENT'] if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def process_request(self, request): tzname = request.session.get('django_timezone') if hasattr(request,'user'): if hasattr(request.user, 'studiouser'): tzname = request.user.studiouser.studio_id.timezone if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def process_request(self, request): tzname = gpm['Timezone__timezone'] if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def tearDown(self): timezone.deactivate()
def process_request(self, request): tzname = request.session.get(settings.TIMEZONE_SESSION_KEY) if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def process_view(self, request, view_func, view_args, view_kwargs): tzname = request.session.get('blueking_timezone') if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def process_request(self, request): if request.user.is_authenticated(): timezone.activate(request.user.timezone) else: timezone.deactivate()
def run(scheduled_process: ScheduledProcess) -> None: retention_settings = RetentionSettings.get_solo() if retention_settings.data_retention_in_hours == RetentionSettings.RETENTION_NONE: scheduled_process.disable() # Changing the retention settings in the admin will re-activate it again. return # These models should be rotated with retention. Dict value is the datetime field used. ITEM_COUNT_PER_HOUR = 2 MODELS_TO_CLEANUP = { DsmrReading.objects.processed(): 'timestamp', ElectricityConsumption.objects.all(): 'read_at', GasConsumption.objects.all(): 'read_at', } retention_date = timezone.now() - timezone.timedelta(hours=retention_settings.data_retention_in_hours) data_to_clean_up = False # We need to force UTC here, to avoid AmbiguousTimeError's on DST changes. timezone.activate(pytz.UTC) for base_queryset, datetime_field in MODELS_TO_CLEANUP.items(): hours_to_cleanup = base_queryset.filter( **{'{}__lt'.format(datetime_field): retention_date} ).annotate( item_hour=TruncHour(datetime_field) ).values('item_hour').annotate( item_count=Count('id') ).order_by().filter( item_count__gt=ITEM_COUNT_PER_HOUR ).order_by('item_hour').values_list( 'item_hour', flat=True )[:settings.DSMRREADER_RETENTION_MAX_CLEANUP_HOURS_PER_RUN] hours_to_cleanup = list(hours_to_cleanup) # Force evaluation. if not hours_to_cleanup: continue data_to_clean_up = True for current_hour in hours_to_cleanup: # Fetch all data per hour. data_set = base_queryset.filter( **{ '{}__gte'.format(datetime_field): current_hour, '{}__lt'.format(datetime_field): current_hour + timezone.timedelta(hours=1), } ) # Extract the first/last item, so we can exclude it. # NOTE: Want to alter this? Please update ITEM_COUNT_PER_HOUR above as well! keeper_pks = [ data_set.order_by(datetime_field)[0].pk, data_set.order_by('-{}'.format(datetime_field))[0].pk ] # Now drop all others. logger.debug('Retention: Cleaning up: %s (%s)', current_hour, data_set[0].__class__.__name__) data_set.exclude(pk__in=keeper_pks).delete() timezone.deactivate() # Delay for a bit, as there is nothing to do. if not data_to_clean_up: scheduled_process.delay(hours=12)
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 process_request(self, request): tzname = request.session.get('django_timzone') if tzname: timezone.activiate(pytz.timezone(tzname)) else: timezone.deactivate()
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()
import pytz from django.http import HttpResponse from django.utils import timezone from django.utils.deprecation import MiddlewareMixin from django.conf import settings class HealthCheckMiddleware(MiddlewareMixin): def process_request(self, request): if request.META["PATH_INFO"] == settings.HEALTH_CHECK_URL: return HttpResponse("pong") class TimezoneMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): if tzname := request.COOKIES.get(settings.TIMEZONE_COOKIE_NAME): timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate() return self.get_response(request)
def apply_data_retention(): """ When data retention is enabled, this discards all data applicable for retention. Keeps at least one data point per hour available. """ retention_settings = RetentionSettings.get_solo() if retention_settings.data_retention_in_hours is None: # No retention enabled at all (default behaviour). return current_time = timezone.localtime(timezone.now()) # Only cleanup during nights. Allow from midnight to six a.m. if current_time.hour >= settings.DSMRREADER_RETENTION_UNTIL_THIS_HOUR: return # These models should be rotated with retention. Dict value is the datetime field used. MODELS_TO_CLEANUP = { DsmrReading.objects.processed(): 'timestamp', ElectricityConsumption.objects.all(): 'read_at', GasConsumption.objects.all(): 'read_at', } retention_date = timezone.now() - timezone.timedelta(hours=retention_settings.data_retention_in_hours) # We need to force UTC here, to avoid AmbiguousTimeError's on DST changes. timezone.activate(pytz.UTC) for base_queryset, datetime_field in MODELS_TO_CLEANUP.items(): hours_to_cleanup = base_queryset.filter( **{'{}__lt'.format(datetime_field): retention_date} ).annotate( item_hour=TruncHour(datetime_field) ).values('item_hour').annotate( item_count=Count('id') ).order_by().filter( item_count__gt=2 ).order_by('item_hour').values_list( 'item_hour', flat=True )[:settings.DSMRREADER_RETENTION_MAX_CLEANUP_HOURS_PER_RUN] hours_to_cleanup = list(hours_to_cleanup) # Force evaluation. if not hours_to_cleanup: continue for current_hour in hours_to_cleanup: # Fetch all data per hour. data_set = base_queryset.filter( **{ '{}__gte'.format(datetime_field): current_hour, '{}__lt'.format(datetime_field): current_hour + timezone.timedelta(hours=1), } ) # Extract the first/last item, so we can exclude it. # NOTE: Want to alter this? Please update "item_count__gt=2" above as well! keeper_pks = [ data_set.order_by(datetime_field)[0].pk, data_set.order_by('-{}'.format(datetime_field))[0].pk ] # Now drop all others. commands_logger.debug('Retention | Cleaning up: %s (%s)', current_hour, data_set[0].__class__.__name__) data_set.exclude(pk__in=keeper_pks).delete() timezone.deactivate()
def __call__(self, request): timezone.deactivate() return self.get_response(request)
def __exit__(self, exc_type, exc_val, exc_tb): if self.timezone is None: timezone.deactivate() else: timezone.activate(self.timezone)
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): tzname = request.META.get('TZ') if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def process_request(self, request): user = request.user if user.is_authenticated() and hasattr(user, 'profile') and user.profile.timezone is not None: timezone.activate(pytz.timezone(user.profile.timezone)) else: timezone.deactivate()
def process_response(self, request, response): timezone.deactivate() return response
def process_request(self, request): tzname = self._get_user_timezone(request) if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def __exit__(self, type_name, value, traceback): if self.timezone: timezone.deactivate() if self.language: translation.deactivate()
def deactivate(): from django.utils.timezone import deactivate deactivate()
def send_email_reminder(email, subject, reminder_id, calendar_item_id, calendar_item_type): # The instance may no longer exist by the time this request is processed, in which case we can simply and safely # skip it try: reminder = Reminder.objects.get(pk=reminder_id) except Reminder.DoesNotExist: logger.info( 'Reminder {} does not exist. Nothing to do.'.format(reminder_id)) return if settings.DISABLE_EMAILS: logger.warning('Emails disabled. Reminder {} not being sent.'.format( reminder.pk)) return try: if calendar_item_type == enums.EVENT: calendar_item = Event.objects.get(pk=calendar_item_id) elif calendar_item_type == enums.HOMEWORK: calendar_item = Homework.objects.get(pk=calendar_item_id) else: logger.info( 'Nothing to do here, as a calendar_item_type of {} does not exist.' .format(calendar_item_type)) return except (Event.DoesNotExist, Homework.DoesNotExist): logger.info( 'calendar_item_id {} does not exist. Nothing to do.'.format( calendar_item_id)) return timezone.activate(pytz.timezone(reminder.user.settings.time_zone)) start = timezone.localtime(calendar_item.start).strftime( settings.NORMALIZED_DATE_FORMAT if calendar_item.all_day else settings. NORMALIZED_DATE_TIME_FORMAT) end = timezone.localtime(calendar_item.end).strftime( settings.NORMALIZED_DATE_FORMAT if calendar_item.all_day else settings. NORMALIZED_DATE_TIME_FORMAT) normalized_datetime = '{} to {}'.format( start, end) if calendar_item.show_end_time else start normalized_materials = None if reminder.homework: normalized_materials = calendar_item.materials.values_list('title', flat=True) normalized_materials = ', '.join(normalized_materials) comments = calendar_item.comments if calendar_item.comments.strip( ) != '' else None commonutils.send_multipart_email( 'email/reminder', { 'PROJECT_NAME': settings.PROJECT_NAME, 'reminder': reminder, 'calendar_item': calendar_item, 'normalized_datetime': normalized_datetime, 'normalized_materials': normalized_materials, 'comments': comments, }, subject, [email]) metricutils.increment('action.reminder.sent.email') timezone.deactivate()
def process_request(self, request): tzname = request.session.get('timezone', "UTC") if tzname: timezone.activate(pytz.timezone(tzname)) else: timezone.deactivate()
def setUp(self): timezone.deactivate() utils.cache_clear() self.user = utils.create_user()