def test_is_convertible_or_formatable(self): self.assertTrue(is_convertible_or_formattable('test', 'unit_only')) self.assertTrue(is_convertible_or_formattable('test', 'digit_only')) self.assertTrue(is_convertible_or_formattable('test', 'both')) self.assertTrue( is_convertible_or_formattable('test', 'separate_units')) self.assertFalse(is_convertible_or_formattable('test', 'random_field'))
def test_is_convertible_or_formatable(self): self.assertTrue(is_convertible_or_formattable('test', 'unit_only')) self.assertTrue(is_convertible_or_formattable('test', 'digit_only')) self.assertTrue(is_convertible_or_formattable('test', 'both')) self.assertTrue(is_convertible_or_formattable('test', 'separate_units')) self.assertFalse(is_convertible_or_formattable('test', 'random_field'))
def _unit_format(self, value): model_name = self.model.lower() if is_convertible_or_formattable(model_name, self.field): _, value = get_display_value( self.instance, model_name, self.field, value) if value and is_convertible(model_name, self.field): units = get_units(self.instance, model_name, self.field) value += (' %s' % units) return value
def _unit_format(self, value): model_name = self.model.lower() if isinstance(value, GEOSGeometry): if value.geom_type == 'Point': return '%d,%d' % (value.x, value.y) if value.geom_type in {'MultiPolygon', 'Polygon'}: value = value.area if is_convertible_or_formattable(model_name, self.field): _, value = get_display_value( self.instance, model_name, self.field, value) if value and is_convertible(model_name, self.field): units = get_unit_name(get_units(self.instance, model_name, self.field)) value += (' %s' % units) return value
def _unit_format(self, value): model_name = self.model.lower() if isinstance(value, GEOSGeometry): if value.geom_type == 'Point': return '%d,%d' % (value.x, value.y) if value.geom_type in {'MultiPolygon', 'Polygon'}: value = value.area if is_convertible_or_formattable(model_name, self.field): _, value = get_display_value(self.instance, model_name, self.field, value) if value and is_convertible(model_name, self.field): units = get_unit_name( get_units(self.instance, model_name, self.field)) value += (' %s' % units) return value
def render(self, context): label, identifier = self.resolve_label_and_identifier(context) user = _resolve_variable(self.user, context) instance = _resolve_variable(self.instance, context) field_template = get_template(_resolve_variable( self.field_template, context)) if not isinstance(identifier, basestring)\ or not _identifier_regex.match(identifier): raise template.TemplateSyntaxError( 'expected a string with the format "model.property" ' 'to follow "from" %s' % identifier) model_name, field_name = identifier.split('.', 1) model = self.get_model(context, model_name, instance) def _is_udf(model, udf_field_name): return (hasattr(model, 'udf_field_names') and udf_field_name in model.udf_field_names) def _udf_dict(model, field_name): return model.get_user_defined_fields()\ .filter(name=field_name.replace('udf:', ''))[0]\ .datatype_dict def _field_type_label_choices(model, field_name, label): choices = None udf_field_name = field_name.replace('udf:', '') if not _is_udf(model, udf_field_name): field = model._meta.get_field(field_name) field_type = field.get_internal_type() try: field_type = FieldNode._field_mappings[field_type] except KeyError: raise Exception('This template tag only supports %s not %s' % (FieldNode._valid_field_keys, field_type)) label = label if label else field.help_text choices = [{'value': choice[0], 'display_value': choice[1]} for choice in field.choices] if choices and field.null: choices = [{'value': '', 'display_value': ''}] + choices else: udf_dict = _udf_dict(model, field_name) field_type = udf_dict['type'] label = label if label else udf_field_name if 'choices' in udf_dict: values = [''] + udf_dict['choices'] choices = [{'value': value, 'display_value': value} for value in values] return field_type, label, choices def _field_value(model, field_name): udf_field_name = field_name.replace('udf:', '') if field_name in model._meta.get_all_field_names(): try: val = getattr(model, field_name) except ObjectDoesNotExist: val = None elif _is_udf(model, udf_field_name): val = model.udfs[udf_field_name] else: raise ValueError('Could not find field: %s' % field_name) return val if is_json_field_reference(field_name): field_value = get_attr_from_json_field(model, field_name) choices = None is_visible = is_editable = True data_type = "string" else: field_value = _field_value(model, field_name) data_type, label, choices = _field_type_label_choices( model, field_name, label) if user is not None and hasattr(model, 'field_is_visible'): is_visible = model.field_is_visible(user, field_name) is_editable = model.field_is_editable(user, field_name) else: # This tag can be used without specifying a user. In that case # we assume that the content is visible and upstream code is # responsible for only showing the content to the appropriate # user is_visible = True is_editable = True digits = (get_digits(model.instance, model_name, field_name) if is_formattable(model_name, field_name) else '') units = '' if is_convertible(model_name, field_name): units = get_units(model.instance, model_name, field_name) if field_value is None: display_val = None elif data_type == 'date' and model.instance: display_val = dateformat.format(field_value, model.instance.short_date_format) elif data_type == 'date': display_val = dateformat.format(field_value, settings.SHORT_DATE_FORMAT) elif is_convertible_or_formattable(model_name, field_name): field_value, display_val = get_display_value( model.instance, model_name, field_name, field_value) if units is not '': display_val += (' %s' % units) else: display_val = unicode(field_value) context['field'] = { 'label': label, 'identifier': identifier, 'value': field_value, 'display_value': display_val, 'units': units, 'digits': digits, 'data_type': data_type, 'is_visible': is_visible, 'is_editable': is_editable, 'choices': choices } self.get_additional_context(context['field']) return field_template.render(context)
def render(self, context): explanation = _resolve_variable(self.explanation, context) label, identifier = self.resolve_label_and_identifier(context) user = _resolve_variable(self.user, context) instance = _resolve_variable(self.instance, context) field_template = get_template(_resolve_variable( self.field_template, context)).template if not isinstance(identifier, basestring)\ or not _identifier_regex.match(identifier): raise template.TemplateSyntaxError( 'expected a string with the format "object_name.property" ' 'to follow "from" %s' % identifier) model_name_or_object_name, field_name = dotted_split(identifier, 2, maxsplit=1) model = self.get_model(context, model_name_or_object_name, instance) object_name = to_object_name(model_name_or_object_name) identifier = "%s.%s" % (object_name, field_name) def _field_value(model, field_name, data_type): udf_field_name = field_name.replace('udf:', '') val = None if field_name in [f.name for f in model._meta.get_fields()]: try: val = getattr(model, field_name) except (ObjectDoesNotExist, AttributeError): pass elif _is_udf(model, udf_field_name): if udf_field_name in model.udfs: val = model.udfs[udf_field_name] # multichoices place a json serialized data-value # on the dom element and client-side javascript # processes it into a view table and edit widget if data_type == 'multichoice': val = json.dumps(val) elif data_type == 'multichoice': val = '[]' else: raise ValueError('Could not find field: %s' % field_name) return val if is_json_field_reference(field_name): field_value = get_attr_from_json_field(model, field_name) choices = None is_visible = is_editable = True data_type = "string" else: add_blank = (ADD_BLANK_ALWAYS if self.treat_multichoice_as_choice else ADD_BLANK_IF_CHOICE_FIELD) data_type, label, explanation, choices = field_type_label_choices( model, field_name, label, explanation=explanation, add_blank=add_blank) field_value = _field_value(model, field_name, data_type) if user is not None and hasattr(model, 'field_is_visible'): is_visible = model.field_is_visible(user, field_name) is_editable = model.field_is_editable(user, field_name) else: # This tag can be used without specifying a user. In that case # we assume that the content is visible and upstream code is # responsible for only showing the content to the appropriate # user is_visible = True is_editable = True digits = units = '' if hasattr(model, 'instance'): digits = get_digits_if_formattable( model.instance, object_name, field_name) units = get_units_if_convertible( model.instance, object_name, field_name) if units != '': units = get_unit_abbreviation(units) if data_type == 'foreign_key': # rendered clientside display_val = '' elif field_value is None: display_val = None elif data_type in ['date', 'datetime']: fmt = (model.instance.short_date_format if model.instance else settings.SHORT_DATE_FORMAT) display_val = dateformat.format(field_value, fmt) elif is_convertible_or_formattable(object_name, field_name): display_val = format_value( model.instance, object_name, field_name, field_value) if units != '': display_val += (' %s' % units) elif data_type == 'bool': display_val = _('Yes') if field_value else _('No') elif data_type == 'multichoice': # this is rendered clientside from data attributes so # there's no meaningful intermediate value to send # without rendering the same markup server-side. display_val = None elif choices: display_vals = [choice['display_value'] for choice in choices if choice['value'] == field_value] display_val = display_vals[0] if display_vals else field_value else: display_val = unicode(field_value) context['field'] = { 'label': label, 'explanation': explanation, 'identifier': identifier, 'value': field_value, 'display_value': display_val, 'units': units, 'digits': digits, 'data_type': data_type, 'is_visible': is_visible, 'is_editable': is_editable, 'choices': choices, } self.get_additional_context( context['field'], model, field_name, context.get('q', '')) return field_template.render(context)
def render(self, context): label, identifier = self.resolve_label_and_identifier(context) user = _resolve_variable(self.user, context) instance = _resolve_variable(self.instance, context) field_template = get_template(_resolve_variable(self.field_template, context)) if not isinstance(identifier, basestring) or not _identifier_regex.match(identifier): raise template.TemplateSyntaxError( 'expected a string with the format "object_name.property" ' 'to follow "from" %s' % identifier ) model_name_or_object_name, field_name = identifier.split(".", 1) model = self.get_model(context, model_name_or_object_name, instance) object_name = to_object_name(model_name_or_object_name) identifier = "%s.%s" % (object_name, field_name) def _field_value(model, field_name): udf_field_name = field_name.replace("udf:", "") if field_name in model._meta.get_all_field_names(): try: val = getattr(model, field_name) except ObjectDoesNotExist: val = None elif _is_udf(model, udf_field_name): val = model.udfs[udf_field_name] else: raise ValueError("Could not find field: %s" % field_name) return val if is_json_field_reference(field_name): field_value = get_attr_from_json_field(model, field_name) choices = None is_visible = is_editable = True data_type = "string" else: field_value = _field_value(model, field_name) data_type, label, choices = field_type_label_choices(model, field_name, label) if user is not None and hasattr(model, "field_is_visible"): is_visible = model.field_is_visible(user, field_name) is_editable = model.field_is_editable(user, field_name) else: # This tag can be used without specifying a user. In that case # we assume that the content is visible and upstream code is # responsible for only showing the content to the appropriate # user is_visible = True is_editable = True digits = units = "" if hasattr(model, "instance"): digits = get_digits_if_formattable(model.instance, object_name, field_name) units = get_units_if_convertible(model.instance, object_name, field_name) if field_value is None: display_val = None elif data_type == "date" and model.instance: display_val = dateformat.format(field_value, model.instance.short_date_format) elif data_type == "date": display_val = dateformat.format(field_value, settings.SHORT_DATE_FORMAT) elif is_convertible_or_formattable(object_name, field_name): display_val = format_value(model.instance, object_name, field_name, field_value) if units != "": display_val += " %s" % units elif data_type == "bool": display_val = trans("Yes") if field_value else trans("No") else: display_val = unicode(field_value) context["field"] = { "label": label, "identifier": identifier, "value": field_value, "display_value": display_val, "units": units, "digits": digits, "data_type": data_type, "is_visible": is_visible, "is_editable": is_editable, "choices": choices, } self.get_additional_context(context["field"]) return field_template.render(context)
def render(self, context): explanation = _resolve_variable(self.explanation, context) label, identifier = self.resolve_label_and_identifier(context) user = _resolve_variable(self.user, context) instance = _resolve_variable(self.instance, context) field_template = get_template(_resolve_variable( self.field_template, context)).template if not isinstance(identifier, basestring)\ or not _identifier_regex.match(identifier): raise template.TemplateSyntaxError( 'expected a string with the format "object_name.property" ' 'to follow "from" %s' % identifier) model_name_or_object_name, field_name = dotted_split(identifier, 2, maxsplit=1) model = self.get_model(context, model_name_or_object_name, instance) object_name = to_object_name(model_name_or_object_name) identifier = "%s.%s" % (object_name, field_name) def _field_value(model, field_name, data_type): udf_field_name = field_name.replace('udf:', '') val = None if field_name in [f.name for f in model._meta.get_fields()]: try: val = getattr(model, field_name) except (ObjectDoesNotExist, AttributeError): pass elif _is_udf(model, udf_field_name): if udf_field_name in model.udfs: val = model.udfs[udf_field_name] # multichoices place a json serialized data-value # on the dom element and client-side javascript # processes it into a view table and edit widget if data_type == 'multichoice': val = json.dumps(val) elif data_type == 'multichoice': val = '[]' else: raise ValueError('Could not find field: %s' % field_name) return val if is_json_field_reference(field_name): field_value = get_attr_from_json_field(model, field_name) choices = None is_visible = is_editable = True data_type = "string" else: add_blank = (ADD_BLANK_ALWAYS if self.treat_multichoice_as_choice else ADD_BLANK_IF_CHOICE_FIELD) data_type, label, explanation, choices = field_type_label_choices( model, field_name, label, explanation=explanation, add_blank=add_blank) field_value = _field_value(model, field_name, data_type) if user is not None and hasattr(model, 'field_is_visible'): is_visible = model.field_is_visible(user, field_name) is_editable = model.field_is_editable(user, field_name) else: # This tag can be used without specifying a user. In that case # we assume that the content is visible and upstream code is # responsible for only showing the content to the appropriate # user is_visible = True is_editable = True digits = units = '' if hasattr(model, 'instance'): digits = get_digits_if_formattable( model.instance, object_name, field_name) units = get_units_if_convertible( model.instance, object_name, field_name) if units != '': units = get_unit_abbreviation(units) if data_type == 'foreign_key': # rendered clientside display_val = '' elif field_value is None: display_val = None elif data_type in ['date', 'datetime']: fmt = (model.instance.short_date_format if model.instance else settings.SHORT_DATE_FORMAT) display_val = dateformat.format(field_value, fmt) elif is_convertible_or_formattable(object_name, field_name): display_val = format_value( model.instance, object_name, field_name, field_value) if units != '': display_val += (' %s' % units) elif data_type == 'bool': display_val = _('Yes') if field_value else _('No') elif data_type == 'multichoice': # this is rendered clientside from data attributes so # there's no meaningful intermediate value to send # without rendering the same markup server-side. display_val = None elif choices: display_vals = [choice['display_value'] for choice in choices if choice['value'] == field_value] display_val = display_vals[0] if display_vals else field_value elif data_type == 'float': display_val = num_format(field_value) else: display_val = unicode(field_value) context['field'] = { 'label': label, 'explanation': explanation, 'identifier': identifier, 'value': field_value, 'display_value': display_val, 'units': units, 'digits': digits, 'data_type': data_type, 'is_visible': is_visible, 'is_editable': is_editable, 'choices': choices, } self.get_additional_context( context['field'], model, field_name, context.get('q', '')) return field_template.render(context)
def render(self, context): label, identifier = self.resolve_label_and_identifier(context) user = _resolve_variable(self.user, context) instance = _resolve_variable(self.instance, context) field_template = get_template(_resolve_variable( self.field_template, context)) if not isinstance(identifier, basestring)\ or not _identifier_regex.match(identifier): raise template.TemplateSyntaxError( 'expected a string with the format "model.property" ' 'to follow "from" %s' % identifier) model_name, field_name = identifier.split('.', 1) model = self.get_model(context, model_name, instance) def _field_value(model, field_name): udf_field_name = field_name.replace('udf:', '') if field_name in model._meta.get_all_field_names(): try: val = getattr(model, field_name) except ObjectDoesNotExist: val = None elif _is_udf(model, udf_field_name): val = model.udfs[udf_field_name] else: raise ValueError('Could not find field: %s' % field_name) return val if is_json_field_reference(field_name): field_value = get_attr_from_json_field(model, field_name) choices = None is_visible = is_editable = True data_type = "string" else: field_value = _field_value(model, field_name) data_type, label, choices = field_type_label_choices( model, field_name, label) if user is not None and hasattr(model, 'field_is_visible'): is_visible = model.field_is_visible(user, field_name) is_editable = model.field_is_editable(user, field_name) else: # This tag can be used without specifying a user. In that case # we assume that the content is visible and upstream code is # responsible for only showing the content to the appropriate # user is_visible = True is_editable = True digits = units = '' if hasattr(model, 'instance'): digits = get_digits_if_formattable( model.instance, model_name, field_name) units = get_units_if_convertible( model.instance, model_name, field_name) if field_value is None: display_val = None elif data_type == 'date' and model.instance: display_val = dateformat.format(field_value, model.instance.short_date_format) elif data_type == 'date': display_val = dateformat.format(field_value, settings.SHORT_DATE_FORMAT) elif is_convertible_or_formattable(model_name, field_name): field_value, display_val = get_display_value( model.instance, model_name, field_name, field_value) if units is not '': display_val += (' %s' % units) else: display_val = unicode(field_value) context['field'] = { 'label': label, 'identifier': identifier, 'value': field_value, 'display_value': display_val, 'units': units, 'digits': digits, 'data_type': data_type, 'is_visible': is_visible, 'is_editable': is_editable, 'choices': choices } self.get_additional_context(context['field']) return field_template.render(context)
def render(self, context): label, identifier = self.resolve_label_and_identifier(context) user = _resolve_variable(self.user, context) instance = _resolve_variable(self.instance, context) field_template = get_template(_resolve_variable( self.field_template, context)) if not isinstance(identifier, basestring)\ or not _identifier_regex.match(identifier): raise template.TemplateSyntaxError( 'expected a string with the format "object_name.property" ' 'to follow "from" %s' % identifier) model_name_or_object_name, field_name = dotted_split(identifier, 2, maxsplit=1) model = self.get_model(context, model_name_or_object_name, instance) object_name = to_object_name(model_name_or_object_name) identifier = "%s.%s" % (object_name, field_name) def _field_value(model, field_name): udf_field_name = field_name.replace('udf:', '') if field_name in model._meta.get_all_field_names(): try: val = getattr(model, field_name) except ObjectDoesNotExist: val = None elif _is_udf(model, udf_field_name): val = model.udfs[udf_field_name] else: raise ValueError('Could not find field: %s' % field_name) return val if is_json_field_reference(field_name): field_value = get_attr_from_json_field(model, field_name) choices = None is_visible = is_editable = True data_type = "string" else: field_value = _field_value(model, field_name) data_type, label, choices = field_type_label_choices( model, field_name, label) if user is not None and hasattr(model, 'field_is_visible'): is_visible = model.field_is_visible(user, field_name) is_editable = model.field_is_editable(user, field_name) else: # This tag can be used without specifying a user. In that case # we assume that the content is visible and upstream code is # responsible for only showing the content to the appropriate # user is_visible = True is_editable = True digits = units = '' if hasattr(model, 'instance'): digits = get_digits_if_formattable( model.instance, object_name, field_name) units = get_units_if_convertible( model.instance, object_name, field_name) if field_value is None: display_val = None elif data_type == 'date' and model.instance: display_val = dateformat.format(field_value, model.instance.short_date_format) elif data_type == 'date': display_val = dateformat.format(field_value, settings.SHORT_DATE_FORMAT) elif is_convertible_or_formattable(object_name, field_name): display_val = format_value( model.instance, object_name, field_name, field_value) if units != '': display_val += (' %s' % units) elif data_type == 'bool': display_val = trans('Yes') if field_value else trans('No') else: display_val = unicode(field_value) context['field'] = { 'label': label, 'identifier': identifier, 'value': field_value, 'display_value': display_val, 'units': units, 'digits': digits, 'data_type': data_type, 'is_visible': is_visible, 'is_editable': is_editable, 'choices': choices } self.get_additional_context(context['field']) return field_template.render(context)
def test_is_convertible_or_formatbile(self): self.assertTrue(is_convertible_or_formattable('test', 'unit_only')) self.assertTrue(is_convertible_or_formattable('test', 'digit_only')) self.assertTrue(is_convertible_or_formattable('test', 'both'))
def render(self, context): label, identifier = self.resolve_label_and_identifier(context) user = _resolve_variable(self.user, context) instance = _resolve_variable(self.instance, context) field_template = get_template(_resolve_variable( self.field_template, context)) if not isinstance(identifier, basestring)\ or not _identifier_regex.match(identifier): raise template.TemplateSyntaxError( 'expected a string with the format "object_name.property" ' 'to follow "from" %s' % identifier) model_name_or_object_name, field_name = dotted_split(identifier, 2, maxsplit=1) model = self.get_model(context, model_name_or_object_name, instance) object_name = to_object_name(model_name_or_object_name) identifier = "%s.%s" % (object_name, field_name) def _field_value(model, field_name, data_type): udf_field_name = field_name.replace('udf:', '') if field_name in model._meta.get_all_field_names(): try: val = getattr(model, field_name) except ObjectDoesNotExist: val = None elif _is_udf(model, udf_field_name): val = model.udfs[udf_field_name] # multichoices place a json serialized data-value # on the dom element and client-side javascript # processes it into a view table and edit widget if data_type == 'multichoice': val = json.dumps(val) else: raise ValueError('Could not find field: %s' % field_name) return val if is_json_field_reference(field_name): field_value = get_attr_from_json_field(model, field_name) choices = None is_visible = is_editable = True data_type = "string" else: data_type, label, choices = field_type_label_choices( model, field_name, label) field_value = _field_value(model, field_name, data_type) if user is not None and hasattr(model, 'field_is_visible'): is_visible = model.field_is_visible(user, field_name) is_editable = model.field_is_editable(user, field_name) else: # This tag can be used without specifying a user. In that case # we assume that the content is visible and upstream code is # responsible for only showing the content to the appropriate # user is_visible = True is_editable = True digits = units = '' if hasattr(model, 'instance'): digits = get_digits_if_formattable( model.instance, object_name, field_name) units = get_units_if_convertible( model.instance, object_name, field_name) if field_value is None: display_val = None elif data_type == 'date' and model.instance: display_val = dateformat.format(field_value, model.instance.short_date_format) elif data_type == 'date': display_val = dateformat.format(field_value, settings.SHORT_DATE_FORMAT) elif is_convertible_or_formattable(object_name, field_name): display_val = format_value( model.instance, object_name, field_name, field_value) if units != '': display_val += (' %s' % units) elif data_type == 'bool': display_val = _('Yes') if field_value else _('No') elif data_type == 'multichoice': # this is rendered clientside from data attributes so # there's no meaningful intermediate value to send # without rendering the same markup server-side. display_val = None else: display_val = unicode(field_value) context['field'] = { 'label': label, 'identifier': identifier, 'value': field_value, 'display_value': display_val, 'units': units, 'digits': digits, 'data_type': data_type, 'is_visible': is_visible, 'is_editable': is_editable, 'choices': choices } self.get_additional_context(context['field']) return field_template.render(context)
def test_is_convertible_or_formatable(self): self.assertTrue(is_convertible_or_formattable("test", "unit_only")) self.assertTrue(is_convertible_or_formattable("test", "digit_only")) self.assertTrue(is_convertible_or_formattable("test", "both")) self.assertTrue(is_convertible_or_formattable("test", "separate_units")) self.assertFalse(is_convertible_or_formattable("test", "random_field"))