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 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 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 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 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}
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 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 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 get_last_hotel_id(): r = Session().query(Hotel.id).order_by(Hotel.id)[0][0] print r return r #This function returns the last 5 hotels stored in the system def get_last_hotels(): return Session().query(Hotel).all()[-5:] #Hotel's FieldSet HotelFieldSet = FieldSet(Hotel) HotelFieldSet.append(Field(name='imagem').with_renderer(FileFieldRenderer)) HotelFieldSet.configure( exclude=[HotelFieldSet.latitude,HotelFieldSet.longitude], options=[HotelFieldSet.regiao.dropdown(options=HotelRegiao().get_values()), HotelFieldSet.finalidade.dropdown(options=HotelFim().get_values()), HotelFieldSet.tipo.dropdown(options=HotelTipo().get_values())]) #User's FieldSet UserFieldSet = FieldSet(User) UserFieldSet.insert_after(UserFieldSet.password, Field(name='password2').with_renderer(PasswordFieldRenderer)) UserFieldSet.append(Field(name='password').with_renderer(PasswordFieldRenderer)) UserFieldSet.append(Field('hotel_fim').dropdown(options=HotelFim().get_values())) UserFieldSet.configure(exclude=[UserFieldSet.creation_date]) #TouristicSite's FieldSet TouristicSiteFieldSet = FieldSet(TouristicSite) TouristicSiteFieldSet.configure(exclude=[TouristicSiteFieldSet.latitude,TouristicSiteFieldSet.longitude]) #Service's FieldSet
from bind_config_manager.lib.base import BaseController, render log = logging.getLogger(__name__) import bind_config_manager.lib.helpers as h from bind_config_manager import model from bind_config_manager.model import meta from formalchemy import FieldSet from formalchemy.validators import * DomainFields = FieldSet(model.Domain) DomainFields.configure( options=[ DomainFields.type.dropdown(['master', 'slave']), DomainFields.name.validate(regex('^[\w\.]+$')), DomainFields.soa_nameserver.validate(regex('^[\w\.]+$')), DomainFields.admin_mailbox.validate(regex('^[\w\.]+$')), ], exclude=[DomainFields.records] ) class DomainsController(BaseController): requires_auth = True def index(self): c.domains = meta.Session.query(model.Domain).all() return render('domains/index.html') def new(self):
from pylons import request, response, session, tmpl_context as c, url from pylons.controllers.util import abort, redirect from bind_config_manager.lib.base import BaseController, render log = logging.getLogger(__name__) from bind_config_manager import model from bind_config_manager.model import meta import bind_config_manager.lib.helpers as h import formalchemy from formalchemy import FieldSet UserFields = FieldSet(model.User) UserFields.configure(include=[UserFields.username, UserFields.password, UserFields.is_admin, UserFields.is_active]) UserFields.password.name = 'password' class UsersController(BaseController): requires_admin = True def new(self): c.fs = UserFields return render('users/new.html') def create(self): user = model.User() c.fs = UserFields.bind(user, data=request.POST) if c.fs.validate(): c.fs.sync()
import re from flask import Module, request, session, g, redirect, url_for, \ abort, render_template, flash from formalchemy import FieldSet from formalchemy.base import ModelRenderer from sqlalchemy.exceptions import IntegrityError import model from model import db projects = Module(__name__) project_form = FieldSet(model.Project) project_form.configure(options=[ project_form.description.textarea('70x20'), project_form.rating.hidden(), ]) model_re = re.compile('(\w+)-(\d*)-.*') def split_model(fields): """Find the (ModelClass, id) of the first matching form field. The field names are like ModelClass-id-FieldName """ for field_name, value in fields.items(): m = model_re.match(field_name) if m: model_name, id = m.groups() if not id:
from formalchemy import Grid, FieldSet, config from pyramid_formalchemy.utils import TemplateEngine from fa.jquery import renderers as fa_renderers from pygall import models from pygall.lib.forms.pygallimage import PyGallImageFieldRenderer config.engine = TemplateEngine() FieldSet.default_renderers.update(fa_renderers.default_renderers) Tag = FieldSet(models.Tag) Tag.configure(exclude=[Tag.photos]) TagGrid = Grid(models.Tag) TagGrid.configure(exclude=[TagGrid.photos]) PhotoView = FieldSet(models.Photo) PhotoView.fspot_id.set(readonly=True) PhotoView.md5sum.set(readonly=True) PhotoView.uri.set(renderer=PyGallImageFieldRenderer) PhotoView.configure() PhotoEdit = FieldSet(models.Photo) PhotoEdit.fspot_id.set(readonly=True) PhotoEdit.md5sum.set(readonly=True) PhotoEdit.uri.set(renderer=PyGallImageFieldRenderer, readonly=True) PhotoEdit.configure() PhotoAdd = FieldSet(models.Photo) PhotoAdd.uri.set(renderer=PyGallImageFieldRenderer) PhotoAdd.configure(exclude=[
log = logging.getLogger(__name__) class DatePickerFieldRenderer(FieldRenderer): def render(self): value = self.value and self.value or '' vars = dict(name=self.name, value=value) return """ <input id="%(name)s" class="widthAuto" name="%(name)s" type="text" value="%(value)s" /> """ % vars task_form = FieldSet(Task) task_form.configure(include=[ task_form.task.textarea(), task_form.assigned_to.dropdown( options=[(user.username, user.id) for user in Session.query(User).all()] ).required(), task_form.deadline.with_renderer(DatePickerFieldRenderer), #task_form.tasklist_id, #task_form.project_id.hidden(), ]) class TasksController(BaseController): def __before__(self, action, **params): filter_actions = ["new", "edit", "create", "update", "delete"] if "user" not in session and action in filter_actions: redirect("/users/login") def new(self): # TODO this doesn't work
from pylons import request, response, session, tmpl_context as c, url from pylons.controllers.util import abort, redirect from pylons.decorators.rest import restrict from chrismoylan.lib.base import BaseController, render from chrismoylan.model.meta import Session from chrismoylan.model.comment import Comment from chrismoylan.model.blog import Blog log = logging.getLogger(__name__) comment_form = FieldSet(Comment) comment_form.configure( include=[ comment_form.name, comment_form.email.with_metadata(instructions="Used to help prevent spam but will not be published"), comment_form.content.textarea(), ], focus=False, ) class CommentsController(BaseController): """REST Controller styled on the Atom Publishing Protocol""" # To properly map this controller, ensure your config/routing.py # file has a resource setup: # map.resource('comment', 'comments') @restrict("POST") def create(self, blogid): """POST /comments: Create a new item"""
def cpEdit(context=None): fs = FieldSet(ChannelPermissions,session=__session__) fs.configure(include=[fs.id, fs.perm]) return fs
("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, options=time_options,
# -*- 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()
from bind_config_manager.lib.base import BaseController, render log = logging.getLogger(__name__) import bind_config_manager.lib.helpers as h from bind_config_manager import model from bind_config_manager.model import meta from formalchemy import FieldSet from formalchemy.validators import * RecordFields = FieldSet(model.Record) RecordFields.configure( options=[ RecordFields.type.dropdown(['A', 'CNAME', 'MX', 'NS', 'PTR']), RecordFields.priority.label('Priority (for MX only)'), RecordFields.name.validate(regex('^[@\w\.]+$')), RecordFields.value.validate(regex('^[@\w\.]+$')), ], exclude=[RecordFields.domain] ) class RecordsController(BaseController): requires_auth = True def __before__(self, action, domain_id=None): c.domain = meta.Session.query(model.Domain).filter_by(id=domain_id).first() BaseController.__before__(self) def new(self, domain_id): c.fs = RecordFields.bind(model.Record)
import logging import json from formalchemy import FieldSet, Field from pylons import request, response, session, tmpl_context as c, url from pylons.controllers.util import abort, redirect from ideabox.lib.base import BaseController, Session, render from ideabox.model.user import User log = logging.getLogger(__name__) user_form = FieldSet(User) user_form.configure( include = [ user_form.username.required(), user_form.firstname, user_form.lastname, user_form.email.required() ] ) class UsersController(BaseController): def new(self): return render('users/new.html', {'user_form': user_form.render()}) def create(self): password = request.POST.pop('password') password_conf = request.POST.pop('password2') create_form = user_form.bind(User, data=request.POST) if request.POST and create_form.validate(): user_dict = {
from pylons.decorators.rest import restrict import webhelpers.paginate as paginate from chrismoylan.lib.base import BaseController, render from chrismoylan.model.meta import Session from chrismoylan.model.blog import Blog from chrismoylan.model.tag import Tag from chrismoylan.controllers.comments import comment_form log = logging.getLogger(__name__) blog_form = FieldSet(Blog) blog_form.configure( include = [ blog_form.title.required(), blog_form.date, blog_form.entry.textarea(), blog_form.tags.checkbox()#.with_html(class_='chkbx_lst') ] ) class BlogsController(BaseController): """REST Controller styled on the Atom Publishing Protocol""" # To properly map this controller, ensure your config/routing.py # file has a resource setup: # map.resource('blog', 'blogs') requires_auth = ['new', 'create', 'edit', 'update', 'delete'] #list def index(self, format='html'): """GET /blogs: All items in the collection""" # url('blogs') blogs = Session.query(Blog).order_by(Blog.date.desc())
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) # Theme Theme = FieldSet(models.Theme) Theme.order.set(metadata=dict(mandatory='')).required() Theme.children.set(renderer=TreeItemCheckBoxTreeSet) Theme.configure(exclude=[Theme.parents]) # Functionality Functionality = FieldSet(models.Functionality) Functionality.name.set( renderer=fields.SelectFieldRenderer, options=formalchemy_available_functionalities) Functionality.value.set(metadata=dict(mandatory='')).required() # RestrictionArea RestrictionArea = FieldSet(models.RestrictionArea) RestrictionArea.name.set(metadata=dict(mandatory='')).required() RestrictionArea.layers.set(renderer=LayerCheckBoxTreeSet) RestrictionArea.roles.set(renderer=fields.CheckBoxSet) RestrictionArea.area.set(label=_(u'Restriction area'), options=[ ('map_srid', 900913),
link_id = schema.Column(types.Integer(), schema.ForeignKey('link.id'), primary_key=True) link = relationship("Link", backref="stat_result_assocs") count = schema.Column(types.BigInteger()) class Link(Base, _BaseMixin): __tablename__ = 'link' id = schema.Column(types.Integer, schema.Sequence('link_sq_id', optional=True), primary_key=True) code = schema.Column(types.Text()) s_ns = schema.Column(types.Text()) o_ns = schema.Column(types.Text()) stat_result = association_proxy('stat_result_assocs', 'stat_result', creator=lambda s: StatResult(link=s)) class PropertyLabeled(Base, _BaseMixin): __tablename__ = 'rdf_property_label' id = schema.Column(types.Integer, schema.Sequence('rdf_property_label_id_seq', optional=True), primary_key=True) label_en = schema.Column(types.Text()) uri = schema.Column(types.Text()) count = schema.Column(types.Integer) rdf_property_id = schema.Column(types.Integer) label_en_index_col = schema.Column(postgresql.TSVECTOR) class CkanCatalog(Base, _BaseMixin): __tablename__ = 'ckan_catalog' name = schema.Column(types.Text(), primary_key=True) api_url = schema.Column(types.Text()) # formalchemy RDFDoc_fa = FieldSet(RDFDoc) RDFDoc_fa.configure(options=[RDFDoc_fa.uri.label('URI of the dataset')]) RDFDoc_fa.configure(options=[RDFDoc_fa.uri.validate(validators.required)])
from formalchemy import FieldSet, Grid from datetime import datetime from pylons import request, response, session, tmpl_context as c, url from pylons.controllers.util import abort, redirect from pylons.decorators.rest import restrict from chrismoylan.lib.base import BaseController, Session, render from chrismoylan.model.page import Page log = logging.getLogger(__name__) page_form = FieldSet(Page) page_form.configure( include = [ page_form.title.required(), page_form.content.textarea() ] ) class PagesController(BaseController): """REST Controller styled on the Atom Publishing Protocol""" # To properly map this controller, ensure your config/routing.py # file has a resource setup: # map.resource('page', 'pages') requires_auth = ['new', 'create', 'edit', 'update', 'delete'] #list @restrict('POST') def create(self): """POST /pages: Create a new item""" # url('pages') create_form = page_form.bind(Page, data=request.POST)
import logging from formalchemy import FieldSet from pylons import request, response, session, tmpl_context as c, url from pylons.controllers.util import abort, redirect from ideabox.lib.base import BaseController, Session, render from ideabox.model.project import TaskList log = logging.getLogger(__name__) tasklist_form = FieldSet(TaskList) tasklist_form.configure( include = [ tasklist_form.name.required(), ] ) class TasklistsController(BaseController): def create(self): tasklist_args = { "name": request.params["tasklist_name"], "project_id": request.params["project_id"] } tasklist = TaskList(**tasklist_args) Session.add(tasklist) Session.commit() return redirect("/projects/show/%s" % tasklist.project.id)
from formalchemy import FieldSet, Grid from pylons import request, response, session, tmpl_context as c, url from pylons.controllers.util import abort, redirect from ideabox.lib.base import BaseController, Session, render from ideabox.model.project import Project, TaskList, Task from ideabox.model.user import User import ideabox.model as model log = logging.getLogger(__name__) project_form = FieldSet(Project) project_form.configure( include = [ project_form.name, project_form.description.textarea(), ] ) # TODO project description will get cut off after 300 chars. The use should be warned. class ProjectsController(BaseController): filter_actions = ["new", "edit", "create", "update", "delete", "index"] def new(self): context = { "project_form": project_form.render() } return render("projects/new.html", context)
renderer=fields.SelectFieldRenderer, options=["disabled", "value", "range"]) 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) # Theme Theme = FieldSet(models.Theme) Theme.order.set(metadata=dict(mandatory='')).required() Theme.children.set(renderer=TreeItemCheckBoxTreeSet) Theme.configure(exclude=[Theme.parents]) # Functionality Functionality = FieldSet(models.Functionality) Functionality.name.set( renderer=fields.SelectFieldRenderer, options=formalchemy_available_functionalities) Functionality.value.set(metadata=dict(mandatory='')).required() # RestrictionArea RestrictionArea = FieldSet(models.RestrictionArea) RestrictionArea.name.set(metadata=dict(mandatory='')).required() RestrictionArea.layers.set(renderer=LayerCheckBoxTreeSet) RestrictionArea.roles.set(renderer=fields.CheckBoxSet) RestrictionArea.area.set(label=_(u'Restriction area'), options=[ ('map_srid', 3857),
from pylons import request, response, session, tmpl_context as c, url from pylons.controllers.util import abort, redirect from bind_config_manager.lib.base import BaseController, render log = logging.getLogger(__name__) from pylons.decorators import rest import bind_config_manager.lib.helpers as h from bind_config_manager import model from bind_config_manager.model import meta from formalchemy import FieldSet UserFields = FieldSet(model.User) UserFields.configure(include=[UserFields.username, UserFields.password]) UserFields.password.name = 'password' class AuthController(BaseController): def sign_in(self): c.fs = UserFields.bind(model.User) return render('/auth/sign_in.html') @rest.restrict("POST") def sign_in_submit(self): c.fs = UserFields.bind(model.User, data=request.POST) user = meta.Session.query(model.User).filter_by(username=c.fs.username.value).first() if (user and user.authenticate(c.fs.password.value)): if user.is_active == True: session["user"] = user