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