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):
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 "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):
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)
