def smart_date(start_date=None, end_date=None, date_format='j.n.'):
from datetime import datetime
from django.utils import dateformat
now = datetime.now()
components = []
if start_date:
components.append(dateformat.format(start_date, date_format))
if start_date.year != now.year: components.append(str(start_date.year))
start_time = start_date.time()
if start_time.hour > 0 or start_time.minute > 0:
components.append(dateformat.time_format(start_time,r',&\n\b\s\p;G:i'))
if end_date:
components.append(' – ')
if (not start_date) or end_date.date() != start_date.date():
components.append(dateformat.format(end_date, date_format))
if end_date.year != now.year: components.append(str(end_date.year))
end_time = end_date.time()
if end_time.hour > 0 or end_time.minute > 0:
components.append(dateformat.time_format(end_time,r',&\n\b\s\p;G:i'))
return ''.join(components)
def reldate(val, arg=""):
if not val:
return _("Never")
now = datetime.now(utc if is_aware(val) else None)
local_now = localtime(now)
diff = now - val
local = localtime(val)
# Today check
if format(local, 'Y-z') == format(local_now, 'Y-z'):
return _("Today, %(hour)s") % {'hour': time_format(local, formats['TIME_FORMAT'])}
# Yesteday check
yesterday = localtime(now - timedelta(days=1))
if format(local, 'Y-z') == format(yesterday, 'Y-z'):
return _("Yesterday, %(hour)s") % {'hour': time_format(local, formats['TIME_FORMAT'])}
# Tomorrow Check
tomorrow = localtime(now + timedelta(days=1))
if format(local, 'Y-z') == format(tomorrow, 'Y-z'):
return _("Tomorrow, %(hour)s") % {'hour': time_format(local, formats['TIME_FORMAT'])}
# Day of Week check
if format(local, 'D') != format(local_now, 'D') and diff.days > -7 and diff.days < 7:
return _("%(day)s, %(hour)s") % {'day': format(local, 'l'), 'hour': time_format(local, formats['TIME_FORMAT'])}
# Fallback to date
return date(val, arg)
def __str__(self):
# FIXME: output date in locale-specific format
if self.opens and self.closes:
hours = ", {0} - {1}".format(time_format(self.opens, "G:i"), time_format(self.closes, "G:i"))
else:
hours = ""
return "{4}, {3}: {1:%d.%m.%Y} - {2:%d.%m.%Y}, {0}: {3} {5}".format(
self.get_weekday_display(), self.period.start, self.period.end,
STATE_BOOLS[self.closed], self.period.name, hours)
def _format(self, value, label, cast=None, null='(None)', empty='(Empty)', places=2, map=None, max_length=100, truncate='...'):
"""Intelligently format typed data"""
if value is None:
value = null % {'label': label}
if cast is not None:
value = cast(value)
if isinstance(value, (datetime.datetime, datetime.time, datetime.date)):
if isinstance(value, datetime.datetime):
result_repr = capfirst(dateformat.format(value, settings.DATE_FORMAT))
elif isinstance(value, datetime.time):
result_repr = capfirst(dateformat.time_format(value, settings.TIME_FORMAT))
else:
result_repr = capfirst(dateformat.format(value, settings.DATE_FORMAT))
elif isinstance(value, bool):
BOOLEAN_MAPPING = {True: 'yes', False: 'no', None: 'unknown'}
result_repr = E.IMG(src="%sadmin/img/icon-%s.gif" % (settings.ADMIN_MEDIA_PREFIX, BOOLEAN_MAPPING[value]), alt="%s" % value)
elif isinstance(value, (float, Decimal)):
result_repr = (u'%%.%sf' % places) % value
elif map:
result_repr = map.get(value, '--')
elif isinstance(value, (SafeUnicode, SafeString)):
try:
return etree.fromstring(value)
except etree.XMLSyntaxError:
result_repr = value
else:
result_repr = unicode(value)
if empty and result_repr == '':
result_repr = empty % {'label': label}
if not isinstance(result_repr, (SafeUnicode, SafeString)) and max_length and len(result_repr) > max_length:
result_repr = E.ABBR(result_repr[:max_length-len(truncate)] + truncate, title=result_repr)
return result_repr
def display_for_field(value, field):
from django.contrib.admin.templatetags.admin_list import _boolean_icon
from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE
if field.flatchoices:
return dict(field.flatchoices).get(value, EMPTY_CHANGELIST_VALUE)
# NullBooleanField needs special-case null-handling, so it comes
# before the general null test.
elif isinstance(field, models.BooleanField) or isinstance(field, models.NullBooleanField):
return _boolean_icon(value)
elif value is None:
return EMPTY_CHANGELIST_VALUE
elif isinstance(field, models.DateField) or isinstance(field, models.TimeField):
if value:
date_format = formats.get_format('DATE_FORMAT')
datetime_format = formats.get_format('DATETIME_FORMAT')
time_format = formats.get_format('TIME_FORMAT')
if isinstance(field, models.DateTimeField):
return capfirst(dateformat.format(value, datetime_format))
elif isinstance(field, models.TimeField):
return capfirst(dateformat.time_format(value, time_format))
else:
return capfirst(dateformat.format(value, date_format))
else:
return EMPTY_CHANGELIST_VALUE
elif isinstance(field, models.DecimalField):
if value is not None:
return ('%%.%sf' % field.decimal_places) % value
else:
return EMPTY_CHANGELIST_VALUE
elif isinstance(field, models.FloatField):
return escape(value)
else:
return smart_str(value)
def value_list(self):
"""
Returns a list of {value, url} dictionaries representing each value for
this attribute.
"""
from django.utils.dateformat import format, time_format
urls = [None]
descriptions = [None]
if self.is_filter:
if self.is_lookup:
urls = [look and '/%s/by-%s/%s/' % (self.schema_slug, self.sf.slug, look.slug) or None for look in self.values]
elif isinstance(self.raw_value, datetime.date):
urls = ['/%s/by-%s/%s/%s/%s/' % (self.schema_slug, self.sf.slug, self.raw_value.year, self.raw_value.month, self.raw_value.day)]
elif self.raw_value in (True, False, None):
urls = ['/%s/by-%s/%s/' % (self.schema_slug, self.sf.slug, {True: 'yes', False: 'no', None: 'na'}[self.raw_value])]
if self.is_lookup:
values = [val and val.name or 'None' for val in self.values]
descriptions = [val and val.description or None for val in self.values]
elif isinstance(self.raw_value, datetime.datetime):
values = [format(self.raw_value, 'F j, Y, P')]
elif isinstance(self.raw_value, datetime.date):
values = [format(self.raw_value, 'F j, Y')]
elif isinstance(self.raw_value, datetime.time):
values = [time_format(self.raw_value, 'P')]
elif self.raw_value is True:
values = ['Yes']
elif self.raw_value is False:
values = ['No']
elif self.raw_value is None:
values = ['N/A']
else:
values = [self.raw_value]
return [{'value': value, 'url': url, 'description': description} for value, url, description in zip(values, urls, descriptions)]
def _format_value(self, value):
if value is None:
return ''
elif not isinstance(value, datetime.time):
return value
else:
return time_format(value, self.format)
def values(self):
"""
Returns a list of values for this field for this instance. It's a list
so we can accomodate many-to-many fields.
"""
# This import is deliberately inside the function because it causes
# some settings to be imported, and we don't want to do that at the
# module level.
if self.field.rel:
if isinstance(self.field.rel, models.ManyToOneRel):
objs = getattr(self.instance.instance, self.field.name)
elif isinstance(self.field.rel, models.ManyToManyRel): # ManyToManyRel
return list(getattr(self.instance.instance, self.field.name).all())
elif self.field.choices:
objs = dict(self.field.choices).get(self.raw_value, EMPTY_VALUE)
elif isinstance(self.field, models.DateField) or isinstance(self.field, models.TimeField):
if self.raw_value:
date_format, datetime_format, time_format = get_date_formats()
if isinstance(self.field, models.DateTimeField):
objs = capfirst(dateformat.format(self.raw_value, datetime_format))
elif isinstance(self.field, models.TimeField):
objs = capfirst(dateformat.time_format(self.raw_value, time_format))
else:
objs = capfirst(dateformat.format(self.raw_value, date_format))
else:
objs = EMPTY_VALUE
elif isinstance(self.field, models.BooleanField) or isinstance(self.field, models.NullBooleanField):
objs = {True: 'Yes', False: 'No', None: 'Unknown'}[self.raw_value]
else:
objs = self.raw_value
return [objs]
def time(value, arg=None):
if value is None or isinstance(value, Undefined):
return u''
from django.conf import settings
from django.utils.dateformat import time_format
if arg is None:
arg = settings.TIME_FORMAT
return time_format(value, arg)
def time(value, arg=None):
if value is None or isinstance(value, Undefined):
return u''
from django.conf import settings
from django.utils.dateformat import time_format
if arg is None:
arg = settings.TIME_FORMAT
return time_format(value, arg)
def time_format(value, format=None, use_l10n=None):
"""
Formats a datetime.time object using a localizable format
If use_l10n is provided and is not None, that will force the value to
be localized (or not), overriding the value of settings.USE_L10N.
"""
return dateformat.time_format(value, get_format(format or 'TIME_FORMAT', use_l10n=use_l10n))
def time(value, arg=None):
"""Formats a time according to the given format."""
from django.utils.dateformat import time_format
if value in (None, u''):
return u''
if arg is None:
arg = settings.TIME_FORMAT
return time_format(value, arg)
def time_format(value, format=None, use_l10n=None):
"""
Formats a datetime.time object using a localizable format
If use_l10n is provided and is not None, that will force the value to
be localized (or not), overriding the value of settings.USE_L10N.
"""
return dateformat.time_format(value, get_format(format or 'TIME_FORMAT', use_l10n=use_l10n))
def time(value, arg=None):
"""Formats a time according to the given format."""
from django.utils.dateformat import time_format
if value in (None, ''):
return ''
if arg is None:
arg = settings.TIME_FORMAT
return time_format(value, arg)
def format_datetime(self, data):
data = make_naive(data)
today = make_naive(timezone.now())
time_string = dateformat.time_format(data, "P")
date_string = dateformat.format(data, "j M Y")
if data.date() == today.date():
return "today, " + time_string
else:
return date_string
def _msg_format(self, msg, req):
return {
'date': time_format(msg.create,"H:i"),
'user_name':unicode(msg.author),
#'date': unicode(_human_datetime(msg.create)),
'i': int(msg.author==req.user),
'name': msg.author.get_full_name(),
'text': msg.text
}
def humantime(time):
formatting = 'H:i'
try:
formatted = formats.time_format(time, formatting)
except AttributeError:
try:
formatted = time_format(time, formatting)
except AttributeError:
formatted = ''
return _("{date} at {time}").format(date=humandate(time), time=formatted)
def value_list(self):
"""
Returns a list of {value, url, description} dictionaries
representing each value for this attribute.
"""
from django.utils.dateformat import format, time_format
# Setting these to [None] ensures that zip() returns a list
# of at least length one.
urls = [None]
descriptions = [None]
if self.is_filter:
if self.is_lookup:
urls = [
look and '/%s/by-%s/%s/' %
(self.schema_slug, self.sf.slug, look.slug) or None
for look in self.values
]
elif isinstance(self.raw_value, datetime.date):
urls = [
'/%s/by-%s/%s/%s/%s/' %
(self.schema_slug, self.sf.slug, self.raw_value.year,
self.raw_value.month, self.raw_value.day)
]
elif self.raw_value in (True, False, None):
urls = [
'/%s/by-%s/%s/' % (self.schema_slug, self.sf.slug, {
True: 'yes',
False: 'no',
None: 'na'
}[self.raw_value])
]
if self.is_lookup:
values = [val and val.name or 'None' for val in self.values]
descriptions = [
val and val.description or None for val in self.values
]
elif isinstance(self.raw_value, datetime.datetime):
values = [format(self.raw_value, 'F j, Y, P')]
elif isinstance(self.raw_value, datetime.date):
values = [format(self.raw_value, 'F j, Y')]
elif isinstance(self.raw_value, datetime.time):
values = [time_format(self.raw_value, 'P')]
elif self.raw_value is True:
values = ['Yes']
elif self.raw_value is False:
values = ['No']
elif self.raw_value is None:
values = ['N/A']
else:
values = [self.raw_value]
return [{
'value': value,
'url': url,
'description': description
} for value, url, description in zip(values, urls, descriptions)]
def test_P_format(self):
for expected, t in [
("midnight", time(0)),
("noon", time(12)),
("4 a.m.", time(4)),
("8:30 a.m.", time(8, 30)),
("4 p.m.", time(16)),
("8:30 p.m.", time(20, 30)),
]:
with self.subTest(time=t):
self.assertEqual(dateformat.time_format(t, "P"), expected)
def time(value, arg=None):
"""Format a time according to the given format."""
if value in (None, ''):
return ''
try:
return formats.time_format(value, arg)
except (AttributeError, TypeError):
try:
return time_format(value, arg)
except (AttributeError, TypeError):
return ''
def test_P_format(self):
for expected, t in [
('midnight', time(0)),
('noon', time(12)),
('4 a.m.', time(4)),
('8:30 a.m.', time(8, 30)),
('4 p.m.', time(16)),
('8:30 p.m.', time(20, 30)),
]:
with self.subTest(time=t):
self.assertEqual(dateformat.time_format(t, 'P'), expected)
def time(value, arg=None):
"""Formats a time according to the given format."""
if value in (None, ''):
return ''
try:
return formats.time_format(value, arg)
except (AttributeError, TypeError):
try:
return time_format(value, arg)
except (AttributeError, TypeError):
return ''
def appointment_time(self, obj=None):
try:
start = localize(timezone.localtime(obj.appointment.start))
except AttributeError:
start = ""
try:
end_time = time_format(timezone.localtime(obj.appointment.end), "H:i")
except AttributeError:
end_time = ""
return f"{start} - {end_time}"
def time(value, arg=None):
"""Formats a time according to the given format."""
from django.utils.dateformat import time_format
if value in (None, u""):
return u""
if arg is None:
arg = settings.TIME_FORMAT
try:
return time_format(value, arg)
except AttributeError:
return ""
def time(value, arg=None):
"""Formats a time according to the given format."""
if value in (None, ''):
return ''
if arg is None:
arg = settings.TIME_FORMAT
try:
return formats.time_format(value, arg)
except AttributeError:
try:
return time_format(value, arg)
except AttributeError:
return ''
def time(value, arg=None):
"""Formats a time according to the given format."""
if value in (None, ''):
return ''
if arg is None:
arg = settings.TIME_FORMAT
try:
return formats.time_format(value, arg)
except AttributeError:
try:
return time_format(value, arg)
except AttributeError:
return ''
def render(self, context):
start_time, end_time = None, None
try:
start_time = self.start_time.resolve(context)
end_time = self.end_time.resolve(context)
except template.VariableDoesNotExist:
pass
if start_time is None:
return ''
start_format = ""
end_format = ""
if start_time == end_time or not end_time:
start_format = "%s" % self.format['hour']
if start_time.minute != 0:
start_format += ":%s" % self.format['minute']
start_format += " A"
else:
start_format = "%s" % self.format['hour']
if start_time.minute != 0:
start_format += ":%s" % self.format['minute']
if end_time:
end_format = "%s" % self.format['hour']
if end_time.minute != 0:
end_format += ":%s" % self.format['minute']
end_format += " A"
else:
start_format += " A"
ret = dateformat.time_format(start_time, start_format)
if end_format:
ret += " - " + dateformat.time_format(end_time, end_format)
return ret
def reldate(val, arg=""):
if not val:
return _("Never")
now = datetime.now(utc if is_aware(val) else None)
local_now = localtime(now)
diff = now - val
local = localtime(val)
# Today check
if format(local, 'Y-z') == format(local_now, 'Y-z'):
return _("Today, %(hour)s") % {
'hour': time_format(local, formats['TIME_FORMAT'])
}
# Yesteday check
yesterday = localtime(now - timedelta(days=1))
if format(local, 'Y-z') == format(yesterday, 'Y-z'):
return _("Yesterday, %(hour)s") % {
'hour': time_format(local, formats['TIME_FORMAT'])
}
# Tomorrow Check
tomorrow = localtime(now + timedelta(days=1))
if format(local, 'Y-z') == format(tomorrow, 'Y-z'):
return _("Tomorrow, %(hour)s") % {
'hour': time_format(local, formats['TIME_FORMAT'])
}
# Day of Week check
if format(local, 'D') != format(local_now,
'D') and diff.days > -7 and diff.days < 7:
return _("%(day)s, %(hour)s") % {
'day': format(local, 'l'),
'hour': time_format(local, formats['TIME_FORMAT'])
}
# Fallback to date
return date(val, arg)
def time(value, arg=None):
"""Formats a time according to the given format."""
from django.utils import dateformat
if value in (None, u''):
return u''
if arg is None:
arg = settings.TIME_FORMAT
try:
return formats.time_format(value, arg)
except AttributeError:
try:
return dateformat.time_format(value, arg)
except AttributeError:
return ''
def format_seconds(value, arg=None):
"""Formats a number of seconds according to the given format."""
from django.utils import dateformat
#from django.utils import formats
if value in (None, u''):
return u''
if arg is None:
arg = settings.TIME_FORMAT
data = Duration(value)
try:
return dateformat.time_format(data, arg)
except AttributeError:
return ''
def format_seconds(value, arg=None):
"""Formats a number of seconds according to the given format."""
from django.utils import dateformat
#from django.utils import formats
if value in (None, u''):
return u''
if arg is None:
arg = settings.TIME_FORMAT
data = Duration(value)
try:
return dateformat.time_format(data, arg)
except AttributeError:
return ''
def localize(f_value):
if isinstance(f_value, datetime):
return dateformat.format(f_value, datetime_format)
if isinstance(f_value, time):
return dateformat.time_format(f_value, time_format)
if isinstance(f_value, date):
return dateformat.format(f_value, date_format)
if isinstance(f_value, decimal.Decimal):
return moneyformat(f_value, None, app_settings.THOUSANDS_SEPARATOR)
return value
def localize(f_value):
if isinstance(f_value, datetime):
return dateformat.format(f_value, datetime_format)
if isinstance(f_value, time):
return dateformat.time_format(f_value, time_format)
if isinstance(f_value, date):
return dateformat.format(f_value, date_format)
if isinstance(f_value, decimal.Decimal):
return moneyformat(f_value, None, app_settings.THOUSANDS_SEPARATOR)
return value
def time(value, arg=None):
"""Formats a time according to the given format."""
if value is None or isinstance(value, Undefined):
return u''
from django.conf import settings
from django.utils import formats
from django.utils.dateformat import time_format
if arg is None:
arg = settings.TIME_FORMAT
try:
return formats.time_format(value, arg)
except AttributeError:
try:
return time_format(value, arg)
except AttributeError:
return ''
def time(value, arg=None):
"""Formats a time according to the given format."""
if value is None or isinstance(value, Undefined):
return u''
from django.conf import settings
from django.utils import formats
from django.utils.dateformat import time_format
if arg is None:
arg = settings.TIME_FORMAT
try:
return formats.time_format(value, arg)
except AttributeError:
try:
return time_format(value, arg)
except AttributeError:
return ''
def time_range(start_time, end_time):
"""Make time ranges like 7-9 p.m."""
if start_time is None:
return u''
if end_time is None or start_time == end_time:
return time_format(start_time, 'P')
if start_time.hour == 12 or start_time.hour == 0 \
or end_time.hour == 12 or end_time.hour == 0:
return u'%s - %s' % (time_format(start_time, 'P'), time_format(end_time, 'P'))
if (start_time.hour < 12 and end_time.hour >= 12) \
or (end_time.hour < 12 and start_time.hour >= 12):
return u'%s - %s' % (time_format(start_time, 'P'), time_format(end_time, 'P'))
first_part = time_format(start_time, 'P')
first_part = first_part.replace(' a.m.', '').replace(' p.m.', '')
return u'%s-%s' % (first_part, time_format(end_time, 'P'))
def time(value, arg=None):
"""
Alternative implementation to the built-in `time` template filter which also accepts the
date string in iso-8601 as passed in by the REST serializers.
"""
if value in (None, ''):
return ''
if not isinstance(value, datetime):
value = from_iso8601(value)
if arg is None:
arg = settings.TIME_FORMAT
try:
return formats.time_format(value, arg)
except AttributeError:
try:
return time_format(value, arg)
except AttributeError:
return ''
def time(value, arg=None):
"""
Alternative implementation to the built-in `time` template filter which also accepts the
date string in iso-8601 as passed in by the REST serializers.
"""
if value in (None, ''):
return ''
if not isinstance(value, datetime):
value = from_iso8601(value)
if arg is None:
arg = settings.TIME_FORMAT
try:
return formats.time_format(value, arg)
except AttributeError:
try:
return time_format(value, arg)
except AttributeError:
return ''
def nicetimedelta(date1, date0):
tdelta = date1 - date0
days = tdelta.days
sdays = day * days
delta = tdelta.seconds + sdays
if delta < fudge:
return u'about a second ago'
elif delta < (60.0 / fudge):
return u'about %d seconds ago' % int(delta)
elif delta < (60.0 * fudge):
return u'about a minute ago'
elif delta < (hour / fudge):
return u'about %d minutes ago' % int(delta / 60.0)
elif delta < (hour * fudge):
return u'about an hour ago'
elif delta < day:
return u'about %d hours ago' % int(delta / hour)
else:
return u'%s %s' % (format(date0, settings.DATE_FORMAT),time_format(date0.time(), settings.TIME_FORMAT))
def test_timezones(self):
my_birthday = datetime(1979, 7, 8, 22, 00)
summertime = datetime(2005, 10, 30, 1, 00)
wintertime = datetime(2005, 10, 30, 4, 00)
noon = time(12, 0, 0)
# 3h30m to the west of UTC
tz = get_fixed_timezone(-210)
aware_dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=tz)
if TZ_SUPPORT:
for specifier, expected in [
("e", ""),
("O", "+0100"),
("r", "Sun, 08 Jul 1979 22:00:00 +0100"),
("T", "CET"),
("U", "300315600"),
("Z", "3600"),
]:
with self.subTest(specifier=specifier):
self.assertEqual(dateformat.format(my_birthday, specifier),
expected)
self.assertEqual(dateformat.format(aware_dt, "e"), "-0330")
self.assertEqual(
dateformat.format(aware_dt, "r"),
"Sat, 16 May 2009 05:30:30 -0330",
)
self.assertEqual(dateformat.format(summertime, "I"), "1")
self.assertEqual(dateformat.format(summertime, "O"), "+0200")
self.assertEqual(dateformat.format(wintertime, "I"), "0")
self.assertEqual(dateformat.format(wintertime, "O"), "+0100")
for specifier in ["e", "O", "T", "Z"]:
with self.subTest(specifier=specifier):
self.assertEqual(dateformat.time_format(noon, specifier),
"")
# Ticket #16924 -- We don't need timezone support to test this
self.assertEqual(dateformat.format(aware_dt, "O"), "-0330")
def test_timezones(self):
my_birthday = datetime(1979, 7, 8, 22, 00)
summertime = datetime(2005, 10, 30, 1, 00)
wintertime = datetime(2005, 10, 30, 4, 00)
noon = time(12, 0, 0)
# 3h30m to the west of UTC
tz = get_fixed_timezone(-210)
aware_dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=tz)
if TZ_SUPPORT:
for specifier, expected in [
('e', ''),
('O', '+0100'),
('r', 'Sun, 08 Jul 1979 22:00:00 +0100'),
('T', 'CET'),
('U', '300315600'),
('Z', '3600'),
]:
with self.subTest(specifier=specifier):
self.assertEqual(dateformat.format(my_birthday, specifier),
expected)
self.assertEqual(dateformat.format(aware_dt, 'e'), '-0330')
self.assertEqual(
dateformat.format(aware_dt, 'r'),
'Sat, 16 May 2009 05:30:30 -0330',
)
self.assertEqual(dateformat.format(summertime, 'I'), '1')
self.assertEqual(dateformat.format(summertime, 'O'), '+0200')
self.assertEqual(dateformat.format(wintertime, 'I'), '0')
self.assertEqual(dateformat.format(wintertime, 'O'), '+0100')
for specifier in ['e', 'O', 'T', 'Z']:
with self.subTest(specifier=specifier):
self.assertEqual(dateformat.time_format(noon, specifier),
'')
# Ticket #16924 -- We don't need timezone support to test this
self.assertEqual(dateformat.format(aware_dt, 'O'), '-0330')
def values(self):
"""
Returns a list of values for this field for this instance. It's a list
so we can accomodate many-to-many fields.
"""
# This import is deliberately inside the function because it causes
# some settings to be imported, and we don't want to do that at the
# module level.
if self.field.rel:
if isinstance(self.field.rel, models.ManyToOneRel):
objs = getattr(self.instance.instance, self.field.name)
elif isinstance(self.field.rel,
models.ManyToManyRel): # ManyToManyRel
return list(
getattr(self.instance.instance, self.field.name).all())
elif self.field.choices:
objs = dict(self.field.choices).get(self.raw_value, EMPTY_VALUE)
elif isinstance(self.field, models.DateField) or isinstance(
self.field, models.TimeField):
if self.raw_value:
date_format, datetime_format, time_format = get_date_formats()
if isinstance(self.field, models.DateTimeField):
objs = capfirst(
dateformat.format(self.raw_value, datetime_format))
elif isinstance(self.field, models.TimeField):
objs = capfirst(
dateformat.time_format(self.raw_value, time_format))
else:
objs = capfirst(
dateformat.format(self.raw_value, date_format))
else:
objs = EMPTY_VALUE
elif isinstance(self.field, models.BooleanField) or isinstance(
self.field, models.NullBooleanField):
objs = {True: 'Yes', False: 'No', None: 'Unknown'}[self.raw_value]
else:
objs = self.raw_value
return [objs]
def format_datetime(dt, user, date_format, time_format, separator=' '):
"""
Formats a datetime, using ``'Today'`` or ``'Yesterday'`` instead of
the given date format when appropriate.
If a User is given and they have a timezone set in their profile,
the datetime will be translated to their local time.
"""
if user:
dt = user_timezone(dt, user)
today = user_timezone(datetime.datetime.now(), user).date()
else:
today = datetime.date.today()
date_part = dt.date()
delta = date_part - today
if delta.days == 0:
date = u'Today'
elif delta.days == -1:
date = u'Yesterday'
else:
date = dateformat.format(dt, date_format)
return u'%s%s%s' % (date, separator,
dateformat.time_format(dt.time(), time_format))
def format_datetime(dt, user, date_format, time_format, separator=' '):
"""
Formats a datetime, using ``'Today'`` or ``'Yesterday'`` instead of
the given date format when appropriate.
If a User is given and they have a timezone set in their profile,
the datetime will be translated to their local time.
"""
if user:
dt = user_timezone(dt, user)
today = user_timezone(datetime.datetime.now(), user).date()
else:
today = datetime.date.today()
date_part = dt.date()
delta = date_part - today
if delta.days == 0:
date = u'Today'
elif delta.days == -1:
date = u'Yesterday'
else:
date = dateformat.format(dt, date_format)
return u'%s%s%s' % (date, separator,
dateformat.time_format(dt.time(), time_format))
def general_formatter(value, cast=None, **kwargs):
"""
Intelligently format typed data
"""
if value is None:
if 'null' in kwargs:
value = kwargs.get('null', EMPTY_CHANGELIST_VALUE) % {'attribute': kwargs.get('attribute', '')}
else:
value = EMPTY_CHANGELIST_VALUE
if cast is not None:
value = cast(value)
if isinstance(value, (datetime.datetime, datetime.time, datetime.date)):
if isinstance(value, datetime.datetime):
result_repr = capfirst(dateformat.format(value, settings.DATE_FORMAT))
elif isinstance(value, datetime.time):
result_repr = capfirst(dateformat.time_format(value, settings.TIME_FORMAT))
else:
result_repr = capfirst(dateformat.format(value, settings.DATE_FORMAT))
elif isinstance(value, bool):
result_repr = _boolean_icon(value)
elif isinstance(value, (float, Decimal)):
result_repr = (u'%%.%sf' % kwargs.get('places', 2)) % value
elif 'map' in kwargs:
result_repr = kwargs['map'].get(value, EMPTY_CHANGELIST_VALUE)
elif isinstance(value, (SafeUnicode, SafeString)):
result_repr = value
else:
result_repr = unicode(value)
if 'empty' in kwargs and result_repr == '':
result_repr = kwargs.get('empty', EMPTY_CHANGELIST_VALUE) % {'attribute': kwargs.get('attribute', '')}
if not isinstance(result_repr, (SafeUnicode, SafeString)) and kwargs.get('max_length', False) and len(result_repr) > kwargs['max_length']:
result_repr = mark_safe(u'<abbr title="%s">%s</abbr>' % (result_repr,
result_repr[:kwargs['max_length']-len(kwargs.get('truncate', ''))] + kwargs.get('truncate', '')))
return result_repr
def value_list(self):
"""
Returns a list of {value, url, description} dictionaries
representing each value for this attribute.
"""
from django.utils.dateformat import format, time_format
# Setting these to [None] ensures that zip() returns a list
# of at least length one.
urls = [None]
descriptions = [None]
if self.is_filter:
from ebpub.db.schemafilters import FilterChain
chain = FilterChain(schema=self.sf.schema)
if self.is_lookup:
urls = [chain.replace(self.sf, look).make_url() if look else None
for look in self.values]
else:
urls = [chain.replace(self.sf, self.raw_value).make_url()]
if self.is_lookup:
values = [val and val.name or 'None' for val in self.values]
descriptions = [val and val.description or None for val in self.values]
elif isinstance(self.raw_value, datetime.datetime):
values = [format(self.raw_value, 'F j, Y, P')]
elif isinstance(self.raw_value, datetime.date):
values = [format(self.raw_value, 'F j, Y')]
elif isinstance(self.raw_value, datetime.time):
values = [time_format(self.raw_value, 'P')]
elif self.raw_value is True:
values = ['Yes']
elif self.raw_value is False:
values = ['No']
elif self.raw_value is None:
values = ['N/A']
else:
values = [self.raw_value]
return [{'value': value, 'url': url, 'description': description} for value, url, description in zip(values, urls, descriptions)]
def my_items_for_result(cl, result, form):
'''
defines onclick function in book's change_list
(returns _unicode_() instead of id )
'''
first = True
cl_pk = cl.lookup_opts.pk.attname
for field_name in cl.list_display:
row_class = ''
try:
field = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
try:
if callable(field_name):
attr = field_name
value = attr(result)
elif hasattr(cl.model_admin, field_name) and \
not field_name == '__str__' and not field_name == '__unicode__':
attr = getattr(cl.model_admin, field_name)
value = attr(result)
else:
attr = getattr(result, field_name)
if callable(attr):
value = attr()
else:
value = attr
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = _boolean_icon(value)
else:
result_repr = smart_unicode(value)
except (AttributeError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
if not allow_tags:
result_repr = escape(result_repr)
else:
result_repr = mark_safe(result_repr)
else:
field_val = getattr(result, field.attname)
if isinstance(field.rel, models.ManyToOneRel):
if field_val is not None:
result_repr = escape(getattr(result, field.name))
else:
result_repr = EMPTY_CHANGELIST_VALUE
elif isinstance(field, models.DateField) or isinstance(
field, models.TimeField):
if field_val:
(date_format, datetime_format,
time_format) = get_date_formats()
if isinstance(field, models.DateTimeField):
result_repr = capfirst(
dateformat.format(field_val, datetime_format))
elif isinstance(field, models.TimeField):
result_repr = capfirst(
dateformat.time_format(field_val, time_format))
else:
result_repr = capfirst(
dateformat.format(field_val, date_format))
else:
result_repr = EMPTY_CHANGELIST_VALUE
row_class = ' class="nowrap"'
elif isinstance(field, models.BooleanField) or isinstance(
field, models.NullBooleanField):
result_repr = _boolean_icon(field_val)
elif isinstance(field, models.DecimalField):
if field_val is not None:
result_repr = ('%%.%sf' % field.decimal_places) % field_val
else:
result_repr = EMPTY_CHANGELIST_VALUE
elif field.flatchoices:
result_repr = dict(field.flatchoices).get(
field_val, EMPTY_CHANGELIST_VALUE)
else:
result_repr = escape(field_val)
if force_unicode(result_repr) == '':
result_repr = mark_safe(' ')
if (first and not cl.list_display_links
) or field_name in cl.list_display_links:
table_tag = {True: 'th', False: 'td'}[first]
first = False
url = cl.url_for_result(result)
if cl.to_field:
attr = str(cl.to_field)
else:
attr = cl_pk
value = result.serializable_value(attr)
result_id = repr(force_unicode(value))[1:]
######### my representation for books in author
if isinstance(result, Author):
result_name = repr(force_unicode(result.name))[1:]
yield mark_safe(u'<%s%s><a href="%s"%s>%s</a></%s>' % \
(table_tag, row_class, url, (cl.is_popup and ' onclick="opener.checkboxDismissRelatedLookupPopup(window, %s, %s); return false;"' %(result_id, result_name) or ('','')), conditional_escape(result_repr), table_tag))
else:
yield mark_safe(u'<%s%s><a href="%s"%s>%s</a></%s>' % \
(table_tag, row_class, url, (cl.is_popup and ' onclick="opener.checkboxDismissRelatedLookupPopup(window, %s); return false;"' %result_id or ''), conditional_escape(result_repr), table_tag))
else:
if form and field_name in form.fields:
form_field_name = form[field_name]
result_repr = mark_safe(
force_unicode(form_field_name.errors) +
force_unicode(form_field_name))
else:
result_repr = conditional_escape(result_repr)
yield mark_safe(u'<td%s>%s</td>' % (row_class, result_repr))
if form:
yield mark_safe(force_unicode(form[cl.model._meta.pk.name]))
def thumbnails_for_result(cl, result, form):
"""
Basically does the same thing as django's items_for_result, but makes all the
items fit in one <td> element instead of separate elements for each field
"""
first = True
pk = cl.lookup_opts.pk.attname
for field_name in cl.list_display:
row_class = ''
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
# For non-field list_display values, the value is either a method,
# property or returned via a callable.
try:
if callable(field_name):
attr = field_name
value = attr(result)
elif hasattr(cl.model_admin, field_name) and \
not field_name == '__str__' and not field_name == '__unicode__':
attr = getattr(cl.model_admin, field_name)
value = attr(result)
else:
attr = getattr(result, field_name)
if callable(attr):
value = attr()
else:
value = attr
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = _boolean_icon(value)
else:
result_repr = smart_unicode(value)
except (AttributeError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if not allow_tags:
result_repr = escape(result_repr)
else:
result_repr = mark_safe(result_repr)
else:
field_val = getattr(result, f.attname)
if isinstance(f.rel, models.ManyToOneRel):
if field_val is not None:
result_repr = escape(getattr(result, f.name))
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Dates and times are special: They're formatted in a certain way.
elif isinstance(f, models.DateField) or isinstance(f, models.TimeField):
if field_val:
(date_format, datetime_format, time_format) = get_date_formats()
if isinstance(f, models.DateTimeField):
result_repr = capfirst(dateformat.format(field_val, datetime_format))
elif isinstance(f, models.TimeField):
result_repr = capfirst(dateformat.time_format(field_val, time_format))
else:
result_repr = capfirst(dateformat.format(field_val, date_format))
else:
result_repr = EMPTY_CHANGELIST_VALUE
row_class = ' class="nowrap"'
# Booleans are special: We use images.
elif isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField):
result_repr = _boolean_icon(field_val)
# DecimalFields are special: Zero-pad the decimals.
elif isinstance(f, models.DecimalField):
if field_val is not None:
result_repr = ('%%.%sf' % f.decimal_places) % field_val
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Fields with choices are special: Use the representation
# of the choice.
elif f.flatchoices:
result_repr = dict(f.flatchoices).get(field_val, EMPTY_CHANGELIST_VALUE)
else:
result_repr = escape(field_val)
if force_unicode(result_repr) == '':
result_repr = mark_safe(' ')
# If list_display_links not defined, add the link tag to the first field
if (first and not cl.list_display_links) or field_name in cl.list_display_links:
table_tag = {True:'th', False:'td'}[first]
first = False
url = cl.url_for_result(result)
# Convert the pk to something that can be used in Javascript.
# Problem cases are long ints (23L) and non-ASCII strings.
if cl.to_field:
attr = str(cl.to_field)
else:
attr = pk
value = result.serializable_value(attr)
result_id = repr(force_unicode(value))[1:]
if cl.is_popup and cl.params['pop'] == u'2':
yield mark_safe(u'<a href="%s"%s>%s</a>' % \
('#', (cl.is_popup and ' onclick="FileBrowserDialogue.fileSubmit(\'%s\', \'%s\', \'%s\'); return false;"' % (result.media_url or '', quo_esc(result.caption) or '', result.get_absolute_url())), conditional_escape(result_repr)))
#(url, (cl.is_popup and ' onclick="FileBrowserDialogue.fileSubmit(\'%s\'); return false;"' % result.get_absolute_url() or ''), conditional_escape(result_repr)))
else:
yield mark_safe(u'<a href="%s"%s>%s</a>' % \
(url, (cl.is_popup and ' onclick="opener.dismissRelatedLookupPopup(window, %s); return false;"' % result_id or ''), conditional_escape(result_repr)))
else:
# By default the fields come from ModelAdmin.list_editable, but if we pull
# the fields out of the form instead of list_editable custom admins
# can provide fields on a per request basis
if form and field_name in form.fields:
bf = form[field_name]
result_repr = mark_safe(force_unicode(bf.errors) + force_unicode(bf))
else:
result_repr = conditional_escape(result_repr)
yield mark_safe(u'%s' % (result_repr))
if form:
yield mark_safe(force_unicode(form[cl.model._meta.pk.name]))
def time_format(value, format=settings.TIME_FORMAT):
from django.utils import dateformat
return dateformat.time_format(value, format)
def time_format(value, format=None):
"""
Formats a datetime.time object using a localizable format
"""
return dateformat.time_format(value, get_format(format or 'TIME_FORMAT'))
def thumbnails_for_result(cl, result, form):
"""
Basically does the same thing as django's items_for_result, but makes all the
items fit in one <td> element instead of separate elements for each field
"""
first = True
pk = cl.lookup_opts.pk.attname
for field_name in cl.list_display:
row_class = ''
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
# For non-field list_display values, the value is either a method,
# property or returned via a callable.
try:
if callable(field_name):
attr = field_name
value = attr(result)
elif hasattr(cl.model_admin, field_name) and \
not field_name == '__str__' and not field_name == '__unicode__':
attr = getattr(cl.model_admin, field_name)
value = attr(result)
else:
attr = getattr(result, field_name)
if callable(attr):
value = attr()
else:
value = attr
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = _boolean_icon(value)
else:
result_repr = smart_unicode(value)
except (AttributeError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if not allow_tags:
result_repr = escape(result_repr)
else:
result_repr = mark_safe(result_repr)
else:
field_val = getattr(result, f.attname)
if isinstance(f.rel, models.ManyToOneRel):
if field_val is not None:
result_repr = escape(getattr(result, f.name))
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Dates and times are special: They're formatted in a certain way.
elif isinstance(f, models.DateField) or isinstance(f, models.TimeField):
if field_val:
date_format = get_format('DATE_FORMAT')
datetime_format = get_format('DATETIME_FORMAT')
time_format = get_format('TIME_FORMAT')
if isinstance(f, models.DateTimeField):
result_repr = capfirst(dateformat.format(field_val, datetime_format))
elif isinstance(f, models.TimeField):
result_repr = capfirst(dateformat.time_format(field_val, time_format))
else:
result_repr = capfirst(dateformat.format(field_val, date_format))
else:
result_repr = EMPTY_CHANGELIST_VALUE
row_class = ' class="nowrap"'
# Booleans are special: We use images.
elif isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField):
result_repr = _boolean_icon(field_val)
# DecimalFields are special: Zero-pad the decimals.
elif isinstance(f, models.DecimalField):
if field_val is not None:
result_repr = ('%%.%sf' % f.decimal_places) % field_val
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Fields with choices are special: Use the representation
# of the choice.
elif f.flatchoices:
result_repr = dict(f.flatchoices).get(field_val, EMPTY_CHANGELIST_VALUE)
else:
result_repr = escape(field_val)
if force_unicode(result_repr) == '':
result_repr = mark_safe(' ')
# If list_display_links not defined, add the link tag to the first field
if (first and not cl.list_display_links) or field_name in cl.list_display_links:
table_tag = {True:'th', False:'td'}[first]
first = False
url = cl.url_for_result(result)
# Convert the pk to something that can be used in Javascript.
# Problem cases are long ints (23L) and non-ASCII strings.
if cl.to_field:
attr = str(cl.to_field)
else:
attr = pk
value = result.serializable_value(attr)
result_id = repr(force_unicode(value))[1:]
if cl.is_popup and cl.params['pop'] == u'2':
yield mark_safe(u'<a href="%s"%s>%s</a>' % \
('#', (cl.is_popup and ' onclick="FileBrowserDialogue.fileSubmit(\'%s\', \'%s\', \'%s\'); return false;"' % (result.media_url or '', quo_esc(result.caption) or '', result.get_absolute_url())), conditional_escape(result_repr)))
#(url, (cl.is_popup and ' onclick="FileBrowserDialogue.fileSubmit(\'%s\'); return false;"' % result.get_absolute_url() or ''), conditional_escape(result_repr)))
else:
yield mark_safe(u'<a href="%s"%s>%s</a>' % \
(url, (cl.is_popup and ' onclick="opener.dismissRelatedLookupPopup(window, %s); return false;"' % result_id or ''), conditional_escape(result_repr)))
else:
# By default the fields come from ModelAdmin.list_editable, but if we pull
# the fields out of the form instead of list_editable custom admins
# can provide fields on a per request basis
if form and field_name in form.fields:
bf = form[field_name]
result_repr = mark_safe(force_unicode(bf.errors) + force_unicode(bf))
else:
result_repr = conditional_escape(result_repr)
yield mark_safe(u'%s' % (result_repr))
if form:
yield mark_safe(force_unicode(form[cl.model._meta.pk.name]))
def mptt_items_for_result(cl, result, form):
first = True
pk = cl.lookup_opts.pk.attname
# figure out which field to indent
mptt_indent_field = None
for field_name in cl.list_display:
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
if mptt_indent_field is None:
attr = getattr(result, field_name, None)
if callable(attr):
# first callable field, use this if we can't find any model fields
mptt_indent_field = field_name
else:
# first model field, use this one
mptt_indent_field = field_name
break
for field_name in cl.list_display:
row_class = ''
f = None
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
# For non-field list_display values, the value is either a method,
# property or returned via a callable.
try:
if callable(field_name):
attr = field_name
value = attr(result)
elif hasattr(cl.model_admin, field_name) and \
not field_name == '__str__' and not field_name == '__unicode__':
attr = getattr(cl.model_admin, field_name)
value = attr(result)
else:
attr = getattr(result, field_name)
if callable(attr):
value = attr()
else:
value = attr
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = _boolean_icon(value)
else:
result_repr = smart_unicode(value)
except (AttributeError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if not allow_tags:
result_repr = escape(result_repr)
else:
result_repr = mark_safe(result_repr)
else:
field_val = getattr(result, f.attname)
if isinstance(f.rel, models.ManyToOneRel):
if field_val is not None:
result_repr = escape(getattr(result, f.name))
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Dates and times are special: They're formatted in a certain way.
elif isinstance(f, models.DateField) or isinstance(
f, models.TimeField):
if field_val:
(date_format, datetime_format,
time_format) = get_date_formats()
if isinstance(f, models.DateTimeField):
result_repr = capfirst(
dateformat.format(field_val, datetime_format))
elif isinstance(f, models.TimeField):
result_repr = capfirst(
dateformat.time_format(field_val, time_format))
else:
result_repr = capfirst(
dateformat.format(field_val, date_format))
else:
result_repr = EMPTY_CHANGELIST_VALUE
row_class = ' class="nowrap"'
# Booleans are special: We use images.
elif isinstance(f, models.BooleanField) or isinstance(
f, models.NullBooleanField):
result_repr = _boolean_icon(field_val)
# DecimalFields are special: Zero-pad the decimals.
elif isinstance(f, models.DecimalField):
if field_val is not None:
result_repr = ('%%.%sf' % f.decimal_places) % field_val
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Fields with choices are special: Use the representation
# of the choice.
elif f.flatchoices:
result_repr = dict(f.flatchoices).get(field_val,
EMPTY_CHANGELIST_VALUE)
else:
result_repr = escape(field_val)
if force_unicode(result_repr) == '':
result_repr = mark_safe(' ')
if field_name == mptt_indent_field:
level = getattr(result, result._mptt_meta.level_attr)
padding_attr = ' style="padding-left:%spx"' % (
5 + MPTT_ADMIN_LEVEL_INDENT * level)
else:
padding_attr = ''
# If list_display_links not defined, add the link tag to the first field
if (first and not cl.list_display_links
) or field_name in cl.list_display_links:
table_tag = {True: 'th', False: 'td'}[first]
first = False
url = cl.url_for_result(result)
# Convert the pk to something that can be used in Javascript.
# Problem cases are long ints (23L) and non-ASCII strings.
if cl.to_field:
attr = str(cl.to_field)
else:
attr = pk
value = result.serializable_value(attr)
result_id = repr(force_unicode(value))[1:]
yield mark_safe(u'<%s%s%s><a href="%s"%s>%s</a></%s>' % \
(table_tag, row_class, padding_attr, url, (cl.is_popup and ' onclick="opener.dismissRelatedLookupPopup(window, %s); return false;"' % result_id or ''), conditional_escape(result_repr), table_tag))
else:
# By default the fields come from ModelAdmin.list_editable, but if we pull
# the fields out of the form instead of list_editable custom admins
# can provide fields on a per request basis
if form and field_name in form.fields:
bf = form[field_name]
result_repr = mark_safe(
force_unicode(bf.errors) + force_unicode(bf))
else:
result_repr = conditional_escape(result_repr)
yield mark_safe(u'<td%s%s>%s</td>' %
(row_class, padding_attr, result_repr))
if form:
yield mark_safe(u'<td>%s</td>' %
force_unicode(form[cl.model._meta.pk.name]))
def items_for_result(cl, result):
first = True
pk = cl.lookup_opts.pk.attname
for field_name in cl.list_display:
row_class = ''
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
# For non-field list_display values, the value is either a method,
# property or returned via a callable.
try:
if callable(field_name):
attr = field_name
value = attr(result)
elif hasattr(cl.model_admin, field_name) and \
not field_name == '__str__' and not field_name == '__unicode__':
attr = getattr(cl.model_admin, field_name)
value = attr(result)
else:
attr = getattr(result, field_name)
if callable(attr):
value = attr()
else:
value = attr
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = _boolean_icon(value)
else:
result_repr = smart_unicode(value)
except (AttributeError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if not allow_tags:
result_repr = escape(result_repr)
else:
result_repr = mark_safe(result_repr)
else:
field_val = getattr(result, f.attname)
if isinstance(f.rel, models.ManyToOneRel):
if field_val is not None:
result_repr = escape(getattr(result, f.name))
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Dates and times are special: They're formatted in a certain way.
elif isinstance(f, models.DateField) or isinstance(
f, models.TimeField):
if field_val:
(date_format, datetime_format,
time_format) = get_date_formats()
if isinstance(f, models.DateTimeField):
result_repr = capfirst(
dateformat.format(field_val, datetime_format))
elif isinstance(f, models.TimeField):
result_repr = capfirst(
dateformat.time_format(field_val, time_format))
else:
result_repr = capfirst(
dateformat.format(field_val, date_format))
else:
result_repr = EMPTY_CHANGELIST_VALUE
row_class = ' class="nowrap"'
# Booleans are special: We use images.
elif isinstance(f, models.BooleanField) or isinstance(
f, models.NullBooleanField):
result_repr = _boolean_icon(field_val)
# DecimalFields are special: Zero-pad the decimals.
elif isinstance(f, models.DecimalField):
if field_val is not None:
result_repr = ('%%.%sf' % f.decimal_places) % field_val
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Fields with choices are special: Use the representation
# of the choice.
elif f.choices:
result_repr = dict(f.choices).get(field_val,
EMPTY_CHANGELIST_VALUE)
else:
result_repr = escape(field_val)
if force_unicode(result_repr) == '':
result_repr = mark_safe(' ')
# If list_display_links not defined, add the link tag to the first field
if (first and not cl.list_display_links
) or field_name in cl.list_display_links:
table_tag = {True: 'th', False: 'td'}[first]
first = False
url = cl.url_for_result(result)
# Convert the pk to something that can be used in Javascript.
# Problem cases are long ints (23L) and non-ASCII strings.
if cl.to_field:
attr = str(cl.to_field)
else:
attr = pk
value = result.serializable_value(attr)
result_id = repr(force_unicode(value))[1:]
yield mark_safe(u'<%s%s><a href="%s"%s>%s</a></%s>' % \
(table_tag, row_class, url, (cl.is_popup and ' onclick="opener.dismissRelatedLookupPopup(window, %s); return false;"' % result_id or ''), conditional_escape(result_repr), table_tag))
else:
yield mark_safe(u'<td%s>%s</td>' %
(row_class, conditional_escape(result_repr)))
def format_datetime(dt):
return format(dt, settings.DATE_FORMAT) + ", " + time_format(
dt, settings.TIME_FORMAT)
def items_for_result(cl, result):
first = True
pk = cl.lookup_opts.pk.attname
for field_name in cl.lookup_opts.admin.list_display:
row_class = ''
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
# For non-field list_display values, the value is either a method
# or a property.
try:
attr = getattr(result, field_name)
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if callable(attr):
attr = attr()
if boolean:
allow_tags = True
result_repr = _boolean_icon(attr)
else:
result_repr = str(attr)
except (AttributeError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if not allow_tags:
result_repr = escape(result_repr)
else:
field_val = getattr(result, f.attname)
if isinstance(f.rel, models.ManyToOneRel):
if field_val is not None:
result_repr = escape(getattr(result, f.name))
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Dates and times are special: They're formatted in a certain way.
elif isinstance(f, models.DateField) or isinstance(f, models.TimeField):
if field_val:
(date_format, datetime_format, time_format) = get_date_formats()
if isinstance(f, models.DateTimeField):
result_repr = capfirst(dateformat.format(field_val, datetime_format))
elif isinstance(f, models.TimeField):
result_repr = capfirst(dateformat.time_format(field_val, time_format))
else:
result_repr = capfirst(dateformat.format(field_val, date_format))
else:
result_repr = EMPTY_CHANGELIST_VALUE
row_class = ' class="nowrap"'
# Booleans are special: We use images.
elif isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField):
result_repr = _boolean_icon(field_val)
# DecimalFields are special: Zero-pad the decimals.
elif isinstance(f, models.DecimalField):
if field_val is not None:
result_repr = ('%%.%sf' % f.decimal_places) % field_val
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Fields with choices are special: Use the representation
# of the choice.
elif f.choices:
result_repr = dict(f.choices).get(field_val, EMPTY_CHANGELIST_VALUE)
else:
result_repr = escape(str(field_val))
if result_repr == '':
result_repr = ' '
# If list_display_links not defined, add the link tag to the first field
if (first and not cl.lookup_opts.admin.list_display_links) or field_name in cl.lookup_opts.admin.list_display_links:
table_tag = {True:'th', False:'td'}[first]
first = False
url = cl.url_for_result(result)
result_id = str(getattr(result, pk)) # str() is needed in case of 23L (long ints)
yield ('<%s%s><a href="%s"%s>%s</a></%s>' % \
(table_tag, row_class, url, (cl.is_popup and ' onclick="opener.dismissRelatedLookupPopup(window, %r); return false;"' % result_id or ''), result_repr, table_tag))
else:
yield ('<td%s>%s</td>' % (row_class, result_repr))
def localtime(value, time_format=settings.TIME_FORMAT):
try:
return dateformat.time_format(value, time_format)
except Exception as e:
return value
def items_for_result(cl, result):
first = True
pk = cl.lookup_opts.pk.attname
for field_name in cl.lookup_opts.admin.list_display:
row_class = ''
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
# For non-field list_display values, the value is either a method
# or a property.
try:
attr = getattr(result, field_name)
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if callable(attr):
attr = attr()
if boolean:
allow_tags = True
result_repr = _boolean_icon(attr)
else:
result_repr = str(attr)
except (AttributeError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if not allow_tags:
result_repr = escape(result_repr)
else:
field_val = getattr(result, f.attname)
if isinstance(f.rel, models.ManyToOneRel):
if field_val is not None:
result_repr = escape(getattr(result, f.name))
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Dates and times are special: They're formatted in a certain way.
elif isinstance(f, models.DateField) or isinstance(
f, models.TimeField):
if field_val:
(date_format, datetime_format,
time_format) = get_date_formats()
if isinstance(f, models.DateTimeField):
result_repr = capfirst(
dateformat.format(field_val, datetime_format))
elif isinstance(f, models.TimeField):
result_repr = capfirst(
dateformat.time_format(field_val, time_format))
else:
result_repr = capfirst(
dateformat.format(field_val, date_format))
else:
result_repr = EMPTY_CHANGELIST_VALUE
row_class = ' class="nowrap"'
# Booleans are special: We use images.
elif isinstance(f, models.BooleanField) or isinstance(
f, models.NullBooleanField):
result_repr = _boolean_icon(field_val)
# FloatFields are special: Zero-pad the decimals.
elif isinstance(f, models.FloatField):
if field_val is not None:
result_repr = ('%%.%sf' % f.decimal_places) % field_val
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Fields with choices are special: Use the representation
# of the choice.
elif f.choices:
result_repr = dict(f.choices).get(field_val,
EMPTY_CHANGELIST_VALUE)
else:
result_repr = escape(str(field_val))
if result_repr == '':
result_repr = ' '
# If list_display_links not defined, add the link tag to the first field
if (first and not cl.lookup_opts.admin.list_display_links
) or field_name in cl.lookup_opts.admin.list_display_links:
table_tag = {True: 'th', False: 'td'}[first]
first = False
url = cl.url_for_result(result)
result_id = str(getattr(
result, pk)) # str() is needed in case of 23L (long ints)
yield ('<%s%s><a href="%s"%s>%s</a></%s>' % \
(table_tag, row_class, url, (cl.is_popup and ' onclick="opener.dismissRelatedLookupPopup(window, %r); return false;"' % result_id or ''), result_repr, table_tag))
else:
yield ('<td%s>%s</td>' % (row_class, result_repr))
def items_for_result(cl, result):
first = True
pk = cl.lookup_opts.pk.attname
for field_name in cl.list_display:
row_class = ''
try:
f = cl.lookup_opts.get_field(field_name)
except models.FieldDoesNotExist:
# For non-field list_display values, the value is either a method,
# property or returned via a callable.
try:
if callable(field_name):
attr = field_name
value = attr(result)
elif hasattr(cl.model_admin, field_name) and \
not field_name == '__str__' and not field_name == '__unicode__':
attr = getattr(cl.model_admin, field_name)
value = attr(result)
else:
attr = getattr(result, field_name)
if callable(attr):
value = attr()
else:
value = attr
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = _boolean_icon(value)
else:
result_repr = smart_unicode(value)
except (AttributeError, ObjectDoesNotExist):
result_repr = EMPTY_CHANGELIST_VALUE
else:
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if not allow_tags:
result_repr = escape(result_repr)
else:
result_repr = mark_safe(result_repr)
else:
field_val = getattr(result, f.attname)
if isinstance(f.rel, models.ManyToOneRel):
if field_val is not None:
result_repr = escape(getattr(result, f.name))
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Dates and times are special: They're formatted in a certain way.
elif isinstance(f, models.DateField) or isinstance(f, models.TimeField):
if field_val:
(date_format, datetime_format, time_format) = get_date_formats()
if isinstance(f, models.DateTimeField):
result_repr = capfirst(dateformat.format(field_val, datetime_format))
elif isinstance(f, models.TimeField):
result_repr = capfirst(dateformat.time_format(field_val, time_format))
else:
result_repr = capfirst(dateformat.format(field_val, date_format))
else:
result_repr = EMPTY_CHANGELIST_VALUE
row_class = ' class="nowrap"'
# Booleans are special: We use images.
elif isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField):
result_repr = _boolean_icon(field_val)
# DecimalFields are special: Zero-pad the decimals.
elif isinstance(f, models.DecimalField):
if field_val is not None:
result_repr = ('%%.%sf' % f.decimal_places) % field_val
else:
result_repr = EMPTY_CHANGELIST_VALUE
# Fields with choices are special: Use the representation
# of the choice.
elif f.choices:
result_repr = dict(f.choices).get(field_val, EMPTY_CHANGELIST_VALUE)
else:
result_repr = escape(field_val)
if force_unicode(result_repr) == '':
result_repr = mark_safe(' ')
# If list_display_links not defined, add the link tag to the first field
if (first and not cl.list_display_links) or field_name in cl.list_display_links:
table_tag = {True:'th', False:'td'}[first]
first = False
#
#RYW
#
#original:
#url = cl.url_for_result(result)
#
# a hack: I'm using this file to stash a global variable for the
# HTTP request, which is currently used by admin_list.py to exclude
# a link to a page for editing details.
#
req = dsh_common_django_request.get()
if not dsh_common_django_request.deny_it(req):
url = cl.url_for_result(result)
else:
url = dsh_common_django_request.no_permission_reply()
# Convert the pk to something that can be used in Javascript.
# Problem cases are long ints (23L) and non-ASCII strings.
if cl.to_field:
attr = str(cl.to_field)
else:
attr = pk
result_id = repr(force_unicode(getattr(result, attr)))[1:]
yield mark_safe(u'<%s%s><a href="%s"%s>%s</a></%s>' % \
(table_tag, row_class, url, (cl.is_popup and ' onclick="opener.dismissRelatedLookupPopup(window, %s); return false;"' % result_id or ''), conditional_escape(result_repr), table_tag))
else:
yield mark_safe(u'<td%s>%s</td>' % (row_class, conditional_escape(result_repr)))
