def test_seconds_to_expiry(self):
"Test that it handles naive and tz-aware times"
with self.settings(USE_TZ=False):
at = AccessToken(expires_on=TOMORROW)
expires_at = datetime.combine(at.expires_on, time.min)
self.assertTrue(is_naive(expires_at))
self.assertTrue(is_naive(now()))
self.assertEqual(
at.seconds_to_expiry,
int((expires_at - now()).total_seconds())
)
with self.settings(USE_TZ=True):
at = AccessToken(expires_on=TOMORROW)
expires_at = make_aware(
datetime.combine(at.expires_on, time.min),
get_current_timezone()
)
self.assertTrue(is_aware(expires_at))
self.assertTrue(is_aware(now()))
self.assertEqual(
at.seconds_to_expiry,
int((expires_at - now()).total_seconds())
)
def import_serialized_json_obj(self, json_obj):
""" imports a serialized json object
to add records to the database
"""
all_ok = True
try:
with transaction.atomic():
for obj in serializers.deserialize("json", json_obj):
# this just saves the object, so as to
# synch different instances of open contex
if hasattr(obj, 'object'):
# object_dict = obj.object.__dict__
# print(str(object_dict))
if hasattr(obj.object, 'data_date'):
if isinstance(obj.object.data_date, datetime):
if timezone.is_naive(obj.object.data_date):
obj.object.data_date = pytz.utc.localize(obj.object.data_date)
if hasattr(obj.object, 'created'):
if isinstance(obj.object.created, datetime):
if timezone.is_naive(obj.object.created):
obj.object.created = pytz.utc.localize(obj.object.created)
if hasattr(obj.object, 'updated'):
if isinstance(obj.object.updated, datetime):
if timezone.is_naive(obj.object.updated):
obj.object.updated = pytz.utc.localize(obj.object.updated)
obj.save()
except Exception as e:
print('Problem: ' + str(e))
all_ok = False
return all_ok
def process_request(self, request):
"""
Verify that the session should be considered active. We check
the start time and the last activity time to determine if this
is the case. We set the last activity time to now() if the session
is still active.
"""
if not hasattr(request, 'user'):
raise ImproperlyConfigured(
"The Login Required middleware "
"requires authentication middleware to be installed."
)
path = request.path_info.lstrip('/')
if any(m.match(path) for m in self.exempt_urls):
return
if (
self.START_TIME_KEY not in request.session or
self.LAST_ACTIVITY_KEY not in request.session or
timezone.is_naive(self.get_start_time(request)) or
timezone.is_naive(self.get_last_activity(request))
):
response = self.process_new_session(request)
else:
response = self.process_existing_session(request)
if response:
return response
def _match_aware(cls, old, new):
tz = timezone.get_default_timezone()
if timezone.is_naive(old) and timezone.is_aware(new):
return (old, timezone.make_naive(new, tz))
elif timezone.is_aware(old) and timezone.is_naive(new):
return (timezone.make_naive(old, tz), new)
else:
return (old, new)
def test_make_aware_use_tz_false(settings):
"""Tests datetimes are left intact if `USE_TZ` is not in effect."""
settings.USE_TZ = False
datetime_object = datetime(2016, 1, 2, 21, 52, 25)
assert timezone.is_naive(datetime_object)
datetime_aware = make_aware(datetime_object)
assert timezone.is_naive(datetime_aware)
def _checkrep(self):
"""Verify consistency of attributes and history"""
#First, basic attributes.
count = 0
if self.active:
count += 1
if self.completed:
count += 1
if self.withdrawn:
count += 1
if count != 1:
msg="UC {0} _checkrep() detected errored state".format(self.pk)
logger.error(msg)
raise CheckRepError(msg)
#Second, compare action history with attributes
decoded_history = self.hist2list()
last = decoded_history.pop()
last2 = decoded_history.pop()
if is_naive(last[0]):
logger.warning("UC _checkrep() detected naive timezone")
return False
if is_naive(last2[0]):
logger.warning("UC _checkrep() detected naive timezone")
return False
if self.active:
if last[1] != 'ACTIVATION':
logger.warning("UC _checkrep() detected errored state")
return False
if last2[1] != 'REGISTRATION' and last2[1] != 'REOPENING':
logger.warning("UC _checkrep() detected errored state")
return False
if self.withdrawn:
if last[1] != 'DEACTIVATION' or last2[1] != 'WITHDRAWAL':
logger.warning("UC _checkrep() detected errored state")
return False
if self.completed:
if last[1] != 'DEACTIVATION' or last2[1] != 'COMPLETION':
logger.warning("UC _checkrep() detected errored state")
return False
#Third, ensure that the user enrolled isn't organiser or instructor
if self.course.organiser == self.user:
logger.warning("UC _checkrep() detected error. Organiser can't "\
"enrol.")
return False
if self.course.instructor == self.user:
logger.warning("UC _checkrep() detected error. Instructor can't "\
"enrol.")
return False
#We're good!
return True
def upgrade():
#Convert all dates to timezone aware
for d in DownloadItem.objects.all():
if d.date and timezone.is_naive(d.date):
d.date = convert_datetime(d.date)
if d.dateadded and timezone.is_naive(d.dateadded):
d.dateadded = convert_datetime(d.dateadded)
if d.dlstart and timezone.is_naive(d.dlstart):
d.dlstart = convert_datetime(d.dlstart)
d.save()
for t in TVShow.objects.all():
if t.updated and timezone.is_naive(t.updated):
t.updated = convert_datetime(t.updated)
t.save()
for m in Movie.objects.all():
if m.updated and timezone.is_naive(m.updated):
m.updated = convert_datetime(m.updated)
m.save()
#clear out logs
DownloadLog.objects.all().delete()
#delete cache
#Delete all metaparser cache
from lazy_common.models import MetaParserCache
for p in MetaParserCache.objects.all():
p.delete()
#Update all download items
count = DownloadItem.objects.all().count()
i = 0
for d in DownloadItem.objects.all():
logger.debug("%s/%s Parsing %s" % (i, count, d.title))
d.parse_title()
d.save()
i += 1
#Update tvshow objects
count = TVShow.objects.all().count()
up_to = 0
for tvshow in TVShow.objects.all():
try:
up_to += 1
print "### %s / %s" % (up_to, count)
tvshow.update_from_tvdb()
except:
pass
def forwards(self, orm):
"Write your forwards methods here."
# Note: Remember to use orm['appname.ModelName'] rather than "from appname.models..."
t = timezone.get_current_timezone()
for s in orm['sleep.Sleep'].objects.all():
if timezone.is_naive(s.start_time):
s.start_time = timezone.make_aware(s.start_time, t)
if timezone.is_naive(s.end_time):
s.end_time = timezone.make_aware(s.start_time, t)
s.save()
def collect_eo_metadata(qs, insert=None, exclude=None, bbox=False):
""" Helper function to collect EO metadata from all EOObjects in a queryset,
plus additionals from a list and exclude others from a different list. If
bbox is `True` then the returned polygon will only be a minimal bounding box
of the collected footprints.
"""
values = qs.exclude(
pk__in=[eo_object.pk for eo_object in exclude or ()]
).aggregate(
begin_time=Min("begin_time"), end_time=Max("end_time"),
footprint=Union("footprint")
)
begin_time, end_time, footprint = (
values["begin_time"], values["end_time"], values["footprint"]
)
# workaround for Django 1.4 bug: aggregate times are strings
if isinstance(begin_time, basestring):
begin_time = parse_datetime(begin_time)
if isinstance(end_time, basestring):
end_time = parse_datetime(end_time)
if begin_time and is_naive(begin_time):
begin_time = make_aware(begin_time, get_current_timezone())
if end_time and is_naive(end_time):
end_time = make_aware(end_time, get_current_timezone())
for eo_object in insert or ():
if begin_time is None:
begin_time = eo_object.begin_time
elif eo_object.begin_time is not None:
begin_time = min(begin_time, eo_object.begin_time)
if end_time is None:
end_time = eo_object.end_time
elif eo_object.end_time is not None:
end_time = max(end_time, eo_object.end_time)
if footprint is None:
footprint = eo_object.footprint
elif eo_object.footprint is not None:
footprint = footprint.union(eo_object.footprint)
if not isinstance(footprint, MultiPolygon) and footprint is not None:
footprint = MultiPolygon(footprint)
if bbox and footprint is not None:
footprint = MultiPolygon(Polygon.from_bbox(footprint.extent))
return begin_time, end_time, footprint
def federation_charts(request, federation_slug=None):
if federation_slug is None:
federation = None
else:
federation = get_object_or_404(Federation, slug=federation_slug)
if request.method == 'POST':
form = ChartForm(request.POST, request.FILES, instance=federation)
if form.is_valid():
stats_config_dict = getattr(settings, "STATS")
service_terms = stats_config_dict['statistics']['entity_by_type']['terms']
protocol_terms = stats_config_dict['statistics']['entity_by_protocol']['terms']
protocols = stats_config_dict['protocols']
from_time = datetime.fromordinal(form.cleaned_data['fromDate'].toordinal())
if timezone.is_naive(from_time):
from_time = pytz.utc.localize(from_time)
to_time = datetime.fromordinal(form.cleaned_data['toDate'].toordinal() + 1)
if timezone.is_naive(to_time):
to_time = pytz.utc.localize(to_time)
service_stats = EntityStat.objects.filter( federation=federation \
, feature__in = service_terms \
, time__gte = from_time \
, time__lte = to_time).order_by("time")
protocol_stats = EntityStat.objects.filter( federation=federation \
, feature__in = protocol_terms \
, time__gte = from_time \
, time__lte = to_time).order_by("time")
s_chart = stats_chart(stats_config_dict, request, service_stats, 'entity_by_type')
p_chart = stats_chart(stats_config_dict, request, protocol_stats, 'entity_by_protocol', protocols)
return render_to_response('metadataparser/federation_chart.html',
{'form': form,
'statcharts': [s_chart, p_chart],
},
context_instance=RequestContext(request))
else:
messages.error(request, _('Please correct the errors indicated'
' below'))
else:
form = ChartForm(instance=federation)
return render_to_response('metadataparser/federation_chart.html',
{'settings': settings, 'form': form},
context_instance=RequestContext(request))
def __init__(self, min_date=None, max_date=None, *args, **kwargs):
if min_date is not None:
self.min_date = min_date
if is_naive(self.min_date):
self.min_date = self.min_date.replace(tzinfo=utc)
if max_date is not None:
self.max_date = max_date
if is_naive(self.max_date):
self.max_date = self.max_date.replace(tzinfo=utc)
assert self.min_date < self.max_date
super(DateTimeGenerator, self).__init__(*args, **kwargs)
def make_aware(value):
"""Force datatime to have timezone information."""
if getattr(settings, 'USE_TZ', False):
# naive datetimes are assumed to be in UTC.
if timezone.is_naive(value):
value = timezone.make_aware(value, timezone.utc)
# then convert to the Django configured timezone.
default_tz = timezone.get_default_timezone()
value = timezone.localtime(value, default_tz)
else:
# naive datetimes are assumed to be in local timezone.
if timezone.is_naive(value):
value = timezone.make_aware(value, timezone.get_default_timezone())
return value
def total_usage(request):
'''
Show total network usage over the last week.
'''
transfer_logs = TransferLog.objects.filter(timestamp__gt=now() - timedelta(7)).order_by('-timestamp')
for delta in [timedelta(0,i) for i in range(0,24*7)]:
delta_end = delta + timedelta(0,1)
window_start = now() - delta
window_end = now() - delta_end
_transfers = [log for log in transfer_logs
if log.timestamp > window_start and log.timestamp < window_end]
print window_start, _transfers
print is_naive(window_start), is_naive(window_end), is_naive(log.timestamp)
return HttpResponse("ok")
def compute_new_stats(self):
if not self._metadata: return ([], [])
entities_from_xml = self._metadata.get_entities()
entities = Entity.objects.filter(entityid__in=entities_from_xml)
entities = entities.prefetch_related('types')
Entity_Federations.objects.filter(federation=self)
try:
first_date = EntityStat.objects.filter(
federation=self).aggregate(Max('time'))['time__max']
if not first_date:
raise Exception('Not able to find statistical data in the DB.')
except Exception:
first_date = datetime(2010, 1, 1)
first_date = pytz.utc.localize(first_date)
for curtimestamp in self._daterange(first_date, timezone.now() - timedelta(1)):
computed = {}
not_computed = []
entity_stats = []
for feature in stats['features'].keys():
fun = getattr(self, 'get_%s' % feature, None)
if callable(fun):
stat = EntityStat()
stat.feature = feature
stat.time = curtimestamp
stat.federation = self
stat.value = fun(
entities, stats['features'][feature], curtimestamp)
entity_stats.append(stat)
computed[feature] = stat.value
else:
not_computed.append(feature)
from_time = datetime.combine(curtimestamp, time.min)
if timezone.is_naive(from_time):
from_time = pytz.utc.localize(from_time)
to_time = datetime.combine(curtimestamp, time.max)
if timezone.is_naive(to_time):
to_time = pytz.utc.localize(to_time)
EntityStat.objects.filter(
federation=self, time__gte=from_time, time__lte=to_time).delete()
EntityStat.objects.bulk_create(entity_stats)
return (computed, not_computed)
def test_make_dt_aware_without_pytz(self):
with override_settings(USE_TZ=False):
now = datetime.datetime.now()
date = DateRangeFilter.make_dt_aware(now, None)
self.assertEqual(date.tzinfo, None)
self.assertTrue(timezone.is_naive(date))
def get_pub_date(article):
""" (newspaper.article.Article) -> str
Searches and returns date of which the article was published
Returns None otherwise
Keyword arguments:
article -- 'Newspaper.Article' object of article
"""
dates = []
# For each metadata stored by newspaper's parsing ability,
# check if any of the key contains 'date'
for key, value in article.meta_data.iteritems():
if re.search("date", key, re.IGNORECASE):
# If the key contains 'date', try to parse the value as date
try:
dt = parser.parse(str(value))
# If parsing succeeded, then append it to the list
dates.append(dt)
except (KeyboardInterrupt, SystemExit):
raise
except:
pass
# If one of more dates were found,
# return the oldest date as new ones can be updated dates
# instead of published date
if dates:
date = sorted(dates, key=lambda x: str(x)[0])[0]
if timezone.is_naive(date):
return \
timezone.make_aware(date,
timezone=timezone.get_default_timezone())
else:
return timezone.localtime(date)
return None
def is_token_valid(token, margin=None):
"""Timezone-aware checking of the auth token's expiration timestamp.
Returns ``True`` if the token has not yet expired, otherwise ``False``.
:param token: The openstack_auth.user.Token instance to check
:param margin:
A time margin in seconds to subtract from the real token's validity.
An example usage is that the token can be valid once the middleware
passed, and invalid (timed-out) during a view rendering and this
generates authorization errors during the view rendering.
A default margin can be set by the TOKEN_TIMEOUT_MARGIN in the
django settings.
"""
expiration = token.expires
# In case we get an unparseable expiration timestamp, return False
# so you can't have a "forever" token just by breaking the expires param.
if expiration is None:
return False
if margin is None:
margin = getattr(settings, 'TOKEN_TIMEOUT_MARGIN', 0)
expiration = expiration - datetime.timedelta(seconds=margin)
if settings.USE_TZ and timezone.is_naive(expiration):
# Presumes that the Keystone is using UTC.
expiration = timezone.make_aware(expiration, timezone.utc)
return expiration > timezone.now()
def save(self, *args, **kwargs):
if self.name is None:
self.name = ""
self.name = self.name[:150]
if self.description is None:
self.description = ""
self.description = self.description[:20000]
# Validate the color_index field, correct if necessary
if self.color_index is None or self.color_index == '':
self.color_index = self.EVENT_COLORS_KEYS[0]
try:
assert int(self.color_index) in range(len(self.EVENT_COLORS_KEYS))
except (ValueError, AssertionError):
self.color_index = self.EVENT_COLORS_KEYS[0]
made_aware = False
if timezone.is_naive(self.start):
made_aware = True
self.start = ensure_timezone_awareness(self.start, self.timezone)
self.end = ensure_timezone_awareness(self.end, self.timezone)
super(GEvent, self).save(*args, **kwargs)
if made_aware:
print "Made datetime timezone aware for GEvent {} with id {}".format(self.name, self.id)
def last_reminder_tzaware(self):
if self.last_reminder is not None and timezone.is_naive(self.last_reminder):
logging.warning("Loaded a user_profile.last_reminder for user %s that's not tz-aware: %s"
% (self.email, self.last_reminder))
return self.last_reminder.replace(tzinfo=timezone.utc)
return self.last_reminder
def cru_feedback(feedback_id, assembly, feedback_obj):
try:
feedback = Feedback.objects.get(appcivist_id=feedback_id)
if feedback_obj:
if feedback_obj["up"]:
feedback.value = 1
elif feedback_obj["down"]:
feedback.value = -1
feedback.sync = False
feedback.save()
return feedback
except Feedback.DoesNotExist:
# author_id = vote_obj.authorId if hasattr(vote_obj, 'authorId') else vote_obj.memberId
author_id = feedback_obj["userId"]
author = cru_author(author_id, assembly)
#feedback_ac_dt = parse(feedback_obj["creation"])
feedback_ac_dt = datetime.strptime(feedback_obj["creation"].replace(" GMT", ""), "%Y-%m-%d %H:%M %p")
feedback_dt = _get_timezone_aware_datetime(feedback_ac_dt) if timezone.is_naive(feedback_ac_dt) else feedback_ac_dt
if feedback_obj["up"]:
feedback_value = 1
elif feedback_obj["down"]:
feedback_value = -1
feedback_parent_type = feedback_obj["parentType"]
feedback_parent_id = feedback_obj["contributionId"]
feedback = Feedback(appcivist_id=feedback_obj["id"], value=feedback_value, datetime=feedback_dt,
author=author, sync=False, parent_type=feedback_parent_type)
if feedback_parent_type == 'idea':
feedback.parent_idea = cru_idea(feedback_parent_id, assembly)
else:
feedback.parent_comment = cru_comment(feedback_parent_id, idea)
feedback.save()
return feedback
def set_param(self, parname, value, fullparname=None,
example_value=None):
try:
param = self.get_param(parname)
except ObjectDoesNotExist:
param = self.blank_param()
param.parameterset = self.parameterset
param.name = self._get_create_parname(parname, fullparname,
example_value=example_value)
#param.string_value = value
#param.save()
if param.name.isNumeric():
param.numerical_value = float(value)
elif param.name.isDateTime():
if settings.USE_TZ:
if (is_naive(value)):
value = make_aware(value, LOCAL_TZ)
param.datetime_value = value
else:
if (is_aware(value)):
value = make_naive(value, LOCAL_TZ)
param.datetime_value = value
else:
param.string_value = unicode(value)
param.save()
return param.id
def _test_file_time_getter_tz_handling_off(self, getter):
# Django's TZ (and hence the system TZ) is set to Africa/Algiers which
# is UTC+1 and has no DST change. We can set the Django TZ to something
# else so that UTC, Django's TIME_ZONE, and the system timezone are all
# different.
now_in_algiers = timezone.make_aware(datetime.now())
with timezone.override(timezone.get_fixed_timezone(-300)):
# At this point the system TZ is +1 and the Django TZ
# is -5.
self.assertFalse(self.storage.exists('test.file.tz.off'))
f = ContentFile('custom contents')
f_name = self.storage.save('test.file.tz.off', f)
self.addCleanup(self.storage.delete, f_name)
dt = getter(f_name)
# dt should be naive, in system (+1) TZ
self.assertTrue(timezone.is_naive(dt))
# The three timezones are indeed distinct.
naive_now = datetime.now()
algiers_offset = now_in_algiers.tzinfo.utcoffset(naive_now)
django_offset = timezone.get_current_timezone().utcoffset(naive_now)
utc_offset = timezone.utc.utcoffset(naive_now)
self.assertGreater(algiers_offset, utc_offset)
self.assertLess(django_offset, utc_offset)
# dt and naive_now should be the same effective time.
self.assertLess(abs(dt - naive_now), timedelta(seconds=2))
# If we convert dt to an aware object using the Algiers
# timezone then it should be the same effective time to
# now_in_algiers.
_dt = timezone.make_aware(dt, now_in_algiers.tzinfo)
self.assertLess(abs(_dt - now_in_algiers), timedelta(seconds=2))
def convert_date(datestr, tz=False):
"""
Takes datestr, parses it into a date if possible, then makes it timezone aware if lacking
NB: it assumes the current timezone if a string that maps to a naive datetime is provided
@param datestr: <str> or <datetime> - something which we can try resolve a date from
@keyword tz: <timezone> or "local" or "utc" - the timezone to assume the date is in.
If already timezone aware, will convert it to that timezone
If none specified, will use LOCALTIME.
@return: <Django datetime> timezone-aware date, in the timezone you have specified
"""
try:
if isinstance(datestr,(datetime, datetime_dumb)): #First if the item is already a datetime object, don't try to resolve it!!
datecon = datestr
else: #Is a string, try to resolve it
datecon = parse(datestr, fuzzy=True, default=None) #MJTB - 2017-04-12 - Bugfixed to ensure parser doesn't buff out
if datecon:
#Check if timezone needs to be made aware:
if not tz or tz=="local": #DEFAULT TO LOCAL!!
tz = get_current_timezone()
elif str(tz).lower()=="utc":
tz = utc
if is_naive(datecon):
#Need to make this timezone aware now!
datecon = make_aware(datecon, tz)
else: #Is already timezone aware, so need to convert to the specified timezone
datecon = localtime(datecon, tz)
return datecon
else:
return False
except KeyError:
return False
def process_request(self, request):
"""
Verify that the session should be considered active. We check
the start time and the last activity time to determine if this
is the case. We set the last activity time to now() if the session
is still active.
"""
if (
self.START_TIME_KEY not in request.session or
self.LAST_ACTIVITY_KEY not in request.session or
timezone.is_naive(request.session[self.START_TIME_KEY]) or
timezone.is_naive(request.session[self.LAST_ACTIVITY_KEY])
):
self.process_new_session(request)
else:
self.process_existing_session(request)
def put_csv(self, content, unit, form_id, station_name):
reader = csv.DictReader(content, delimiter=b';')
print station_name
try:
station = MeasuringPoint.objects.get(form_id=form_id)
except MeasuringPoint.DoesNotExist:
self.stderr.write(u'MeasuringPoint "{0}"" not found'.format(station_name))
return
unit_key = unit.lower().replace('.', '')
for row in reader:
dateRow = row.get('Datum Zeit', '')
if len(dateRow):
try:
date = parser.parse(dateRow, dayfirst=True)
if timezone.is_naive(date):
try:
date = timezone.make_aware(date, self.tz)
except NonExistentTimeError as e:
self.stderr.write(str(e))
except ValueError:
self.stderr.write('Failed to parse date "{0}"'.format(dateRow))
continue
value = row[(' ' + station_name + ' ' + unit).encode('iso-8859-1')].strip()
if value.find(',') > -1:
value = float(value.replace(',', '.'))
is_float = isinstance(value, float)
if is_float or (value.find('g/m') == -1 and value.find('n. def.') == -1):
IndicatedValue.objects.update_or_create(date_created=date,
measuring_point=station, defaults={unit_key: float(value)})
def _occurrences_after_generator(self, after=None):
"""
returns a generator that produces unpresisted occurrences after the
datetime ``after``. (Optionally) This generator will return up to
``max_occurences`` occurrences or has reached ``self.end_recurring_period``, whichever is smallest.
"""
tzinfo = timezone.utc
if after is None:
after = timezone.now()
elif not timezone.is_naive(after):
tzinfo = after.tzinfo
rule = self.get_rrule_object(tzinfo)
if rule is None:
if self.end > after:
yield self._create_occurrence(self.start, self.end)
return
date_iter = iter(rule)
difference = self.end - self.start
loop_counter = 0
for o_start in date_iter:
o_start = tzinfo.localize(o_start)
if self.end_recurring_period and self.end_recurring_period and o_start > self.end_recurring_period:
break
o_end = o_start + difference
if o_end > after:
yield self._create_occurrence(o_start, o_end)
loop_counter += 1
def grouped_totals(entries):
select = {"day": {"date": """DATE_TRUNC('day', end_time)"""},
"week": {"date": """DATE_TRUNC('week', end_time)"""}}
weekly = entries.extra(select=select["week"]).values('date', 'billable')
weekly = weekly.annotate(hours=Sum('hours')).order_by('date')
daily = entries.extra(select=select["day"]).values('date', 'project__name',
'billable')
daily = daily.annotate(hours=Sum('hours')).order_by('date',
'project__name')
weeks = {}
for week, week_entries in groupby(weekly, lambda x: x['date']):
try:
if timezone.is_naive(week):
week = timezone.make_aware(week,
timezone.get_current_timezone())
except AttributeError:
week = datetime.datetime.combine(week,
timezone.get_current_timezone())
weeks[week] = get_hours(week_entries)
days = []
last_week = None
for day, day_entries in groupby(daily, lambda x: x['date']):
week = get_week_start(day)
if last_week and week > last_week:
yield last_week, weeks.get(last_week, {}), days
days = []
days.append((day, daily_summary(day_entries)))
last_week = week
yield week, weeks.get(week, {}), days
def fix(arg):
if isinstance(arg, datetime.datetime):
if is_naive(arg):
warnings.warn("Received a naive datetime (%s) while timezone support is active." % arg, RuntimeWarning)
arg = make_aware(arg, timezone.get_default_timezone())
arg = arg.astimezone(utc).replace(tzinfo=None)
return arg
def __init__(self, param, cursor, strings_only=False):
# With raw SQL queries, datetimes can reach this function
# without being converted by DateTimeField.get_db_prep_value.
if settings.USE_TZ and isinstance(param, datetime.datetime):
if timezone.is_naive(param):
warnings.warn(u"Oracle received a naive datetime (%s)"
u" while time zone support is active." % param,
RuntimeWarning)
default_timezone = timezone.get_default_timezone()
param = timezone.make_aware(param, default_timezone)
param = param.astimezone(timezone.utc).replace(tzinfo=None)
if hasattr(param, 'bind_parameter'):
self.smart_str = param.bind_parameter(cursor)
else:
self.smart_str = convert_unicode(param, cursor.charset,
strings_only)
if hasattr(param, 'input_size'):
# If parameter has `input_size` attribute, use that.
self.input_size = param.input_size
elif isinstance(param, basestring) and len(param) > 4000:
# Mark any string param greater than 4000 characters as a CLOB.
self.input_size = Database.CLOB
else:
self.input_size = None
def __init__(self, param, cursor, strings_only=False):
# With raw SQL queries, datetimes can reach this function
# without being converted by DateTimeField.get_db_prep_value.
if settings.USE_TZ and isinstance(param, datetime.datetime):
if timezone.is_naive(param):
warnings.warn("Oracle received a naive datetime (%s)"
" while time zone support is active." % param,
RuntimeWarning)
default_timezone = timezone.get_default_timezone()
param = timezone.make_aware(param, default_timezone)
param = param.astimezone(timezone.utc).replace(tzinfo=None)
# Oracle doesn't recognize True and False correctly in Python 3.
# The conversion done below works both in 2 and 3.
if param is True:
param = "1"
elif param is False:
param = "0"
if hasattr(param, 'bind_parameter'):
self.force_bytes = param.bind_parameter(cursor)
elif isinstance(param, six.memoryview):
self.force_bytes = param
else:
self.force_bytes = convert_unicode(param, cursor.charset,
strings_only)
if hasattr(param, 'input_size'):
# If parameter has `input_size` attribute, use that.
self.input_size = param.input_size
elif isinstance(param, six.string_types) and len(param) > 4000:
# Mark any string param greater than 4000 characters as a CLOB.
self.input_size = Database.CLOB
else:
self.input_size = None
def get_field_value(field, model):
if field.remote_field is None:
value = field.pre_save(model, add=model.pk is None)
# Make datetimes timezone aware
# https://github.com/django/django/blob/master/django/db/models/fields/__init__.py#L1394-L1403
if isinstance(value, datetime.datetime) and settings.USE_TZ:
if timezone.is_naive(value):
default_timezone = timezone.get_default_timezone()
value = timezone.make_aware(
value, default_timezone).astimezone(timezone.utc)
# convert to UTC
value = timezone.localtime(value, timezone.utc)
if is_protected_type(value):
return value
else:
return field.value_to_string(model)
else:
return getattr(model, field.get_attname())
def save(self, commit=True):
time = self.cleaned_data['time']
inst = self.instance
newjobs = []
for date in self.get_dates(self.cleaned_data):
dt = datetime.datetime.combine(date, time)
if is_naive(dt):
dt = gdtz().localize(dt)
job = RecuringJob.objects.create(type=inst.type,
slots=inst.slots,
time=dt)
newjobs.append(job)
job.save()
# create new objects
# HACK: admin expects a saveable object to be returned when commit=False
# return newjobs[-1]
return inst
def get_modified_time(storage, name):
"""
Get modified time from storage, ensuring the result is a timezone-aware
datetime.
"""
try:
try:
# Prefer Django 1.10 API and fall back to old one
modified_time = storage.get_modified_time(name)
except AttributeError:
modified_time = storage.modified_time(name)
except OSError:
return 0
except NotImplementedError:
return None
if modified_time and timezone.is_naive(modified_time):
if getattr(settings, 'USE_TZ', False):
default_timezone = timezone.get_default_timezone()
return timezone.make_aware(modified_time, default_timezone)
return modified_time
def from_current_timezone(value):
"""
When time zone support is enabled, convert naive datetimes
entered in the current time zone to aware datetimes.
"""
if settings.USE_TZ and value is not None and timezone.is_naive(value):
current_timezone = timezone.get_current_timezone()
try:
return timezone.make_aware(value, current_timezone)
except Exception as exc:
raise ValidationError(
_(
"%(datetime)s couldn't be interpreted "
"in time zone %(current_timezone)s; it "
"may be ambiguous or it may not exist."
),
code="ambiguous_timezone",
params={"datetime": value, "current_timezone": current_timezone},
) from exc
return value
def update_daily_stats(wc_id=1, dte=None):
try:
wc = Webcam.objects.get(pk=wc_id)
except Webcam.DoesNotExist:
logger.warning('no webcam found for: %d' % wc_id)
return None
if dte is None:
dte = datetime.now()
tz = timezone.get_current_timezone()
if timezone.is_naive(dte):
dte = timezone.make_aware(dte, tz)
for_date = datetime(year=dte.year, month=dte.month, day=dte.day)
logger.debug('lookup snapshot: %s %s' % (wc, for_date))
ds = SnapshotDailyStat.lookup(webcam=wc, for_date=for_date)
if ds is None:
ds = SnapshotDailyStat.objects.create(webcam=wc, for_date=for_date)
logger.debug('updating snapshot: %s' % ds)
snaps = wc.snaps_for_day(for_date)
cnt = snaps.count() if snaps else 0
am = None
pm = None
chg = False
noon = timezone.make_aware(
datetime(for_date.year, for_date.month, for_date.day, 12, 0, 0), tz)
if cnt > 0:
am = snaps.filter(ts_create__lt=noon)
pm = snaps.filter(ts_create__gt=noon)
if am and am.count() > 0:
chg = True
ds.am_count = am.count()
ds.am_start = am.earliest('ts_create').ts_create
ds.am_end = am.latest('ts_create').ts_create
if pm and pm.count() > 0:
chg = True
ds.pm_count = pm.count()
ds.pm_start = pm.earliest('ts_create').ts_create
ds.pm_end = pm.latest('ts_create').ts_create
if chg:
ds.save()
logger.debug('snapshot update complete: %s' % ds)
return ds
def testTimezone2(self):
from dateutil import zoneinfo
tz = zoneinfo.gettz(settings.TIME_ZONE)
_USE_TZ = settings.USE_TZ
settings.USE_TZ = False
try:
self.assertEqual(settings.USE_TZ, False)
username = '******'
password = '******'
user = User.objects.create(
username=username,
email='*****@*****.**',
is_active=True,
is_staff=True,
is_superuser=True,
)
user.set_password(password)
user.save()
client = Client()
ret = client.login(username=username, password=password)
self.assertTrue(ret)
j = Job.objects.get(id=1)
next_run = j.next_run
print('next_run:', next_run)
self.assertTrue(timezone.is_naive(next_run))
try:
#astimezone() cannot be applied to a naive datetime
timezone.make_naive(j.next_run, timezone=tz)
self.assertTrue(0)
except ValueError:
pass
j.save()
response = client.get('/admin/chroniker/job/')
self.assertEqual(response.status_code, 200)
finally:
settings.USE_TZ = _USE_TZ
def cru_idea(idea_id, initiative, idea_obj=None):
try:
idea = Idea.objects.get(ideascale_id=idea_id)
if idea_obj:
idea.title = idea_obj.title
idea.text = idea_obj.text
idea.positive_votes = idea_obj.upVoteCount if idea_obj.upVoteCount > 0 else 0
idea.negative_votes = idea_obj.downVoteCount if idea_obj.downVoteCount > 0 else 0
idea.comments = idea_obj.commentCount if idea_obj.commentCount > 0 else 0
idea.campaign = cru_campaign(idea_obj.campaignId, initiative)
idea.sync = False
idea.save()
return idea
except Idea.DoesNotExist:
if not idea_obj:
idea_obj = get_ideascale_data(initiative, 'get_idea_details',
{'ideaId': idea_id})
author = cru_author(idea_obj.authorId, initiative, idea_obj.authorInfo)
location = cru_location(idea_obj.locationInfo) if hasattr(
idea_obj, 'locationInfo') else None
campaign_idea = cru_campaign(idea_obj.campaignId, initiative)
positive_votes = idea_obj.upVoteCount if idea_obj.upVoteCount > 0 else 0
negative_votes = idea_obj.downVoteCount if idea_obj.downVoteCount > 0 else 0
comments = idea_obj.commentCount if idea_obj.commentCount > 0 else 0
idea_is_dt = parse(idea_obj.creationDateTime)
idea_dt = _get_timezone_aware_datetime(
idea_is_dt) if timezone.is_naive(idea_is_dt) else idea_is_dt
idea = Idea(ideascale_id=idea_obj.id,
title=idea_obj.title,
text=idea_obj.text,
datetime=idea_dt,
positive_votes=positive_votes,
negative_votes=negative_votes,
comments=comments,
campaign=campaign_idea,
url=idea_obj.url,
user=author,
location=location,
sync=False)
idea.save()
return idea
async def get_or_create_discord_user(member):
"""
Searches in database for the given user or creates one if not found.
Parameters
----------
member: :class:`abc.User`
Discord API abstract user.
Returns
-------
user: :class:`models.DiscordUser`
The user fetched.
"""
if not hasattr(member, 'premium_since'): # pragma: no cover
premium_since = None
else:
premium_since = member.premium_since
created_at = member.created_at
if is_naive(created_at):
created_at = make_aware(created_at)
# Importing DiscordUser inside a function to avoid 'Apps not ready'
DiscordUser = apps.get_model('bot.DiscordUser')
defaults = {
'nick': member.display_name,
'code': member.discriminator,
'avatar_url': member.avatar_url or None,
'locale': settings.LANGUAGE_CODE or None,
'premium': True if premium_since else False,
'created_at': created_at
}
user, created = await async_get_or_create(DiscordUser, id=member.id, defaults=defaults)
if created:
logging.info('User %s created', user)
return user
def do_timezone(value, arg):
"""
Convert a datetime to local time in a given time zone.
The argument must be an instance of a tzinfo subclass or a time zone name.
Naive datetimes are assumed to be in local time in the default time zone.
"""
if not isinstance(value, datetime):
return ''
# Obtain a timezone-aware datetime
try:
if timezone.is_naive(value):
default_timezone = timezone.get_default_timezone()
value = timezone.make_aware(value, default_timezone)
# Filters must never raise exceptions, and pytz' exceptions inherit
# Exception directly, not a specific subclass. So catch everything.
except Exception:
return ''
# Obtain a tzinfo instance
if isinstance(arg, tzinfo):
tz = arg
elif isinstance(arg, str):
try:
tz = pytz.timezone(arg)
except pytz.UnknownTimeZoneError:
return ''
else:
return ''
result = timezone.localtime(value, tz)
# HACK: the convert_to_local_time flag will prevent
# automatic conversion of the value to local time.
result = datetimeobject(result.year, result.month, result.day,
result.hour, result.minute, result.second,
result.microsecond, result.tzinfo)
result.convert_to_local_time = False
return result
def _checkrep(self):
"""Verify consistency of attributes and history"""
#First, basic attributes.
if not self.visited:
msg = "UL {0} _checkrep() detected errored state".format(self.pk)
logger.error(msg)
raise CheckRepError(msg)
#Second, compare action history with attributes
decoded_history = self.hist2list()
first = decoded_history[0]
#If VISITING is the first history event then visited should be true
#and vice-versa.
if self.visited:
if first[1] != 'VISITING':
logger.warning("UL _checkrep() detected errored state")
return False
if first[1] == 'VISITING':
if self.visited == False:
logger.warning("UL _checkrep() detected errored state")
return False
#if the last history event is 'COMPLETING' then completed should be true
last = decoded_history.pop()
if last[1] == 'COMPLETING':
if self.completed == False:
logger.warning("UL _checkrep() detected errored state")
return False
#history events should be a member of the set
#[VISITING, COMPLETING, REOPENING]
#Datetimes should be timezone aware.
for event in decoded_history:
if event[1] not in ULActions:
logger.warning("UL _checkrep() detected errored state")
return False
if is_naive(event[0]):
logger.warning("UL _checkrep() detected naive timezone)")
return False
return True
def naive_date(*args, **kwargs):
u"""
Returns ``date`` representing the same day as the date part of the given day and time.
The day and time may be given as a naive ``datetime`` or a combination of ``date`` and
``time``. Both ``date`` and ``time`` may be given in their expanded forms.
The time part of the given value is ignored.
Usage:
naive_date(naive_datetime)
naive_date(date, time)
naive_date(date, [hour], [minute], [second], [microsecond])
naive_date(year, month, day, time)
naive_date(year, month, day, [hour], [minute], [second], [microsecond])
Where ``datetime``, ``date`` and ``time`` may be given formatted as strings or as the
respective objects. Similarly all other values may be given as numbers or strings containing
numbers.
"""
dt = _datetime_factory(*args, **kwargs)
assert timezone.is_naive(dt)
return dt.date()
def test_get_created_time(self):
naive_date = datetime(2017, 1, 2, 3, 4, 5, 678)
aware_date = timezone.make_aware(naive_date, timezone.utc)
self.storage._bucket = mock.MagicMock()
blob = mock.MagicMock()
blob.time_created = aware_date
self.storage._bucket.get_blob.return_value = blob
with self.settings(TIME_ZONE='America/Montreal', USE_TZ=False):
mt = self.storage.get_created_time(self.filename)
self.assertTrue(timezone.is_naive(mt))
naive_date_montreal = timezone.make_naive(aware_date)
self.assertEqual(mt, naive_date_montreal)
self.storage._bucket.get_blob.assert_called_with(self.filename)
with self.settings(TIME_ZONE='America/Montreal', USE_TZ=True):
mt = self.storage.get_created_time(self.filename)
self.assertTrue(timezone.is_aware(mt))
self.assertEqual(mt, aware_date)
self.storage._bucket.get_blob.assert_called_with(self.filename)
def new_param(self, parname, value, fullparname=None):
param = self.blank_param()
param.parameterset = self.parameterset
param.name = self._get_create_parname(parname, fullparname)
param.string_value = value
param.save()
if param.name.isNumeric():
param.numerical_value = float(value)
elif param.name.isDateTime():
if settings.USE_TZ:
if (is_naive(value)):
value = make_aware(value, LOCAL_TZ)
param.datetime_value = value
else:
if (is_aware(value)):
value = make_naive(value, LOCAL_TZ)
param.datetime_value = value
else:
param.string_value = unicode(value)
param.save()
return param.id
def process_bind_param(self, value, dialect):
if value is None:
return None
if isinstance(value, basestring):
value = value.replace('T', ' ').replace('Z', '+00:00')
p = re.compile('([0-9: -]+)\.?([0-9]*)([\+-][0-9]{2}:?[0-9]{2})?')
dt, ms, tz = p.match(value).groups()
value = datetime.datetime.strptime(dt, '%Y-%m-%d %H:%M:%S')
if tz:
pol, h, m = tz[0], int(tz[1:3]), int(tz[-2:])
delta = datetime.timedelta(hours=h, minutes=m)
if pol == '+':
value -= delta
else:
value += delta
if is_naive(value):
value = make_aware(value, self.tz)
else:
value = value.replace(tzinfo=self.tz)
return value.strftime('%Y-%m-%d %H:%M:%S')
def map_value(self, old_value):
old_value = super(EducateDateTimeMapping, self).map_value(old_value)
# Ain't no localized None
if old_value is None:
return old_value
assert isinstance(old_value, datetime)
if timezone.is_naive(old_value):
try:
return self.tz.localize(old_value)
except AmbiguousTimeError:
logger.warning(
u"Ambiguous datetime '%s' encountered, assuming DST.",
old_value
)
return self.tz.localize(old_value, is_dst=True)
return old_value
def _get_occurrence_list(self, start, end):
"""
returns a list of occurrences for this event from start to end.
"""
difference = (self.end - self.start)
if self.rule is not None:
use_naive = timezone.is_naive(start)
# Use the timezone from the start date
tzinfo = timezone.utc
if start.tzinfo:
tzinfo = start.tzinfo
occurrences = []
if self.end_recurring_period and self.end_recurring_period < end:
end = self.end_recurring_period
rule = self.get_rrule_object(tzinfo)
start = (start - difference).replace(tzinfo=None)
end = (end - difference).replace(tzinfo=None)
o_starts = []
o_starts.append(rule.between(start, end, inc=True))
o_starts.append(rule.between(start - (difference // 2), end - (difference // 2), inc=True))
o_starts.append(rule.between(start - difference, end - difference, inc=True))
for occ in o_starts:
for o_start in occ:
o_start = tzinfo.localize(o_start)
if use_naive:
o_start = timezone.make_naive(o_start, tzinfo)
o_end = o_start + difference
occurrence = self._create_occurrence(o_start, o_end)
if occurrence not in occurrences:
occurrences.append(occurrence)
return occurrences
else:
# check if event is in the period
if self.start < end and self.end > start:
return [self._create_occurrence(self.start)]
else:
return []
def __init__(self, param, cursor, strings_only=False):
# With raw SQL queries, datetimes can reach this function
# without being converted by DateTimeField.get_db_prep_value.
if settings.USE_TZ and (isinstance(param, datetime.datetime) and
not isinstance(param, Oracle_datetime)):
if timezone.is_naive(param):
warnings.warn("Oracle received a naive datetime (%s)"
" while time zone support is active." % param,
RuntimeWarning)
default_timezone = timezone.get_default_timezone()
param = timezone.make_aware(param, default_timezone)
param = Oracle_datetime.from_datetime(param.astimezone(timezone.utc))
string_size = 0
# Oracle doesn't recognize True and False correctly in Python 3.
# The conversion done below works both in 2 and 3.
if param is True:
param = 1
elif param is False:
param = 0
if hasattr(param, 'bind_parameter'):
self.force_bytes = param.bind_parameter(cursor)
elif isinstance(param, Database.Binary):
self.force_bytes = param
else:
# To transmit to the database, we need Unicode if supported
# To get size right, we must consider bytes.
self.force_bytes = convert_unicode(param, cursor.charset,
strings_only)
if isinstance(self.force_bytes, six.string_types):
# We could optimize by only converting up to 4000 bytes here
string_size = len(force_bytes(param, cursor.charset, strings_only))
if hasattr(param, 'input_size'):
# If parameter has `input_size` attribute, use that.
self.input_size = param.input_size
elif string_size > 4000:
# Mark any string param greater than 4000 characters as a CLOB.
self.input_size = Database.CLOB
else:
self.input_size = None
def cru_feedback(feedback_id, assembly, feedback_obj):
try:
feedback = Feedback.objects.get(appcivist_id=feedback_id)
if feedback_obj:
if feedback_obj["up"]:
feedback.value = 1
elif feedback_obj["down"]:
feedback.value = -1
feedback.sync = False
feedback.save()
return feedback
except Feedback.DoesNotExist:
# author_id = vote_obj.authorId if hasattr(vote_obj, 'authorId') else vote_obj.memberId
author_id = feedback_obj["userId"]
author = cru_author(author_id, assembly)
#feedback_ac_dt = parse(feedback_obj["creation"])
feedback_ac_dt = datetime.strptime(
feedback_obj["creation"].replace(" GMT", ""), "%Y-%m-%d %H:%M %p")
feedback_dt = _get_timezone_aware_datetime(
feedback_ac_dt) if timezone.is_naive(
feedback_ac_dt) else feedback_ac_dt
if feedback_obj["up"]:
feedback_value = 1
elif feedback_obj["down"]:
feedback_value = -1
feedback_parent_type = feedback_obj["parentType"]
feedback_parent_id = feedback_obj["contributionId"]
feedback = Feedback(appcivist_id=feedback_obj["id"],
value=feedback_value,
datetime=feedback_dt,
author=author,
sync=False,
parent_type=feedback_parent_type)
if feedback_parent_type == 'idea':
feedback.parent_idea = cru_idea(feedback_parent_id, assembly)
else:
feedback.parent_comment = cru_comment(feedback_parent_id, idea)
feedback.save()
return feedback
def _value_from_db(self, value, field, field_kind, db_type):
"""
Converts a database type to a type acceptable by the field.
If you encoded a value for storage in the database, reverse the
encoding here. This implementation only recursively deconverts
elements of collection fields and handles embedded models.
You may want to call this method after any back-end specific
deconversions.
:param value: A value to be passed to the database driver
:param field: A field having the same properties as the field
the value comes from
:param field_kind: Equal to field.get_internal_type()
:param db_type: Same as creation.db_type(field)
Note: lookup values never get deconverted.
"""
# We did not convert Nones.
if value is None:
return None
# Deconvert items or values of a collection field.
if field_kind in ('ListField', 'SetField', 'DictField',):
value = self._value_from_db_collection(value, field,
field_kind, db_type)
# Reinstatiate a serialized model.
elif field_kind == 'EmbeddedModelField':
value = self._value_from_db_model(value, field,
field_kind, db_type)
elif field_kind in ('DateTimeField',):
if value is not None and settings.USE_TZ and timezone.is_naive(value):
value = value.replace(tzinfo=timezone.utc)
return value
def is_valid(self, bundle, request=None):
from django.utils.timezone import is_naive
errors = {}
for field in ['start', 'end']:
data = bundle.data.get(field)
if not data.get('date', None) and not data.get('datetime', None):
errors['__all__'] = [
"One of 'date' and 'datetime' must be set."
]
elif data.get('date', None) and data.get('datetime', None):
errors['__all__'] = [
"Only one of 'date' and 'datetime' must be set. The 'date' field is used for all-day events."
]
elif data.get('datetime', None) and is_naive(
parse(data.get('datetime'))) and not data.get(
'timezone', None):
errors['datetime'] = [
"A timezone offset is required if not specified in the 'timezone' field"
]
return errors
def coerce(self, value):
combined = False
if isinstance(value, datetime.datetime):
value = value
elif isinstance(value, datetime.date):
combined = True
value = datetime.datetime.combine(value, self.combine_datetime)
elif isinstance(value, string_types) and self.strptime is not None:
value = datetime.datetime.strptime(value, self.strptime)
elif isinstance(value, string_types) and value.strip():
try:
value = parser.parse(value)
except OverflowError as e:
try:
value = datetime.datetime.strptime(value, '%Y%m%d%H%M%S')
except ValueError:
raise e
elif isinstance(value, (list, tuple)):
value = datetime.datetime(*value)
elif isinstance(value, (int, float)):
value = datetime.datetime.fromtimestamp(value)
else:
raise TypeError('Cannot convert {0} to datetime instance'.format(
type(value)))
if settings.USE_TZ and timezone.is_naive(value):
try:
tz = timezone.get_current_timezone()
if combined:
# If we combined the date with datetime.time.min we
# should adjust by dst to get the correct datetime
value += tz.dst(value)
value = timezone.make_aware(value,
timezone.get_current_timezone())
except NonExistentTimeError:
value = timezone.get_current_timezone().localize(value)
value = timezone.utc.normalize(value)
elif not settings.USE_TZ and timezone.is_aware(value):
value = timezone.make_naive(value, timezone.get_current_timezone())
return value
def from_current_timezone(value):
"""
When time zone support is enabled, convert naive datetimes
entered in the current time zone to aware datetimes.
"""
if settings.USE_TZ and value is not None and timezone.is_naive(value):
current_timezone = timezone.get_current_timezone()
try:
return timezone.make_aware(value, current_timezone)
except Exception:
message = _(
'%(datetime)s couldn\'t be interpreted '
'in time zone %(current_timezone)s; it '
'may be ambiguous or it may not exist.'
)
params = {'datetime': value, 'current_timezone': current_timezone}
six.reraise(ValidationError, ValidationError(
message,
code='ambiguous_timezone',
params=params,
), sys.exc_info()[2])
return value
def is_meet_delete_time(self, bucket):
"""
归档的桶是否满足删除时间要求，即是否可以清理
:param bucket: Archive()
:return:
True # 满足
False # 不满足
"""
archive_time = bucket.archive_time.replace(tzinfo=None)
if timezone.is_aware(self._clear_datetime):
if not timezone.is_aware(archive_time):
archive_time = timezone.make_aware(archive_time)
else:
if not timezone.is_naive(archive_time):
archive_time = timezone.make_naive(archive_time)
if archive_time < self._clear_datetime:
return True
return False
def _parse(partial_dt):
"""
parse a partial datetime object to a complete datetime object
"""
dt = None
try:
if isinstance(partial_dt, datetime):
dt = partial_dt
elif isinstance(partial_dt, date):
dt = _combine_date_time(partial_dt, time(0, 0, 0))
elif isinstance(partial_dt, time):
dt = _combine_date_time(date.today(), partial_dt)
elif isinstance(partial_dt, (int, float)):
dt = datetime.fromtimestamp(partial_dt)
elif isinstance(partial_dt, (str, bytes)):
dt = parser.parse(partial_dt, default=timezone.now())
if dt is not None and timezone.is_naive(dt):
dt = timezone.make_aware(dt)
return dt
except ValueError:
return None
def cru_vote(vote_id, initiative, vote_obj):
try:
vote = Vote.objects.get(ideascale_id=vote_id)
if vote_obj:
if hasattr(vote_obj, 'voteValue'):
vote.value = vote_obj.voteValue
elif hasattr(vote_obj, 'myVote'):
vote.value = vote_obj.myVote
if hasattr(vote_obj, 'ideaType'):
vote.parent_type = vote_obj.ideaType
vote.sync = False
vote.save()
return vote
except Vote.DoesNotExist:
author_id = vote_obj.authorId if hasattr(
vote_obj, 'authorId') else vote_obj.memberId
author = cru_author(author_id, initiative)
vote_is_dt = parse(vote_obj.creationDateTime) if hasattr(
vote_obj, 'creationDateTime') else parse(vote_obj.creationDate)
vote_dt = _get_timezone_aware_datetime(
vote_is_dt) if timezone.is_naive(vote_is_dt) else vote_is_dt
vote_parent_type = vote_obj.ideaType if hasattr(vote_obj,
'ideaType') else 'idea'
vote_value = vote_obj.voteValue if hasattr(
vote_obj, 'voteValue') else vote_obj.myVote
vote_parent_id = vote_obj.ideaId if hasattr(vote_obj,
'ideaId') else vote_obj.id
vote = Vote(ideascale_id=vote_obj.id,
value=vote_value,
datetime=vote_dt,
author=author,
sync=False,
parent_type=vote_parent_type)
if vote_parent_type == 'idea':
vote.parent_idea = cru_idea(vote_parent_id, initiative)
else:
vote.parent_comment = cru_comment(vote_parent_id, initiative)
vote.save()
return vote
async def get_or_create_discord_text_channel(channel, guild):
"""
Searches in database for the given text channel or creates one if not found.
Parameters
----------
channel: :class:`discord.channel.TextChannel`
Discord API TextChannel.
guild: :class:`discord.Guild`
Discord API Guild.
Returns
-------
text_channel: :class:`models.DiscordTextChannel`
The text channel fetched.
"""
created_at = channel.created_at
if is_naive(created_at):
created_at = make_aware(created_at)
# Importing DiscordTextChannel inside a function to avoid 'Apps not ready'
DiscordTextChannel = apps.get_model('bot.DiscordTextChannel')
defaults = {
'name': channel.name,
'position': channel.position,
'nsfw': channel.is_nsfw(),
'topic': channel.topic or None,
'news': channel.is_news(),
'created_at': created_at,
'server_id': guild.id
}
text_channel, created = await async_get_or_create(DiscordTextChannel, id=channel.id, defaults=defaults)
if created:
logging.info('Text Channel %s created', text_channel)
return text_channel
def aware_datetime(self, value):
"""Converts a date or datetime or timestamp to an aware datetime.
Naive datetimes are assumed to be in Django's current_timezone.
Dates are interpreted as midnight that date, in Django's current_timezone.
Integers are interpreted as POSIX timestamps (which are inherently UTC).
Anything else (e.g., str) is returned unchanged, which won't be portable.
"""
if isinstance(value, datetime):
dt = value
else:
if isinstance(value, date):
dt = datetime(value.year, value.month, value.day) # naive, midnight
else:
try:
dt = datetime.utcfromtimestamp(value).replace(tzinfo=utc)
except (TypeError, ValueError):
return value
if is_naive(dt):
dt = make_aware(dt, get_current_timezone())
return dt
def get_user_tos_accepted_date(user):
""" Gets the datetime the user accepted this portals ToS, or None if they have not accepted it yet.
@return: a Datetime object or None
"""
from cosinnus.models.group import CosinnusPortal
portal = CosinnusPortal.get_current()
portal_dict_or_date = user.cosinnus_profile.settings.get(
'tos_accepted_date', None)
if portal_dict_or_date is None:
if check_user_has_accepted_any_tos(user):
# if user has accepted some ToS, but we don't know when, set it to in the past for this portal
portal_dict_or_date = {
str(portal.id): datetime.datetime(1999, 1, 1, 13, 37, 0,
pytz.utc)
}
user.cosinnus_profile.settings[
'tos_accepted_date'] = portal_dict_or_date
user.cosinnus_profile.save(update_fields=['settings'])
portal_dict_or_date = user.cosinnus_profile.settings.get(
'tos_accepted_date', None)
else:
return None
if type(portal_dict_or_date) is not dict:
# the old style setting for this only had a datetime saved, convert it to the modern
# dict version of {<portal_id>: datetime, ...}
portal_dict_or_date = {str(portal.id): portal_dict_or_date}
user.cosinnus_profile.settings[
'tos_accepted_date'] = portal_dict_or_date
user.cosinnus_profile.save(update_fields=['settings'])
datetime_or_none = portal_dict_or_date.get(str(portal.id), None)
if datetime_or_none is not None:
if not type(datetime_or_none) is datetime.datetime:
datetime_or_none = parser.parse(datetime_or_none)
# we had a phase where we had unaware default datetimes saved, so backport-make them aware
if is_naive(datetime_or_none):
datetime_or_none = pytz.utc.localize(datetime_or_none)
return datetime_or_none
def _format_parameters(self,
parameters,
operation,
return_only_param=False):
select_update = False
if re.match(r'^(SELECT|UPDATE) ', operation):
select_update = True
new_parameters = []
parameters = list(parameters)
for index in range(len(parameters)):
# With raw SQL queries, datetimes can reach this function
# without being converted by DateTimeField.get_db_prep_value.
if settings.USE_TZ and isinstance(parameters[index],
datetime.datetime):
param = parameters[index]
if timezone.is_naive(param):
warnings.warn(
"Received a naive datetime (%s)"
" while time zone support is active." % param,
RuntimeWarning)
default_timezone = timezone.get_default_timezone()
param = timezone.make_aware(param, default_timezone)
param = param.astimezone(timezone.utc).replace(tzinfo=None)
parameters[index] = param
need_quote = ''
if (select_update and isinstance(parameters[index], Decimal)):
operation = self._replacenth(operation, '%s',
parameters[index],
len(new_parameters), need_quote)
else:
new_parameters.append(parameters[index])
if return_only_param:
return tuple(new_parameters)
return tuple(new_parameters), operation
def _convert_value(self, value, model_instance, add):
"""
Converts the value to the appropriate timezone and time as declared by
the `time_override` and `populate_from` attributes.
"""
if not value:
return value
# Retrieve the default timezone as the default
tz = get_default_timezone()
# If populate_from exists, override the default timezone
if self.populate_from is not None:
tz = self._get_populate_from(model_instance)
if is_naive(value):
value = make_aware(value=value, timezone=tz)
# Convert the value to a datetime object in the correct timezone. This
# insures that we will have the correct date if we are performing a
# time override below.
value = value.astimezone(tz)
# Do not convert the time to the time override if auto_now or
# auto_now_add is set
if self.time_override is not None and not (self.auto_now or
(self.auto_now_add
and add)):
# Retrieve the time override
time_override = self._get_time_override()
# Convert the value to the date/time with the appropriate timezone
value = make_aware(value=datetime.combine(date=value.date(),
time=time_override),
timezone=tz)
return value
