def _value(self):
if isinstance(self.data, (list, tuple)):
return u','.join(as_unicode(v) for v in self.data)
elif self.data:
return as_unicode(self.data)
else:
return u''
def _value(self):
if isinstance(self.data, (list, tuple)):
return u",".join(as_unicode(v) for v in self.data)
elif self.data:
return as_unicode(self.data)
else:
return u""
def format(self, model):
if not model:
return None
if not isinstance(model, DBRef):
return (as_unicode(model.pk), as_unicode(model))
else:
return (as_unicode(model), as_unicode(model))
def test_ajax_fk():
app, db, admin = setup()
Model1, Model2 = create_models(db)
view = CustomModelView(
Model2,
url='view',
form_ajax_refs={'model1': {
'fields': ('test1', 'test2')
}})
admin.add_view(view)
ok_(u'model1' in view._form_ajax_refs)
model = Model1(test1=u'first')
model.save()
model2 = Model1(test1=u'foo', test2=u'bar').save()
# Check loader
loader = view._form_ajax_refs[u'model1']
mdl = loader.get_one(model.id)
eq_(mdl.test1, model.test1)
items = loader.get_list(u'fir')
eq_(len(items), 1)
eq_(items[0].id, model.id)
items = loader.get_list(u'bar')
eq_(len(items), 1)
eq_(items[0].test1, u'foo')
# Check form generation
form = view.create_form()
eq_(form.model1.__class__.__name__, u'AjaxSelectField')
with app.test_request_context('/admin/view/'):
ok_(u'value=""' not in form.model1())
form.model1.data = model
ok_(u'data-json="["%s", "first"]"' %
as_unicode(model.id) in form.model1()
or u'data-json="["%s", "first"]"' %
as_unicode(model.id) in form.model1())
ok_(u'value="%s"' % as_unicode(model.id) in form.model1())
# Check querying
client = app.test_client()
req = client.get(u'/admin/view/ajax/lookup/?name=model1&query=foo')
eq_(req.data.decode('utf-8'), u'[["%s", "foo"]]' % model2.id)
# Check submitting
client.post('/admin/view/new/', data={u'model1': as_unicode(model.id)})
mdl = Model2.objects.first()
ok_(mdl is not None)
ok_(mdl.model1 is not None)
eq_(mdl.model1.id, model.id)
eq_(mdl.model1.test1, u'first')
def format(self, model):
if not model:
return None
if as_unicode(model) != '' and getattr(model, self.pk) is None:
return ('new', as_unicode(model))
else:
return (getattr(model, self.pk), as_unicode(model))
def format(self, model, key_field=None):
if not model:
return None
if not key_field:
key_field = self.options.get('key', 'id')
key = getattr(model, key_field)
return (as_unicode(key), as_unicode(model))
def test_ajax_fk():
app, db, admin = setup()
Model1, Model2 = create_models(db)
view = CustomModelView(
Model2,
url="view",
form_ajax_refs={"model1": {
"fields": ("test1", "test2")
}})
admin.add_view(view)
ok_(u"model1" in view._form_ajax_refs)
model = Model1(test1=u"first")
model.save()
model2 = Model1(test1=u"foo", test2=u"bar").save()
# Check loader
loader = view._form_ajax_refs[u"model1"]
mdl = loader.get_one(model.id)
eq_(mdl.test1, model.test1)
items = loader.get_list(u"fir")
eq_(len(items), 1)
eq_(items[0].id, model.id)
items = loader.get_list(u"bar")
eq_(len(items), 1)
eq_(items[0].test1, u"foo")
# Check form generation
form = view.create_form()
eq_(form.model1.__class__.__name__, u"AjaxSelectField")
with app.test_request_context("/admin/view/"):
ok_(u'value=""' not in form.model1())
form.model1.data = model
needle = u'data-json="["%s", "first"]"' % as_unicode(
model.id)
ok_(needle in form.model1())
ok_(u'value="%s"' % as_unicode(model.id) in form.model1())
# Check querying
client = app.test_client()
req = client.get(u"/admin/view/ajax/lookup/?name=model1&query=foo")
eq_(req.data, u'[["%s", "foo"]]' % model2.id)
# Check submitting
client.post("/admin/view/new/", data={u"model1": as_unicode(model.id)})
mdl = Model2.objects.first()
ok_(mdl is not None)
ok_(mdl.model1 is not None)
eq_(mdl.model1.id, model.id)
eq_(mdl.model1.test1, u"first")
def format_error(error):
if isinstance(error, ValidationError):
return as_unicode(error)
if isinstance(error, wtfValidationError):
return '. '.join(itervalues(error.to_dict()))
return as_unicode(error)
def format_error(error):
if isinstance(error, ValidationError):
return as_unicode(error)
if isinstance(error, wtfValidationError):
return '. '.join(itervalues(error.to_dict()))
return as_unicode(error)
def format(self, model):
if not model:
return None
if self.label_attr:
label = getattr(model, self.label_attr)
else:
label = as_unicode(model)
return (as_unicode(model.id), label)
def handle_view_exception(self, exc):
from sqlalchemy.exc import InvalidRequestError
if isinstance(exc, ValidationError):
flash(as_unicode(exc), category='error')
return True
elif isinstance(exc, InvalidRequestError):
flash(as_unicode(exc), category='error')
return True
return super(ModelViewWithAccess, self).handle_view_exception(exc)
def handle_view_exception(self, exc):
from sqlalchemy.exc import InvalidRequestError
if isinstance(exc, ValidationError):
flash(as_unicode(exc), category='error')
return True
elif isinstance(exc, InvalidRequestError):
flash(as_unicode(exc), category='error')
return True
return super(ModelViewWithAccess, self).handle_view_exception(exc)
def test_ajax_fk():
app, db, admin = setup()
Model1, Model2 = create_models(db)
view = CustomModelView(Model2, url="view", form_ajax_refs={"model1": {"fields": ("test1", "test2")}})
admin.add_view(view)
ok_(u"model1" in view._form_ajax_refs)
model = Model1(test1=u"first")
model.save()
model2 = Model1(test1=u"foo", test2=u"bar").save()
# Check loader
loader = view._form_ajax_refs[u"model1"]
mdl = loader.get_one(model.id)
eq_(mdl.test1, model.test1)
items = loader.get_list(u"fir")
eq_(len(items), 1)
eq_(items[0].id, model.id)
items = loader.get_list(u"bar")
eq_(len(items), 1)
eq_(items[0].test1, u"foo")
# Check form generation
form = view.create_form()
eq_(form.model1.__class__.__name__, u"AjaxSelectField")
with app.test_request_context("/admin/view/"):
ok_(u'value=""' not in form.model1())
form.model1.data = model
needle = u'data-json="["%s", "first"]"' % as_unicode(model.id)
ok_(needle in form.model1())
ok_(u'value="%s"' % as_unicode(model.id) in form.model1())
# Check querying
client = app.test_client()
req = client.get(u"/admin/view/ajax/lookup/?name=model1&query=foo")
eq_(req.data, u'[["%s", "foo"]]' % model2.id)
# Check submitting
client.post("/admin/view/new/", data={u"model1": as_unicode(model.id)})
mdl = Model2.objects.first()
ok_(mdl is not None)
ok_(mdl.model1 is not None)
eq_(mdl.model1.id, model.id)
eq_(mdl.model1.test1, u"first")
def set_category_icon(self, name, icon_value, icon_type="fa"):
cat_text = as_unicode(name)
category = self._menu_categories.get(cat_text)
if category is not None:
category.icon_type = icon_type
category.icon_value = icon_value
def _get_list_filter_args(self):
if self._filters:
filters = []
for n in request.args:
if not n.startswith('flt'):
continue
if '_' not in n:
continue
pos, key = n[3:].split('_', 1)
if key in self._filter_args:
idx, flt = self._filter_args[key]
value = request.args[n]
if value.strip() == '':
continue
if flt.validate(value):
filters.append((pos, (idx, as_unicode(flt.name), value)))
else:
flash(gettext('Invalid Filter Value: %(value)s', value=value), 'error')
# Sort filters
return [v[1] for v in sorted(filters, key=lambda n: n[0])]
return None
def test_ajax_fk_multi():
app, db, admin = setup()
class Model1(db.Model):
__tablename__ = 'model1'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
def __str__(self):
return self.name
table = db.Table(
'm2m', db.Model.metadata,
db.Column('model1_id', db.Integer, db.ForeignKey('model1.id')),
db.Column('model2_id', db.Integer, db.ForeignKey('model2.id')))
class Model2(db.Model):
__tablename__ = 'model2'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
model1_id = db.Column(db.Integer(), db.ForeignKey(Model1.id))
model1 = db.relationship(Model1, backref='models2', secondary=table)
db.create_all()
view = CustomModelView(Model2,
db.session,
url='view',
form_ajax_refs={'model1': {
'fields': ['name']
}})
admin.add_view(view)
ok_(u'model1' in view._form_ajax_refs)
model = Model1(name=u'first')
db.session.add_all([model, Model1(name=u'foo')])
db.session.commit()
# Check form generation
form = view.create_form()
eq_(form.model1.__class__.__name__, u'AjaxSelectMultipleField')
with app.test_request_context('/admin/view/'):
ok_(u'data-json="[]"' in form.model1())
form.model1.data = [model]
ok_(u'data-json="[[1, "first"]]"' in form.model1())
# Check submitting
client = app.test_client()
client.post('/admin/view/new/', data={u'model1': as_unicode(model.id)})
mdl = db.session.query(Model2).first()
ok_(mdl is not None)
ok_(mdl.model1 is not None)
eq_(len(mdl.model1), 1)
def __init__(
self,
base_path,
base_url=None,
name=None,
category=None,
endpoint=None,
url=None,
verify_path=True,
menu_class_name=None,
menu_icon_type=None,
menu_icon_value=None,
):
"""
Constructor.
:param base_path:
Base file storage location
:param base_url:
Base URL for the files
:param name:
Name of this view. If not provided, will default to the class name.
:param category:
View category
:param endpoint:
Endpoint name for the view
:param url:
URL for view
:param verify_path:
Verify if path exists. If set to `True` and path does not exist
will raise an exception.
"""
self.base_path = as_unicode(base_path)
self.base_url = base_url
self.init_actions()
self._on_windows = platform.system() == "Windows"
# Convert allowed_extensions to set for quick validation
if self.allowed_extensions and not isinstance(self.allowed_extensions, set):
self.allowed_extensions = set(self.allowed_extensions)
# Convert editable_extensions to set for quick validation
if self.editable_extensions and not isinstance(self.editable_extensions, set):
self.editable_extensions = set(self.editable_extensions)
# Check if path exists
if not op.exists(base_path):
raise IOError('FileAdmin path "%s" does not exist or is not accessible' % base_path)
super(FileAdmin, self).__init__(
name,
category,
endpoint,
url,
menu_class_name=menu_class_name,
menu_icon_type=menu_icon_type,
menu_icon_value=menu_icon_value,
)
def add_category(self,
name,
class_name=None,
icon_type=None,
icon_value=None):
"""
Add a category of a given name
:param name:
The name of the new menu category.
:param class_name:
The class name for the new menu category.
:param icon_type:
The icon name for the new menu category.
:param icon_value:
The icon value for the new menu category.
"""
cat_text = as_unicode(name)
category = self.get_category_menu_item(name)
if category:
return
category = MenuCategory(name,
class_name=class_name,
icon_type=icon_type,
icon_value=icon_value)
self._menu_categories[cat_text] = category
self._menu.append(category)
def add_menu_item(self, menu_item, target_category=None):
"""
Add menu item to menu tree hierarchy.
:param menu_item:
MenuItem class instance
:param target_category:
Target category name
"""
if target_category:
cat_text = as_unicode(target_category)
category = self._menu_categories.get(cat_text)
# create a new menu category if one does not exist already
if category is None:
category = MenuCategory(target_category)
category.class_name = self.category_icon_classes.get(cat_text)
self._menu_categories[cat_text] = category
self._menu.append(category)
category.add_child(menu_item)
else:
self._menu.append(menu_item)
def __init__(self,
base_path,
base_url=None,
name=None,
category=None,
endpoint=None,
url=None,
verify_path=True,
menu_class_name=None,
menu_icon_type=None,
menu_icon_value=None):
"""
Constructor.
:param base_path:
Base file storage location
:param base_url:
Base URL for the files
:param name:
Name of this view. If not provided, will default to the class name.
:param category:
View category
:param endpoint:
Endpoint name for the view
:param url:
URL for view
:param verify_path:
Verify if path exists. If set to `True` and path does not exist
will raise an exception.
"""
self.base_path = as_unicode(base_path)
self.base_url = base_url
self.init_actions()
self._on_windows = platform.system() == 'Windows'
# Convert allowed_extensions to set for quick validation
if (self.allowed_extensions
and not isinstance(self.allowed_extensions, set)):
self.allowed_extensions = set(self.allowed_extensions)
# Convert editable_extensions to set for quick validation
if (self.editable_extensions
and not isinstance(self.editable_extensions, set)):
self.editable_extensions = set(self.editable_extensions)
# Check if path exists
if not op.exists(base_path):
raise IOError(
'FileAdmin path "%s" does not exist or is not accessible' %
base_path)
super(FileAdmin, self).__init__(name,
category,
endpoint,
url,
menu_class_name=menu_class_name,
menu_icon_type=menu_icon_type,
menu_icon_value=menu_icon_value)
def add_menu_item(self, menu_item, target_category=None):
"""
Add menu item to menu tree hierarchy.
:param menu_item:
MenuItem class instance
:param target_category:
Target category name
"""
if target_category:
cat_text = as_unicode(target_category)
category = self._menu_categories.get(cat_text)
# create a new menu category if one does not exist already
if category is None:
category = MenuCategory(target_category)
category.class_name = self.category_icon_classes.get(cat_text)
self._menu_categories[cat_text] = category
self._menu.append(category)
category.add_child(menu_item)
else:
self._menu.append(menu_item)
def _value(self):
if self.raw_data:
return self.raw_data[0]
elif self.data:
# prevent utf8 characters from being converted to ascii
return as_unicode(json.dumps(self.data, ensure_ascii=False))
else:
return ""
def format_error(error):
if isinstance(error, ValidationError):
return as_unicode(error)
if isinstance(error, wtfValidationError):
try:
return '. '.join(itervalues(error.to_dict()))
except Exception:
resp = ''
for v in error.to_dict().values():
if isinstance(v, dict):
resp += str(v.values())
else:
resp += str(v)
return resp
return as_unicode(error)
def _value(self):
if self.raw_data:
return self.raw_data[0]
elif self.data:
# prevent utf8 characters from being converted to ascii
return as_unicode(json.dumps(self.data, ensure_ascii=False))
else:
return ''
def add_sub_category(self, name, parent_name):
"""
Add a category of a given name underneath
the category with parent_name.
:param name:
The name of the new menu category.
:param parent_name:
The name of a parent_name category
"""
name_text = as_unicode(name)
parent_name_text = as_unicode(parent_name)
category = self.get_category_menu_item(name_text)
parent = self.get_category_menu_item(parent_name_text)
if category is None and parent is not None:
category = SubMenuCategory(name)
self._menu_categories[name_text] = category
parent.add_child(category)
def __call__(self, field, **kwargs):
kwargs.setdefault('data-role', 'select2-ajax')
# field의 options로 정의된 param들을 data-url에 붙여준다.
# 추후필요에 따라 data-url자체를 재정의할 수 있는 방법도 제공해주면 좋겠다.
url = get_url('portal.ajax_model_lookup',
name=field.loader.name,
querym=json.dumps(field.options))
kwargs.setdefault('data-url', url)
# kwargs.setdefault('data-url', field.loader.data_url)
allow_blank = getattr(field, 'allow_blank', False)
if allow_blank and not self.multiple:
kwargs['data-allow-blank'] = u'1'
kwargs.setdefault('id', field.id)
kwargs.setdefault('type', 'hidden')
options_string = []
if self.multiple:
result = []
ids = []
for value in field.data:
data = field.loader.format(value)
options_string.append(
HTMLString('<option %s>%s</option>' %
(html_params(value=data[0]), data[1])))
result.append(data)
ids.append(as_unicode(data[0]))
separator = getattr(field, 'separator', ',')
kwargs['value'] = separator.join(ids)
kwargs['data-json'] = json.dumps(result)
kwargs['data-multiple'] = u'1'
else:
data = field.loader.format(field.data)
if data:
options_string.append(
HTMLString('<option %s>%s</option>' %
(html_params(value=data[0]), data[1])))
kwargs['value'] = data[0]
kwargs['data-json'] = json.dumps(data)
placeholder = gettext(
field.loader.options.get('placeholder', 'Please select model'))
kwargs.setdefault('data-placeholder', placeholder)
return HTMLString('<select %s>%s</select>' % (html_params(
name=field.name, **kwargs), '\n'.join(options_string)))
def __init__(self, base_path):
"""
Constructor.
:param base_path:
Base file storage location
"""
self.base_path = as_unicode(base_path)
self.separator = os.sep
if not self.path_exists(self.base_path):
raise IOError('FileAdmin path "%s" does not exist or is not accessible' % self.base_path)
def __init__(self, base_path):
"""
Constructor.
:param base_path:
Base file storage location
"""
self.base_path = as_unicode(base_path)
self.separator = os.sep
if not self.path_exists(self.base_path):
raise IOError('FileAdmin path "%s" does not exist or is not accessible' % self.base_path)
def handle_view_exception(self, exc):
"""
Override of parent handle_view_exception to accommodate mongo exceptions
:param exc:
:return:
"""
if isinstance(exc, (wtfValidationError, mongoengine.ValidationError)):
flash(as_unicode(exc), 'error')
return True
if current_app.config.get('ADMIN_RAISE_ON_VIEW_EXCEPTION'):
raise
# OperationError because this could be a MongoEngine integrity
# violation - such as violation of REVERSE_DELETE_RULE on a deletion
if isinstance(exc, mongoengine.OperationError) and 'refers' in str(exc):
flash(as_unicode(exc), 'error')
return True
if self._debug:
raise
return False
def _add_menu_item(self, menu_item, target_category):
if target_category:
cat_text = as_unicode(target_category)
category = self._menu_categories.get(cat_text)
if category is None:
category = MenuCategory(target_category)
self._menu_categories[cat_text] = category
self._menu.append(category)
category.add_child(menu_item)
else:
self._menu.append(menu_item)
def _add_menu_item(self, menu_item, target_category):
if target_category:
cat_text = as_unicode(target_category)
category = self._menu_categories.get(cat_text)
# create a new menu category if one does not exist already
if category is None:
category = MenuCategory(target_category)
category.class_name = self.category_icon_classes.get(cat_text)
self._menu_categories[cat_text] = category
self._menu.append(category)
category.add_child(menu_item)
else:
self._menu.append(menu_item)
def __call__(self, field, **kwargs):
kwargs.setdefault('data-role', 'select2-ajax')
kwargs.setdefault('data-url',
get_url('.ajax_lookup', name=field.loader.name))
allow_blank = getattr(field, 'allow_blank', False)
if allow_blank and not self.multiple:
kwargs['data-allow-blank'] = u'1'
kwargs.setdefault('id', field.id)
kwargs.setdefault('type', 'hidden')
if self.multiple:
result = []
ids = []
for value in field.data:
data = field.loader.format(value)
result.append(data)
ids.append(as_unicode(data[0]))
separator = getattr(field, 'separator', ',')
kwargs['value'] = separator.join(ids)
kwargs['data-json'] = json.dumps(result)
kwargs['data-multiple'] = u'1'
else:
data = field.loader.format(field.data)
if data:
kwargs['value'] = data[0]
kwargs['data-json'] = json.dumps(data)
placeholder = field.loader.options.get('placeholder',
gettext('Please select model'))
kwargs.setdefault('data-placeholder', placeholder)
minimum_input_length = int(
field.loader.options.get('minimum_input_length', 1))
kwargs.setdefault('data-minimum-input-length', minimum_input_length)
return HTMLString('<input %s>' %
html_params(name=field.name, **kwargs))
def __call__(self, field, **kwargs):
kwargs.setdefault('data-role', 'select2-ajax')
kwargs.setdefault('data-url', get_url('.ajax_lookup', name=field.loader.name))
allow_blank = getattr(field, 'allow_blank', False)
if allow_blank and not self.multiple:
kwargs['data-allow-blank'] = u'1'
kwargs.setdefault('id', field.id)
kwargs.setdefault('type', 'hidden')
if self.multiple:
result = []
ids = []
for value in field.data:
data = field.loader.format(value)
result.append(data)
ids.append(as_unicode(data[0]))
separator = getattr(field, 'separator', ',')
kwargs['value'] = separator.join(ids)
kwargs['data-json'] = json.dumps(result)
kwargs['data-multiple'] = u'1'
else:
data = field.loader.format(field.data)
if data:
kwargs['value'] = data[0]
kwargs['data-json'] = json.dumps(data)
placeholder = field.loader.options.get('placeholder', gettext('Please select model'))
kwargs.setdefault('data-placeholder', placeholder)
minimum_input_length = int(field.loader.options.get('minimum_input_length', 1))
kwargs.setdefault('data-minimum-input-length', minimum_input_length)
return Markup('<input %s>' % html_params(name=field.name, **kwargs))
def __call__(self, field, **kwargs):
kwargs.setdefault("data-role", "select2-ajax")
kwargs.setdefault("data-url", get_url(".ajax_lookup", name=field.loader.name))
allow_blank = getattr(field, "allow_blank", False)
if allow_blank and not self.multiple:
kwargs["data-allow-blank"] = u"1"
kwargs.setdefault("id", field.id)
kwargs.setdefault("type", "hidden")
if self.multiple:
result = []
ids = []
for value in field.data:
data = field.loader.format(value)
result.append(data)
ids.append(as_unicode(data[0]))
separator = getattr(field, "separator", ",")
kwargs["value"] = separator.join(ids)
kwargs["data-json"] = json.dumps(result)
kwargs["data-multiple"] = u"1"
else:
data = field.loader.format(field.data)
if data:
kwargs["value"] = data[0]
kwargs["data-json"] = json.dumps(data)
placeholder = field.loader.options.get("placeholder", gettext("Please select model"))
kwargs.setdefault("data-placeholder", placeholder)
return HTMLString("<input %s>" % html_params(name=field.name, **kwargs))
def format(self, model):
if not model:
return None
return getattr(model, self.pk), as_unicode(model)
def test_ajax_fk():
app, db, admin = setup()
class BaseModel(peewee.Model):
class Meta:
database = db
class Model1(BaseModel):
test1 = peewee.CharField(max_length=20)
test2 = peewee.CharField(max_length=20)
def __str__(self):
return self.test1
class Model2(BaseModel):
model1 = peewee.ForeignKeyField(Model1)
Model1.create_table()
Model2.create_table()
view = CustomModelView(
Model2,
url='view',
form_ajax_refs={'model1': {
'fields': ('test1', 'test2')
}})
admin.add_view(view)
ok_(u'model1' in view._form_ajax_refs)
model = Model1(test1=u'first', test2=u'')
model.save()
model2 = Model1(test1=u'foo', test2=u'bar')
model2.save()
# Check loader
loader = view._form_ajax_refs[u'model1']
mdl = loader.get_one(model.id)
eq_(mdl.test1, model.test1)
items = loader.get_list(u'fir')
eq_(len(items), 1)
eq_(items[0].id, model.id)
items = loader.get_list(u'bar')
eq_(len(items), 1)
eq_(items[0].test1, u'foo')
# Check form generation
form = view.create_form()
eq_(form.model1.__class__.__name__, u'AjaxSelectField')
with app.test_request_context('/admin/view/'):
ok_(u'value=""' not in form.model1())
form.model1.data = model
ok_(u'data-json="[%s, "first"]"' % as_unicode(model.id)
in form.model1()
or u'data-json="[%s, "first"]"' % as_unicode(model.id))
ok_(u'value="%s"' % as_unicode(model.id) in form.model1())
# Check querying
client = app.test_client()
req = client.get(u'/admin/view/ajax/lookup/?name=model1&query=foo')
eq_(req.data, u'[[%s, "foo"]]' % model2.id)
# Check submitting
client.post('/admin/view/new/', data={u'model1': as_unicode(model.id)})
mdl = Model2.select().first()
ok_(mdl is not None)
ok_(mdl.model1 is not None)
eq_(mdl.model1.id, model.id)
eq_(mdl.model1.test1, u'first')
def format(self, model):
# mudança minima porém necessária, o atributo id no modelo é _id
if not model:
return None
return (as_unicode(model._id), as_unicode(model))
def format(self, model):
# mudança minima porém necessária, o atributo id no modelo é _id
if not model:
return None
return (as_unicode(model._id), as_unicode(model))
def test_ajax_fk():
app, db, admin = setup()
class BaseModel(peewee.Model):
class Meta:
database = db
class Model1(BaseModel):
test1 = peewee.CharField(max_length=20)
test2 = peewee.CharField(max_length=20)
def __str__(self):
return self.test1
class Model2(BaseModel):
model1 = peewee.ForeignKeyField(Model1)
Model1.create_table()
Model2.create_table()
view = CustomModelView(
Model2,
url='view',
form_ajax_refs={
'model1': {
'fields': ('test1', 'test2')
}
}
)
admin.add_view(view)
ok_(u'model1' in view._form_ajax_refs)
model = Model1(test1=u'first', test2=u'')
model.save()
model2 = Model1(test1=u'foo', test2=u'bar')
model2.save()
# Check loader
loader = view._form_ajax_refs[u'model1']
mdl = loader.get_one(model.id)
eq_(mdl.test1, model.test1)
items = loader.get_list(u'fir')
eq_(len(items), 1)
eq_(items[0].id, model.id)
items = loader.get_list(u'bar')
eq_(len(items), 1)
eq_(items[0].test1, u'foo')
# Check form generation
form = view.create_form()
eq_(form.model1.__class__.__name__, u'AjaxSelectField')
with app.test_request_context('/admin/view/'):
ok_(u'value=""' not in form.model1())
form.model1.data = model
needle = u'data-json="[%s, "first"]"' % as_unicode(model.id)
ok_(needle in form.model1())
ok_(u'value="%s"' % as_unicode(model.id) in form.model1())
# Check querying
client = app.test_client()
req = client.get(u'/admin/view/ajax/lookup/?name=model1&query=foo')
eq_(req.data, u'[[%s, "foo"]]' % model2.id)
# Check submitting
client.post('/admin/view/new/', data={u'model1': as_unicode(model.id)})
mdl = Model2.select().first()
ok_(mdl is not None)
ok_(mdl.model1 is not None)
eq_(mdl.model1.id, model.id)
eq_(mdl.model1.test1, u'first')
def test_ajax_fk():
app, db, admin = setup()
class BaseModel(peewee.Model):
class Meta:
database = db
class Model1(BaseModel):
test1 = peewee.CharField(max_length=20)
test2 = peewee.CharField(max_length=20)
def __str__(self):
return self.test1
class Model2(BaseModel):
model1 = peewee.ForeignKeyField(Model1)
Model1.create_table()
Model2.create_table()
view = CustomModelView(
Model2,
url="view",
form_ajax_refs={"model1": {
"fields": ("test1", "test2")
}})
admin.add_view(view)
ok_(u"model1" in view._form_ajax_refs)
model = Model1(test1=u"first", test2=u"")
model.save()
model2 = Model1(test1=u"foo", test2=u"bar")
model2.save()
# Check loader
loader = view._form_ajax_refs[u"model1"]
mdl = loader.get_one(model.id)
eq_(mdl.test1, model.test1)
items = loader.get_list(u"fir")
eq_(len(items), 1)
eq_(items[0].id, model.id)
items = loader.get_list(u"bar")
eq_(len(items), 1)
eq_(items[0].test1, u"foo")
# Check form generation
form = view.create_form()
eq_(form.model1.__class__.__name__, u"AjaxSelectField")
with app.test_request_context("/admin/view/"):
ok_(u'value=""' not in form.model1())
form.model1.data = model
needle = u'data-json="[%s, "first"]"' % as_unicode(model.id)
ok_(needle in form.model1())
ok_(u'value="%s"' % as_unicode(model.id) in form.model1())
# Check querying
client = app.test_client()
req = client.get(u"/admin/view/ajax/lookup/?name=model1&query=foo")
eq_(req.data, u'[[%s, "foo"]]' % model2.id)
# Check submitting
client.post("/admin/view/new/", data={u"model1": as_unicode(model.id)})
mdl = Model2.select().first()
ok_(mdl is not None)
ok_(mdl.model1 is not None)
eq_(mdl.model1.id, model.id)
eq_(mdl.model1.test1, u"first")
def format(self, model):
if not model:
return None
return (getattr(model, self.pk), as_unicode(model))
def test_ajax_fk_multi():
app, db, admin = setup()
class Model1(db.Model):
__tablename__ = 'model1'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
def __str__(self):
return self.name
table = db.Table('m2m', db.Model.metadata,
db.Column('model1_id', db.Integer, db.ForeignKey('model1.id')),
db.Column('model2_id', db.Integer, db.ForeignKey('model2.id'))
)
class Model2(db.Model):
__tablename__ = 'model2'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
model1_id = db.Column(db.Integer(), db.ForeignKey(Model1.id))
model1 = db.relationship(Model1, backref='models2', secondary=table)
db.create_all()
view = CustomModelView(
Model2, db.session,
url='view',
form_ajax_refs={
'model1': {
'fields': ['name']
}
}
)
admin.add_view(view)
ok_(u'model1' in view._form_ajax_refs)
model = Model1(name=u'first')
db.session.add_all([model, Model1(name=u'foo')])
db.session.commit()
# Check form generation
form = view.create_form()
eq_(form.model1.__class__.__name__, u'AjaxSelectMultipleField')
with app.test_request_context('/admin/view/'):
ok_(u'data-json="[]"' in form.model1())
form.model1.data = [model]
ok_(u'data-json="[[1, "first"]]"' in form.model1())
# Check submitting
client = app.test_client()
client.post('/admin/view/new/', data={u'model1': as_unicode(model.id)})
mdl = db.session.query(Model2).first()
ok_(mdl is not None)
ok_(mdl.model1 is not None)
eq_(len(mdl.model1), 1)
def format(self, model):
if not model:
return None
return (as_unicode(model.id), as_unicode(model))
def make_name(base, name):
if base:
return ('%s-%s' % (base, name)).lower()
else:
return as_unicode(name).lower()
def test_ajax_fk():
app, db, admin = setup()
Model1, Model2 = create_models(db)
view = CustomModelView(
Model2,
url='view',
form_ajax_refs={
'model1': {
'fields': ('test1', 'test2')
}
}
)
admin.add_view(view)
ok_(u'model1' in view._form_ajax_refs)
model = Model1(test1=u'first')
model.save()
model2 = Model1(test1=u'foo', test2=u'bar').save()
# Check loader
loader = view._form_ajax_refs[u'model1']
mdl = loader.get_one(model.id)
eq_(mdl.test1, model.test1)
items = loader.get_list(u'fir')
eq_(len(items), 1)
eq_(items[0].id, model.id)
items = loader.get_list(u'bar')
eq_(len(items), 1)
eq_(items[0].test1, u'foo')
# Check form generation
form = view.create_form()
eq_(form.model1.__class__.__name__, u'AjaxSelectField')
with app.test_request_context('/admin/view/'):
ok_(u'value=""' not in form.model1())
form.model1.data = model
needle = u'data-json="["%s", "first"]"' % as_unicode(model.id)
ok_(needle in form.model1())
ok_(u'value="%s"' % as_unicode(model.id) in form.model1())
# Check querying
client = app.test_client()
req = client.get(u'/admin/view/ajax/lookup/?name=model1&query=foo')
eq_(req.data, u'[["%s", "foo"]]' % model2.id)
# Check submitting
client.post('/admin/view/new/', data={u'model1': as_unicode(model.id)})
mdl = Model2.objects.first()
ok_(mdl is not None)
ok_(mdl.model1 is not None)
eq_(mdl.model1.id, model.id)
eq_(mdl.model1.test1, u'first')
def make_name(base, name):
if base:
return ('%s-%s' % (base, name)).lower()
else:
return as_unicode(name).lower()
def format(self, model):
if not model:
return None
return (as_unicode(model.id), as_unicode(model))
