def example_filters(model):
filters = {}
for field in model_fields(model):
if field.can_filter:
name = field.name
name__gte = '{}__gte'.format(name)
name__lte = '{}__lte'.format(name)
if field.foreign_key_to:
filters[name] = _example_value(field)
elif field.type == DATE_TIME:
filters[name__gte] = _example_value(field)
filters[name__lte] = to_tz_dt('2020-02-28 23:59').isoformat()
elif field.type == DATE:
filters[name__gte] = _example_value(field)
filters[name__lte] = date(2020, 2, 28).isoformat()
elif field.type == INTEGER:
filters[name__gte] = _example_value(field)
filters[name__lte] = 20
elif field.type == FLOAT:
filters[name__gte] = _example_value(field)
filters[name__lte] = 200.2
elif field.type == BOOLEAN:
filters[name] = True
else:
raise Exception(
'I am not sure what an example {} filter looks like'.
format(field.type))
return filters
def example_values(model, exclude=[], exclude_uneditable=True):
values = {}
for field in model_fields(model):
if field.name in exclude:
continue
if exclude_uneditable and not field.editable:
continue
values[field.name] = _example_value(field)
return values
def __init__(self,
model,
request_data,
cancel_url,
instance=None,
extra_buttons=None,
show_delete=True):
self.model = model
self.model_fields = model_fields(model)
self.request_data = request_data
self.instance = instance
self.extra_buttons = extra_buttons or []
self.show_delete = show_delete
self.save_button = Button('Save', button_type='submit')
self.delete_button = Button('Delete', button_type='delete')
self.cancel_button = InHref('Cancel', cancel_url, button=True)
self.form = Form([self.save_button, self.delete_button] +
self.extra_buttons)
self._saved = False
self._deleted = False
question = 'Delete this {}?'.format(model.__name__)
confirm_delete_js = WIRE_UP_CONFIRM_DELETE.replace('Delete?', question)
super().__init__(js=confirm_delete_js,
classes=['margin-top', 'edit-table'])
self.append_js("setup_edit_field_turns_yellow('.edit-table', 'tr');")
# You have to add_rows before you handle_clicks because handle_clicks has
# to check to see if the widgets are valid.
self._redo_rows()
self.handle_clicks()
if self.saved():
# But if there's a readonly field that changed based on what the user
# saved, then the old call to add_rows might have out of date data, so
# we'd better redo the rows.
self._redo_rows()
self.buttons_cell.cell_contents.append(DisappearingFeedback())
def field_table(model):
table = Table([
'Field', 'Type', 'Description', 'Can filter', 'Required',
'Not editable'
])
for field in model_fields(model):
field_type = field.type
if field_type == CHAR:
field_type = '{}, max length {}'.format(TEXT, field.max_length)
can_filter = '' if not field.can_filter else 'Filter'
editable = '' if field.editable else 'Not editable'
required = 'Required' if field.required and field.editable else ''
help_text = ''
if isinstance(field.help_text, str):
# The User object has a field whose help_text is a
# django.utils.functional.lazy.<locals>.__proxy__
help_text = field.help_text
table.create_row([
field.name, field_type, help_text, can_filter, required, editable
])
return table
def to_json_dict(instance, publishable_class=None):
model, instance = use_model_instance_for_api(
instance, publishable_class=publishable_class)
as_dict = {TYPE: model.__name__}
for field in model_fields(model):
value = None
if field.foreign_key_to:
value = getattr(instance, '{}_id'.format(field.name))
else:
value = getattr(instance, field.name)
if value is not None:
if field.type in [DATE_TIME, DATE]:
value = value.isoformat()
if isinstance(value, Money):
currency = value.currency.code
value = float(value.amount)
as_dict[corresponding_currency_field_name(field)] = currency
as_dict[field.name] = value
if hasattr(instance, 'add_to_json'):
instance.add_to_json(as_dict)
return as_dict
def _set_fields(instance, request_data, credentials):
for field in model_fields(instance.__class__):
if not field.editable:
continue
specified = field.name in request_data
value = None
if specified:
raw_value = request_data[field.name]
if field.foreign_key_to:
if raw_value:
# This line exists entirely because I need to use
# djaveAPI.models.user.User when it's a foreign key to
# django.contrib.auth.models.User
check_credentials_against = get_publishable_model(
field.foreign_key_to.__name__)
value = credentials.allowed_list(
check_credentials_against).filter(
pk=raw_value).first()
if value is None:
raise Problem((
'Either {} {} does not exist, or your API key does not have '
'access to it').format(
field.foreign_key_to.__name__, raw_value))
if not isinstance(value, field.foreign_key_to):
raise Exception('value should be a {}, not {}'.format(
field.foreign_key_to, value.__class__))
elif field.type in [DATE, DATE_TIME]:
value = _date_or_date_time(field, raw_value)
elif field.type in [FLOAT, INTEGER]:
value = _float_or_integer(field, raw_value)
currency = corresponding_currency_value(field, request_data)
if currency:
value = Money(value, currency)
elif field.type in [TEXT, CHAR]:
if field.max_length and len(raw_value) > field.max_length:
raise Problem((
'{} has a maximum length of {}. You sent a string with '
'length {}').format(field.name, field.max_length,
len(raw_value)))
value = raw_value
elif field.type == BOOLEAN:
value = _boolean(field, raw_value)
else:
raise Exception(field.type)
if field.required:
required_error = False
if specified:
required_error = value in [None, '']
else:
required_error = getattr(instance, field.name) in [None, '']
if required_error:
raise Problem('"{}" is required'.format(field.display_name))
if specified:
setattr(instance, field.name, value)
why_invalid = instance.explain_why_invalid()
if why_invalid:
raise Problem(why_invalid)
instance.save()
return instance
def available_filters(model):
to_return = {}
for field in model_fields(model):
if field.can_filter:
to_return[field.name] = field
return to_return