def post(self):
fs = FieldSet(self.instance,
data=self.request.POST)
if fs.validate():
fs.sync()
self.session.flush()
return HTTPFound(location=fs.model.getUrl())
def edit_blog_post(request):
session = DBSession()
matchdict = request.matchdict
post = session.query(Post).filter(Post.id == matchdict["post_id"]).one()
if 'submitted' in request.params:
fs = FieldSet(post, data=request.params)
# TODO
# Not sure why this is necessary...shouldn't I just be able to pass the session to FieldSet and have it sync?
post.title = fs.title.value
post.content = fs.content.value
post.modified_time = time.time()
session.add(post)
return HTTPFound(location = route_url("view_blog_post", request, post_id = post.id))
if 'delete' in request.params:
session.delete(post)
return HTTPFound(location = route_url("edit_blog", request))
edit_blog_post_url = route_url("edit_blog_post", request, post_id = post.id)
fs = FieldSet(post)
fs.configure(options=[fs.content.textarea(size=(45, 10))], exclude = [fs["modified_time"], fs["created_time"], fs["user"]])
form = fs.render()
return dict(form = form, title = post.title, edit_blog_post_url = edit_blog_post_url)
def edit_page(request):
"""Edit a given page."""
session = DBSession()
matchdict = request.matchdict
page = session.query(Page).join(User).filter(Page.id == matchdict["page_id"]).order_by(desc(Page.modified_time)).one()
if 'submitted' in request.params:
fs = FieldSet(page, data=request.params)
# TODO
# add validation
# Not sure why this is necessary...shouldn't I just be able to pass the session to FieldSet and have it sync?
page.title = fs.title.value
page.content = fs.content.value
page.modified_time = time.time()
page.location = fs.location.value
session.add(page)
return HTTPFound(location = route_url("view_page", request, page_location = page.location))
elif 'delete' in request.params:
session.delete(page)
return HTTPFound(location = route_url("edit_pages", request))
edit_blog_post_url = route_url("edit_page", request, page_id = page.id)
fs = FieldSet(page)
fs.configure(options=[fs.content.textarea(size=(45, 10))], exclude = [fs["modified_time"], fs["created_time"], fs["user"]])
form = fs.render()
# TODO
# Figure out how to delete using checkboxes
return dict(title = "Edit '%s'" % page.title, save_name = save_name, delete_name = delete_name, form = form)
def readonly_form(self, resource):
"""
returns a read-only view of a model
"""
# Exclude stuff we're displaying as subitems
exclude = []
# subitems_source can be a class or a str here
# we're only interested in str, as it's the name
# of an attribute
for (key, ss) in resource.subsections.items():
exclude.append(ss.subitems_source)
fs = FieldSet(resource.model)
include = []
# render models's fields using FA
# TODO: there's a way to set this on the form itself
# rather than on individual fields
for (k, field) in fs.render_fields.items():
if k not in exclude:
include.append(field.readonly())
else:
pass
fs.configure(include=include)
return fs.render()
def cFilter(context=None):
ffs = FieldSet(Channel,session=__session__)
ffs.permissions.is_collection = True
ffs.configure(include=[ffs.title.label(_(u"Title")),
ffs.permissions.label(_(u"Permissions")),
])
return {'form': ffs}
def _makeFS(klass, fields):
"""
Erzeugt aus einer Feldliste und einer Pythonklasse ein Fieldset fuer alle Felder.
"""
#print fields
fs = FieldSet(klass, session=__session__)
fs.configure(include=[getattr(fs, fname) for fname in fields])
return fs
def post(self):
fs = FieldSet(self.cls, session=self.session).\
bind(self.cls(), data=self.request.POST)
if fs.validate():
fs.sync()
self.session.flush()
return HTTPFound(location=fs.model.getUrl())
else:
return {'fs': fs, 'cls': self.cls}
def __init__(self, user = None):
"""Pre-configuration"""
FieldSet.__init__(self, User)
inc = [
self.username.label(_("* Username you provided when registering")),
self.email.label(_("* E-mail address you provided when registering")).required().validate(email_match),
]
self.configure(include = inc)
def __init__(self, *arg, **kwargs):
"""Pre-configuration"""
FieldSet.__init__(self, *arg, **kwargs)
options = [self.ip_address.required().validate(IPAddressValidator),
self.type.required(),
self.location.textarea(size="25x10"),
self.mac_address.validate(MacAddressValidator)
]
self.configure(options=options)
def __init__(self, user = None):
"""Pre-configuration"""
FieldSet.__init__(self, User)
inc = [self.username.readonly().label(_("Username")),
self.given_name.label(_("* Given name (required, will not be displayed)")),
self.surname.label(_("* Surname (required, will not be displayed)")),
self.homepage.label(_("Homepage (will be displayed)"))
]
self.configure(include = inc)
def __init__(self):
FieldSet.__init__(self, Session)
self.configure(options=[
self.sched_start.label("Scheduled Start"),
self.sched_end.label("Scheduled End"),
self.approved.label("Approved?"),
self.cancelled.label("Cancelled?"),
self.start.label("Actual Start"),
self.end.label("Actual End"),
self.notes.label("Log").textarea()], exclude=[
self.problem])
def __init__(self, user = None):
"""Pre-configuration"""
FieldSet.__init__(self, User)
self.append(Field('password1'))
self.append(Field('password2'))
inc = [
self.password1.password().label(_("* Password")),
self.password2.password().label(_("* Confirm password")).validate(password_match),
]
self.configure(include = inc)
def __init__(self):
FieldSet.__init__(self, User)
self.add(Field('passwd1'))
self.add(Field('passwd2'))
include = [self.username,
self.passwd1.password().label(u'Password'),
self.passwd2.password().label(u'Confirm').\
validate(validators.passwords_match('passwd1')),
self.email,
self.firstname,
self.lastname,
]
self.configure(include=inc)
def __init__(self):
"""Pre-configuration"""
FieldSet.__init__(self, User)
self.append(Field('captcha'))
inc = [self.username.label(_("Username (will be used publicly to identify you on the website)")).validate(username_different),
self.given_name.label(_("* Given name (will not be displayed)")),
self.surname.label(_("* Surname (will not be displayed)")),
self.homepage.label(_("Homepage")),
self.captcha.label(_("Please enter the following number: 314159")).required().validate(captcha_match)
]
self.configure(include = inc)
def __init__(self):
FieldSet.__init__(self, Comment)
self.append(Field('captcha'))
options = [self.content.textarea(size = (45,20))]
inc = [self.name.label(_("Name")),
self.email.label(_("E-mail (will not be shared)")),
self.homepage.label(_("Homepage")),
self.content.label(_("Comment")).required(),
self.captcha.label(_("Please enter the following number: 314159")).required().validate(captcha_match)
]
self.configure(include = inc, options = options)
def cpFilter(context=None):
"""
"""
ffs = FieldSet(ChannelPermissions,session=__session__)
ffs.channel.is_collection = True
self = context.getContextObj()
if shasattr(self, "myDPTransferFolder", acquire=True):
c_field = ffs.channel_id.with_renderer(HiddenFieldRenderer)
else:
c_field = ffs.channel.with_null_as(('---', '')).dropdown(multiple=True,size=5)
ffs.configure(include=[c_field,
ffs.doc_type.label(_(u"Doc. type short")),
ffs.perm.label(_("Permission"))])
return {'form': ffs, 'filter' : p_pre_filter}
def blogpost_form_factory(model, session=None, request=None):
form = FieldSet(model, session=session, request=request)
exclude = [form.user_id, form.user, form.date]
form.configure(exclude=exclude,
options=[
form.text.textarea(),
form.image.with_renderer(
FileFieldRenderer.new(
storage_path=img_storage_path,
)
)
]
)
return form
def __init__(self):
"""Pre-configuration"""
FieldSet.__init__(self, User)
self.add(Field('passwd1'))
self.add(Field('passwd2'))
inc = [self.username,
self.passwd1.password().label(u'Password'),
self.passwd2.password().label(u'Confirm') \
.validate(validators.passwords_match('passwd1')),
self.email,
self.fullname
]
self.configure(include=inc)
def new(self, req, model_name):
model = self.model.get_model_or_404(model_name)
if req.method == 'POST':
item = model()
fs = FieldSet(item, session=session, data=req.form)
if fs.validate():
fs.sync()
item.save()
session.commit()
return self.redirect_to('list', model_name=model_name)
else:
fs = FieldSet(model, session=session)
return self.render_response('_admin/new.jinja',
item=None, model_name=model_name, fs=fs)
def edit(self, req, model_name, id):
model = self.model.get_model_or_404(model_name)
item = model.query.get(id)
if req.method == 'POST':
fs = FieldSet(item, data=req.form)
if fs.validate():
fs.sync()
item.save()
session.commit()
return self.redirect_to('list', model_name=model_name)
else:
fs = FieldSet(item)
return self.render_response('_admin/new.jinja',
item=item, model_name=model_name, fs=fs, crumbs=[model_name, 'Edit'])
def __init__(self, user = None):
"""Pre-configuration"""
FieldSet.__init__(self, User)
self.append(Field('password1'))
self.append(Field('password2'))
inc = [self.username.readonly().label(_("Username")),
self.password1.password().label(_("* Password")),
self.password2.password().label(_("* Confirm password")).validate(password_match),
self.given_name.label(_("* Given name")),
self.surname.label(_("* Surname")),
self.homepage.label(_("Homepage (may be displayed)"))
]
self.configure(include = inc)
def saveedit(request):
model = meta.__dict__.get(request.matchdict["model"])
if "id" in request.matchdict:
obj = request.db.query(model).filter(model.id==request.matchdict["id"]).first()
fs = FieldSet(obj, request=request)
else:
fs = FieldSet(model, session=request.db, request=request)
if fs.validate():
request.db.add(fs.model)
fs.sync()
else:
return { "fs": fs }
return HTTPFound(location=request.route_url("list", model=request.matchdict["model"]))
def edit(request):
model = meta.__dict__.get(request.matchdict["model"])
if "id" in request.matchdict:
obj = request.db.query(model).filter(model.id==request.matchdict["id"]).first()
fs = FieldSet(obj, request=request)
else:
fs = FieldSet(model, session=request.db, request=request)
if "POST"==request.environ.get("REQUEST_METHOD", "").upper() and request.POST:
if fs.validate():
request.db.add(fs.model)
fs.sync()
return HTTPFound(location=request.route_url("list", model=request.matchdict["model"]))
return { 'fs': fs }
class UserForm:
def __init__(self):
#这里的directories是指表单模板存放的地方，我们在第二章提到的templates下创建一个文件夹，命名为form
config.engine = Jinja2Engine(directories=["templates/form"])
#为表单设置label
def setLabel(self):
self.name = self.fs.name.label("User Name")
self.email = self.fs.email.label("Email Address")
self.password = self.fs.password.label("Password")
self.superuser = self.fs.superuser.label("Admin?")
#定义编辑模式下通用的设置，编辑模式包括：新增，修改
def wmode(self, password=None):
self.setLabel()
#因为新增和修改中都需要用户重新确认密码，所以要为表单加入Confirm Password
#如果有指定password的值，说明用户是在修改记录，那么Confirm Password也必须有值
if not password:
self.fs.insert_after(self.fs.password, Field("confirm_password"))
else:
self.fs.insert_after(self.fs.password, Field("confirm_password", value=password))
self.confirm_password = self.fs.confirm_password.label("Re-enter Password")
self.name = self.name.required()
self.email = self.email.required().email().validate(validators.email)
self.password = self.password.required().password()
self.confirm_password = self.confirm_password.required().password()
#定义新增用户时调用的方法
def write_render(self, cls):
#设置Fieldset对象，指定要绑定的sqlalchemy中的表类，并赋予sqlalchemy的session
self.fs = FieldSet(User, session=cls.db)
self.wmode()
#配置表单信息
self.fs.configure(
#表单包含的字段
include=[
self.name,
self.email,
self.password,
self.confirm_password,
self.superuser
]
)
return self.fs
def object_edit(model_slug, model_key=None, **attrs):
if model_slug not in models:
abort(404)
model = models[model_slug]
sk = attrdict()
if model_key:
try:
data = model.q.get_by(id=model_key)
except NoData:
abort(404)
else:
data = model
sk.session = db
if model_key:
obj = model.q.get_by(id=int(model_key))
else:
obj = None
fields = FieldSet(data, **sk)
_fixup_fs(fields, model_key, attrs)
if request.method == 'POST':
fields.rebind(data=request.form)
if fields.validate():
fields.sync()
next_url = url_for('_admin.object_list', model_slug=model_slug)
return redirect(next_url)
context = {
'model_slug': model_slug,
'model': model,
'fields': fields,
}
template_name = '_admin/edit.html' if model_key else '_admin/new.html'
return render_template(template_name, **context)
def __init__(self, user = None):
"""Pre-configuration"""
FieldSet.__init__(self, User)
self.append(Field('password1'))
self.append(Field('password2'))
self.append(Field('captcha'))
inc = [self.username.label(_("* Username (will be used to publicly identify you on the site)")).required().validate(username_different),
self.password1.password().label(_("* Password")).required(),
self.password2.password().label(_("* Confirm password")).required().validate(password_match),
self.email.label(_("* E-mail address (will not be displayed, required only for password recovery)")).required(),
self.given_name.label(_("* Given name (will not be displayed)")).required(),
self.surname.label(_("* Surname (will not be displayed)")).required(),
self.homepage.label(_("Homepage (may be displayed)")),
self.captcha.label(_("Please enter the following number: 314159")).required().validate(captcha_match)
]
self.configure(include = inc)
def new_blog_post(request):
session = DBSession()
if 'submitted' in request.params:
post = Post()
fs = FieldSet(Post, data=request.params)
post.title = fs.title.value
post.content = fs.content.value
now = time.time()
post.modified_time = now
post.created_time = now
post.user_id = authenticated_userid(request)
session.add(post)
return HTTPFound(location = route_url("edit_blog", request))
new_blog_post_url = route_url("new_blog_post", request)
fs = FieldSet(Post, session = session)
fs.configure(options=[fs.content.textarea(size=(45, 10))], exclude = [fs["modified_time"], fs["user"], fs["comments"], fs["created_time"]])
form = fs.render()
return dict(title = _("New Fluid Nexus Blog Post"), form = form, new_blog_post_url = new_blog_post_url)
def add_form(self, resource, dbsession):
"""
returns an edit form for the model
"""
fs = FieldSet(resource.create_transient_subitem(), session=dbsession)
#
# Make the foreign key fields read-only in the add form
#
# 1. If it's a str, we're inside a subsection filtered by
# our parent
if isinstance(resource.subitems_source, str):
parent_wrapper = resource.parent_model()
parent_instance = parent_wrapper.model
relation_attr = getattr(parent_instance.__class__, resource.subitems_source)
child_attr_name = getattr(relation_attr.property.backref, 'key', None)
if child_attr_name is not None:
fs.render_fields[child_attr_name] = fs.render_fields[child_attr_name].hidden()
return fs.render()
def object_edit(model_slug, model_key=None, **attrs):
if model_slug not in models:
abort(404)
model = models[model_slug]
sk = attrdict()
if model_key:
try: data = model.q.get_by(id=model_key)
except NoData: abort(404)
else:
data = model
sk.session = db
if model_key:
obj = model.q.get_by(id=int(model_key))
else:
obj = None
fields = FieldSet(data, **sk)
_fixup_fs(fields,model_key,attrs)
if request.method == 'POST':
fields.rebind(data=request.form)
if fields.validate():
fields.sync()
next_url = url_for('_admin.object_list', model_slug=model_slug)
return redirect(next_url)
context = {
'model_slug': model_slug,
'model': model,
'fields': fields,
}
template_name = '_admin/edit.html' if model_key else '_admin/new.html'
return render_template(template_name, **context)
def new_page(request):
session = DBSession()
if 'submitted' in request.params:
page = Page()
fs = FieldSet(Page, data=request.params)
page.title = fs.title.value
page.content = fs.content.value
page.location = fs.location.value.lower()
now = time.time()
page.modified_time = now
page.created_time = now
page.user_id = authenticated_userid(request)
session.add(page)
return HTTPFound(location = route_url("edit_pages", request))
new_page_url = route_url("new_page", request)
fs = FieldSet(Page, session = session)
fs.configure(options=[fs.content.textarea(size=(45, 10))], exclude = [fs["modified_time"], fs["user"], fs["created_time"]])
form = fs.render()
return dict(title = "Create new Fluid Nexus page", save_name = save_name, form = form)
def save(self, model, data, session):
fs = FieldSet(model, session=session)
fs.rebind(model, data=data)
if fs.validate():
fs.sync()
return True
#TODO: need to return validation result
return False
image_type_options = [
("image/jpeg", _("image/jpeg")),
("image/png", _("image/png"))
]
time_options = [
("disabled", _("disabled")),
("value", _("value")),
("range", _("range")),
]
time_widget_options = [
("slider", _("slider")),
("datepicker", _("datepicker")),
]
# Layer V1
LayerV1 = FieldSet(models.LayerV1)
LayerV1.configure(exclude=[LayerV1.parents_relation])
LayerV1.layer_type.set(
renderer=SelectFieldRenderer,
options=[
("internal WMS", _("internal WMS")),
("external WMS", _("external WMS")),
("WMTS", _("WMTS")),
("no 2D", _("no 2D")),
])
LayerV1.image_type.set(
renderer=SelectFieldRenderer,
options=image_type_options
)
LayerV1.time_mode.set(
renderer=SelectFieldRenderer,
# -*- coding: utf-8 -*- from pyramid_formalchemy.utils import TemplateEngine from pyramidapp import models from formalchemy import Grid, FieldSet from formalchemy import fields from formalchemy import config config.engine = TemplateEngine() FieldSet.default_renderers['dropdown'] = fields.SelectFieldRenderer MyModel = FieldSet(models.MyModel) GridMyModel = Grid(models.MyModel) GridMyModelReadOnly = Grid(models.MyModel) GridMyModelReadOnly.configure(readonly=True) FooEdit = FieldSet(models.Foo) FooEdit.configure()
' checked="checked"' if self._is_checked(functionality.id) else "",
functionality.value)
i += 1
result += '</ul></li>'
return result
##############################################################################
# FIELDS defs
#
# DefaultBasemap, Layer, LayerGroup, Mandant, Printtemplates, RestrictionArea,
# Role, Title, User
#
##############################################################################
# Layer
Layer = FieldSet(models.Layer)
Layer.order.set(metadata=dict(mandatory='')).required()
Layer.layerType.set(
renderer=fields.SelectFieldRenderer,
options=["internal WMS", "external WMS", "WMTS", "no 2D"])
Layer.imageType.set(
renderer=fields.SelectFieldRenderer,
options=["image/jpeg", "image/png"])
Layer.restrictionareas.set(renderer=fields.CheckBoxSet)
Layer.parents.set(readonly=True)
# LayerGroup
LayerGroup = FieldSet(models.LayerGroup)
LayerGroup.order.set(metadata=dict(mandatory='')).required()
LayerGroup.children.set(renderer=TreeItemCheckBoxTreeSet)
LayerGroup.parents.set(readonly=True)
def task_add():
"""Add a new task command to be executed, added by only Supreme Admin by careful planning"""
task = Task()
fs = FieldSet(task)
stage_options = [('', ''), ('Deployment', 'Deployment'),
('Maintenance', 'Maintenance'), ('General', 'General')]
fs.configure(options=[
fs.name.label('Task Name'),
fs.cmd.label('Command'),
fs.params.label('Parameters'),
fs.stage.dropdown(stage_options)
])
if request.method == 'POST':
fs.rebind(data=request.form)
if fs.validate():
fs.sync()
db.session.add(task)
db.session.commit()
flash('Task successfully added!')
fs.rebind(model=Task)
return render_template('tasks/task_add.html', form=fs)
def FieldSet(*args, **kwargs):
fs = FAFieldSet(*args, **kwargs)
fs.session = Session
return fs
