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()
("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,
("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,
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
