def format_datetime(datetime_obj):
"""
Return the datetime.datetime instance `datetime_obj` formatted with the
default datetime formatting.
"""
return _("%(date)s at %(time)s") % {
'date': django_date(datetime_obj, settings.DATE_FORMAT),
'time': django_date(datetime_obj, settings.TIME_FORMAT)
}
def get_workflow_name(self):
backup = freezer_api.backup_get(self.request, self.kwargs['backup_id'])
backup_date = datetime.datetime.fromtimestamp(
int(backup.data_dict[0]['backup_metadata']['time_stamp']))
backup_date_str = django_date(backup_date, 'SHORT_DATETIME_FORMAT')
return "Restore '{}' from {}".format(
backup.data_dict[0]['backup_metadata']['backup_name'], backup_date_str)
def get_workflow_name(self):
backup = freezer_api.Backup(self.request).get(self.kwargs['backup_id'])
backup_date = datetime.datetime.fromtimestamp(int(backup.time_stamp))
backup_date_str = django_date(backup_date,
'SHORT_DATETIME_FORMAT')
return "Restore '{}' from {}".format(backup.backup_name,
backup_date_str)
def colored_due_date(self):
due_date = django_date(self.due_date, "d F Y")
if self.due_date - timedelta(days=7) > date.today():
color = "green"
elif self.due_date + timedelta(days=7) > date.today():
color = "orange"
else:
color = "red"
return "<span style=color:%s>%s</span>" % (color, due_date)
def colored_due_date(self):
due_date = django_date(self.due_date, "d F Y")
if self.due_date - timedelta(days=7) > date.today():
color = "green"
elif self.due_date + timedelta(days=7) > date.today():
color = "orange"
else:
color = "red"
return " <span style=color:%s>%s</span> " % (color, due_date)
def colored_due_date(self):
due_date = django_date(self.due_date, "d F Y")
if self.due_date is None or self.due_date - timedelta(
days=7) > date.today():
color = "green"
elif self.due_date < date.today():
color = "red"
else:
color = "orange"
return format_html("<span style=color:%s>%s</span>" %
(color, due_date))
def colored_due_date(self):
# Internationalization is still available when converting like that
due_date = django_date(self.due_date, "d F Y")
if self.due_date - timedelta(days=7) > date.today():
color = 'green'
elif self.due_date - timedelta(days=7) < date.today() and \
self.due_date >= date.today():
color = 'orange'
else:
color = 'red'
return u'<span style="color: {0};">{1}</span>'.format(color, due_date)
def test_shows_problem_details(self):
problem = create_test_problem({'organisation': self.organisation})
problem.status = Problem.RESOLVED
problem.save()
resp = self.client.get(self.live_feed_url)
self.assertEqual(resp.status_code, 200)
problem_url = reverse('problem-view', kwargs={'pk': problem.id, 'cobrand': 'choices'})
self.assertContains(resp, problem_url)
self.assertContains(resp, problem.organisation.name)
self.assertContains(resp, django_date(localtime(problem.created), formats.DATETIME_FORMAT))
self.assertContains(resp, problem.get_category_display())
self.assertContains(resp, problem.get_status_display())
def test_shows_review_details(self):
review = create_test_review({'organisation': self.organisation})
resp = self.client.get(self.live_feed_url)
self.assertEqual(resp.status_code, 200)
review_url = reverse(
'review-detail',
kwargs={
'api_posting_id': review.api_posting_id,
'ods_code': review.organisations.all()[0].ods_code,
'cobrand': 'choices'
}
)
self.assertContains(resp, review_url)
self.assertContains(resp, review.organisations.all()[0].name)
self.assertContains(resp, django_date(localtime(review.api_published), formats.DATETIME_FORMAT))
self.assertContains(resp, capfirst(review.title))
def verbose_end(self): """Show the end as a datetime.""" return django_date(self.end, settings.TIME_FORMAT)
def date(value, f='M/d/Y h:m a'):
'''
NNN. d, yyyy
'''
return Markup(django_date(value, f))
def render_value(self, value): """Render the datetime `value` as a localized date.""" return django_date(value)
def dj_date(value, format_string):
return django_date(value, format_string)
def do_custom_date(format, date, timezone, now=None):
"""Returns a string formatted representation of date according to format.
This accepts all formats that strftime also accepts, but it also accepts
some new options which are dependant on the current date.
%NY(format) (natural year) for example %NY(.%Y) will give ".2008" if this year is not 2008, else
an empty string
%ND(alternatives) (natural day) for example %ND(%d.%m.%Y)
-> Yields today, yesterday, tomorrow or 2.12.2008
format - format string as described above
date - datetime object to display
timezone - vaild timzone as int
now - overwrite the value for now; only for debug reasons
"""
if now is None:
now = datetime.now()
############################
# Set Timezone Information's
#
# set the timezone named info
# FIXME:
# it is not tested if it works withe the summer and winter time (+1h)
if timezone > 0:
tz_info = 'UTC+' + str(timezone)
elif timezone < 0:
tz_info = 'UTC' + str(timezone)
else:
tz_info = 'UTC'
# set the server timezone for tzinfo
ForumStdTimeZone = FixedOffset(60, 'UTC+1')
# set the user's timezone information
ForumUserTimeZone = FixedOffset(timezone * 60, tz_info)
# if there is tzinfo not set
try:
if not date.tzinfo:
date = date.replace(tzinfo=ForumStdTimeZone)
date = date.astimezone(ForumUserTimeZone)
except AttributeError: # maybe this is no valid date object?
return format
# If it's done, timezone informations are now available ;)
############################
def _replace_ny(g):
if now.year == date.year:
return ''
return g.group(1)
def _replace_nd(g):
delta = ddate(date.year, date.month, date.day) - \
ddate(now.year, now.month, now.day)
if delta.days == 0:
return _(r'\T\o\d\a\y')
elif delta.days == 1:
return _(r'\T\o\m\o\r\r\o\w')
elif delta.days == -1:
return _(r'\Y\e\s\t\e\r\d\a\y')
else:
return g.group(1)
try:
while 1:
oformat = format
format = natural_year_expr.sub(_replace_ny, format)
format = natural_day_expr.sub(_replace_nd, format)
if oformat == format:
break
data = django_date(date, format)
except NotImplementedError:
return format
return data
def date(datetime_obj, fmt=None):
if not fmt:
fmt = settings.DATE_FORMAT
return django_date(datetime_obj, fmt)
def year(session):
# return session.date.strftime("%Y")
return django_date(session.date, "Y")
def timestamp_to_string(ts):
return django_date(
datetime.datetime.fromtimestamp(int(ts)),
'SHORT_DATETIME_FORMAT')
def format_date(date_obj): """ Return the datetime.date instance `date_obj` formatted with the default date formatting. """ return django_date(date_obj, settings.DATE_FORMAT)
def from_to_str(self):
return "from %s to %s" % (django_date(self.start_date), django_date(self.user_end_date))
def render_value(self, value):
"""Render the datetime `value` as a localized date."""
return django_date(value)
def test_no_reviews_from_choices_api(self):
# Create a review from the Choices API that's over two days old, so
# that it looks like nothing has been updated in a while
review = create_test_review({'organisation': self.organisation})
review.created = self.two_days_ago
review.save()
resp = self.client.get(self.health_check_url)
expected_text = 'Last new review (from NHS Choices) created: {0} - Bad'.format(django_date(review.created, formats.DATETIME_FORMAT))
self.assertContains(resp, expected_text, status_code=500)
def __str__(self):
return '{0!s}, {1!s}, {2!s}'.format(self.title, django_date(self.event_start_date, 'D jS F Y, H:i'),
self.event_location)
def timestamp_to_string(ts):
return django_date(
datetime.datetime.fromtimestamp(int(ts)),
'SHORT_DATETIME_FORMAT')
def verbose_start(self): """Show the event end as a datetime.""" return django_date(self.start, settings.TIME_FORMAT)
def month(session):
# return session.date.strftime("%B")
return django_date(session.date, "F")
