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_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(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 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 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_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 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 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)))