def get_title_from_context(context):
title = None
if IAlchemistContent.providedBy(context):
if IDCDescriptiveProperties.providedBy(context):
title = context.title
else:
props = IDCDescriptiveProperties(context, None)
if props is not None:
title = props.title
else:
title = context.short_name
elif IAlchemistContainer.providedBy(context):
domain_model = context._class
try:
descriptor = queryModelDescriptor(domain_model)
except:
descriptor = None
name = ""
if descriptor:
name = getattr(descriptor, 'container_name', None)
if name is None:
name = getattr(descriptor, 'display_name', None)
if not name:
name = getattr(context, '__name__', None)
title = name
elif ILocation.providedBy(context) and \
IDCDescriptiveProperties.providedBy(context):
title = context.title
return title
def _jsonValues(self, nodes, fields, context):
"""
filter values from the nodes to respresent in json, currently
that means some footwork around, probably better as another
set of adapters.
"""
values = []
domain_model = proxy.removeSecurityProxy(context.domain_model)
domain_interface = queryModelInterface(domain_model)
domain_annotation = queryModelDescriptor(domain_interface)
for n in nodes:
d = {}
# field to dictionaries
for field in fields:
f = field.__name__
getter = field.query
for anno_field in domain_annotation.fields:
if anno_field.name == f:
if getattr(anno_field.listing_column, 'getter', None):
getter = anno_field.listing_column.getter
d[f] = v = getter(n, field)
else:
d[f] = v = field.query(n)
if isinstance(v, datetime.datetime):
d[f] = v.strftime('%F %I:%M %p')
elif isinstance(v, datetime.date):
d[f] = v.strftime('%F')
d['object_id'] = stringKey(n)
values.append(d)
return values
def form_name(self):
parent = self.context.__parent__
if IAlchemistContainer.providedBy(parent):
descriptor = queryModelDescriptor(parent.domain_model)
elif IAlchemistContent.providedBy(self.context):
descriptor = queryModelDescriptor(self.context.__class__)
else:
raise RuntimeError("Unsupported object: %s." % repr(self.context))
if descriptor:
name = getattr(descriptor, 'display_name', None)
if name is None:
name = self.context.__class__.__name__
return name
def type_name(self):
descriptor = queryModelDescriptor(self.domain_model)
if descriptor:
name = getattr(descriptor, "display_name", None)
if not name:
name = getattr(self.domain_model, "__name__", None)
return name
def get_title_from_context(context):
title = None
if IAlchemistContent.providedBy(context):
if IDCDescriptiveProperties.providedBy(context):
title = context.title
else:
props = IDCDescriptiveProperties(context, None)
if props is not None:
title = props.title
else:
title = context.short_name
elif IAlchemistContainer.providedBy(context):
domain_model = context._class
try:
descriptor = queryModelDescriptor(domain_model)
except:
descriptor = None
name = ""
if descriptor:
name = getattr(descriptor, 'container_name', None)
if name is None:
name = getattr(descriptor, 'display_name', None)
if not name:
name = getattr(context, '__name__', None)
title = name
elif ILocation.providedBy(context) and \
IDCDescriptiveProperties.providedBy(context):
title = context.title
return title
def _jsonValues( self, nodes, fields, context):
"""
filter values from the nodes to respresent in json, currently
that means some footwork around, probably better as another
set of adapters.
"""
values = []
domain_model = proxy.removeSecurityProxy( context.domain_model )
domain_interface = queryModelInterface( domain_model )
domain_annotation = queryModelDescriptor( domain_interface )
for n in nodes:
d = {}
# field to dictionaries
for field in fields:
f = field.__name__
getter = field.query
for anno_field in domain_annotation.fields:
if anno_field.name == f:
if getattr(anno_field.listing_column, 'getter', None):
getter=anno_field.listing_column.getter
d[ f ] = v = getter( n , field)
else:
d[ f ] = v = field.query( n )
if isinstance( v, datetime.datetime ):
d[f] = v.strftime('%F %I:%M %p')
elif isinstance( v, datetime.date ):
d[f] = v.strftime('%F')
d['object_id'] = stringKey(n)
values.append( d )
return values
def form_name( self ):
parent = self.context.__parent__
if IAlchemistContainer.providedBy(parent):
descriptor = queryModelDescriptor(parent.domain_model)
elif IAlchemistContent.providedBy(self.context):
descriptor = queryModelDescriptor(self.context.__class__)
else:
raise RuntimeError("Unsupported object: %s." % repr(self.context))
if descriptor:
name = getattr(descriptor, 'display_name', None)
if name is None:
name = self.context.__class__.__name__
return name
def type_name(self):
descriptor = queryModelDescriptor(self.domain_model)
if descriptor:
name = getattr(descriptor, "display_name", None)
if not name:
name = getattr(self.domain_model, "__name__", None)
return name
def validate(self, action, data):
errors = super(AddForm, self).validate(action, data)
errors += self.validateUnique(action, data)
descriptor = queryModelDescriptor(self.domain_model)
for validator in getattr(descriptor, "custom_validators", ()):
errors += validator(action, data, None, self.context)
return errors
def validate(self, action, data):
errors = super(AddForm, self).validate(action, data)
errors += self.validateUnique(action, data)
descriptor = queryModelDescriptor(self.domain_model)
for validator in getattr(descriptor, "custom_validators", ()):
errors += validator(action, data, None, self.context)
return errors
def __init__(self, context, request, view, manager):
self.context = context
self.request = request
self.__parent__ = context.__parent__
self.manager = manager
self.query = None
md = queryModelDescriptor(domain.User)
self.form_fields = md.fields #.select('user_id', 'start_date', 'end_date')
def validate(self, action, data):
errors = super(EditForm, self).validate(action, data)
descriptor = queryModelDescriptor(self.context.__class__)
for validator in getattr(descriptor, "custom_validators", ()):
errors += validator(action, data, self.context, self.context.__parent__)
return errors
def __init__( self, context, request, view, manager ):
self.context = context
self.request = request
self.__parent__= context.__parent__
self.manager = manager
self.query = None
md = queryModelDescriptor(domain.User)
self.form_fields=md.fields #.select('user_id', 'start_date', 'end_date')
def getPropertyExtra( self, property, config ):
inverse_schema = list( interface.implementedBy( config['domain_model'] ) )[0]
inverse_annotation = model.queryModelDescriptor( inverse_schema )
#if self.context.echo:
# print 'i', config['domain_model'], inverse_schema, inverse_annotation
if inverse_annotation and getattr( inverse_annotation,'display_name', None):
# print "found form name"
config['form_name'] = inverse_annotation.display_name
def validate(self, action, data):
errors = super(EditForm, self).validate(action, data)
descriptor = queryModelDescriptor(self.context.__class__)
for validator in getattr(descriptor, "custom_validators", ()):
errors += validator(action, data, self.context, self.context.__parent__)
return errors
def _get_anno_getters_by_field_name(self, context):
domain_model = proxy.removeSecurityProxy(context.domain_model)
domain_interface = queryModelInterface(domain_model)
domain_annotation = queryModelDescriptor(domain_interface)
# dict of domain_annotation field getters by name, for fast lookup
return dict([
(da_field.name, getattr(da_field.listing_column, "getter", None))
for da_field in domain_annotation.fields
])
def __init__(self, context, request):
super(ContainerBrowserView, self).__init__(context, request)
self.domain_model = proxy.removeSecurityProxy(self.context).domain_model
self.domain_interface = queryModelInterface(self.domain_model)
self.domain_annotation = queryModelDescriptor(self.domain_interface)
self.fields = tuple(getFields(
self.context, self.domain_interface, self.domain_annotation))
self.defaults_sort_on = getattr(self.domain_model, "sort_on", None)
self.default_sort_dir = getattr(self.domain_model, "sort_dir", "desc")
self.sort_dir = self.request.get("dir", self.default_sort_dir)
def getFields(context, interface=None, annotation=None):
"""Generator of all fields that will be displayed in a containerlisting
"""
if interface is None:
model = proxy.removeSecurityProxy(context.domain_model)
interface = queryModelInterface(model)
if annotation is None:
annotation = queryModelDescriptor(interface)
for column in annotation.listing_columns:
yield interface[column]
def getFields( context ):
""" get all fields that will be displayed
in a containerlisting
"""
domain_model = proxy.removeSecurityProxy( context.domain_model )
domain_interface = queryModelInterface( domain_model )
domain_annotation = queryModelDescriptor( domain_interface )
for column in domain_annotation.listing_columns:
field = domain_interface[column]
yield field
def getFields(context, interface=None, annotation=None):
"""Generator of all fields that will be displayed in a containerlisting
"""
if interface is None:
model = proxy.removeSecurityProxy(context.domain_model)
interface = queryModelInterface(model)
if annotation is None:
annotation = queryModelDescriptor(interface)
for column in annotation.listing_columns:
yield interface[column]
def getPropertyExtra(self, property, config):
inverse_schema = list(interface.implementedBy(
config['domain_model']))[0]
inverse_annotation = model.queryModelDescriptor(inverse_schema)
#if self.context.echo:
# print 'i', config['domain_model'], inverse_schema, inverse_annotation
if inverse_annotation and getattr(inverse_annotation, 'display_name',
None):
# print "found form name"
config['form_name'] = inverse_annotation.display_name
def getFields(context):
""" get all fields that will be displayed
in a containerlisting
"""
domain_model = proxy.removeSecurityProxy(context.domain_model)
domain_interface = queryModelInterface(domain_model)
domain_annotation = queryModelDescriptor(domain_interface)
for column in domain_annotation.listing_columns:
field = domain_interface[column]
yield field
def __init__( self, context, request, view, manager ):
self.context = context
self.request = request
self.__parent__= view
self.manager = manager
self.query = None
md = queryModelDescriptor(domain.Response)
self.form_fields=md.fields
self.add_url = '%s/responses/add' % ui_url.absoluteURL(
self.context, self.request)
def __init__(self, context, request, view, manager):
self.context = context
self.request = request
self.__parent__ = view
self.manager = manager
self.query = None
md = queryModelDescriptor(domain.Response)
self.form_fields = md.fields
self.add_url = '%s/responses/add' % url.absoluteURL(
self.context, self.request)
def form_name(self):
domain_model = proxy.removeSecurityProxy(self.context).domain_model
descriptor = queryModelDescriptor(domain_model)
if descriptor:
name = getattr(descriptor, "container_name", None)
if name is None:
name = getattr(descriptor, "display_name", None)
if not name:
name = getattr(self.context, "__name__", None)
return name
def form_name(self):
domain_model = proxy.removeSecurityProxy(self.context).domain_model
descriptor = queryModelDescriptor(domain_model)
if descriptor:
name = getattr(descriptor, 'container_name', None)
if name is None:
name = getattr(descriptor, 'display_name', None)
if not name:
name = getattr(self.context, '__name__', None)
return name
def __init__(self, context, request):
super(ContainerBrowserView, self).__init__(context, request)
self.domain_model = proxy.removeSecurityProxy(
self.context).domain_model
self.domain_interface = queryModelInterface(self.domain_model)
self.domain_annotation = queryModelDescriptor(self.domain_interface)
self.fields = tuple(
getFields(self.context, self.domain_interface,
self.domain_annotation))
self.defaults_sort_on = getattr(self.domain_model, "sort_on", None)
self.default_sort_dir = getattr(self.domain_model, "sort_dir", "desc")
self.sort_dir = self.request.get("dir", self.default_sort_dir)
def setUpColumns( domain_model ):
"""
use model descriptor on domain model extract columns for table listings
"""
columns = []
domain_interface = model.queryModelInterface( domain_model )
if not domain_interface:
raise SyntaxError("Model must have domain interface %r"%(domain_model ) )
domain_annotation = model.queryModelDescriptor( domain_interface )
field_column_names = domain_annotation and domain_annotation.listing_columns \
or schema.getFieldNamesInOrder( domain_interface )
# quick hack for now, dates are last in listings
remainder = []
for field_name in field_column_names:
if not field_name in domain_interface:
# we can specify additional columns for tables that are not present in the
# the interface, iff they are fully spec'd as columns in the descriptor/annotation
if domain_annotation \
and field_name in domain_annotation \
and domain_annotation[ field_name ].listing_column:
pass
else:
#print "bad field, container", field_name, domain_interface.__name__
continue
info = domain_annotation and domain_annotation.get( field_name ) or None
if info is not None and info.listing_column:
columns.append(
info.listing_column
)
continue
field = domain_interface[ field_name ]
if isinstance( field, schema.Datetime ):
remainder.append(
column.GetterColumn( title=field.title or field.__name__,
getter=DateGetter( field.query ) )
)
continue
columns.append(
column.GetterColumn( title= ( field.title or field.__name__ ),
getter = Getter( field.query ) )
)
columns.extend( remainder )
return columns
def __init__(self, context, request, view, manager):
super(DisplayViewlet, self).__init__(context, request, view, manager)
# set add url before we change context
self.add_url = self.get_add_url()
target = self.get_target()
if target is None:
self.status = _(u"No item has been set")
else:
self.context = target
self.has_data = True
assert self.factory is not None
descriptor = queryModelDescriptor(self.factory)
self.form_fields = descriptor.fields
def __init__( self, context, request, view, manager):
super(DisplayViewlet, self).__init__(
context, request, view, manager)
# set add url before we change context
self.add_url = self.get_add_url()
target = self.get_target()
if target is None:
self.status = _(u"No item has been set")
else:
self.context = target
self.has_data = True
assert self.factory is not None
descriptor = queryModelDescriptor(self.factory)
self.form_fields = descriptor.fields
def setUpFields( domain_model, mode ):
"""
setup form fields for add/edit/view/search modes, with custom widgets
enabled from model descriptor. this expects the domain model and mode
passed in and will return a form.Fields instance
"""
domain_model = removeSecurityProxy( domain_model )
t = time.time()
domain_interface = model.queryModelInterface( domain_model )
domain_annotation = model.queryModelDescriptor( domain_interface )
search_mode = mode == 'search'
if not domain_annotation:
if search_mode:
form_fields = form.Fields( *setUpSearchFields( domain_interface ) )
else:
form_fields = form.Fields( domain_interface )
return form_fields
fields = []
columns = getattr( domain_annotation, '%s_columns'%mode )
for field_info in columns:
if not field_info.name in domain_interface:
#print "bad field", field_info.name, domain_interface.__name__
continue
custom_widget = getattr( field_info, "%s_widget"%mode )
if search_mode:
fields.append(
form.Field( setUpSearchField( domain_interface[ field_info.name ] ),
custom_widget = custom_widget )
)
else:
fields.append(
form.Field( domain_interface[ field_info.name ],
custom_widget = custom_widget )
)
form_fields = form.Fields( *fields )
#print "field setup cost", time.time()-t
return form_fields
def __init__(self, context, request, view, manager):
self.context = context
self.request = request
self.__parent__ = context.__parent__
self.manager = manager
self.query = None
md = queryModelDescriptor(domain.MemberOfParliament)
self.form_fields = md.fields
session = Session()
trusted = removeSecurityProxy(self.context)
user_id = self.context.user_id
parliament_id = trusted.group.parent_group_id
self.query = session.query(domain.MemberOfParliament).filter(
sql.and_(
domain.MemberOfParliament.user_id == user_id,
domain.MemberOfParliament.group_id == parliament_id)).order_by(
domain.MemberOfParliament.start_date.desc())
self.for_display = self.query.count() > 0
def __call__(self):
context = proxy.removeSecurityProxy(self.context)
self.domain_model = context.domain_model
self.domain_interface = queryModelInterface(self.domain_model)
self.domain_annotation = queryModelDescriptor(self.domain_interface)
session = Session()
self.set_size = 0
self.fields = list(getFields(self.context))
start, limit = self.getOffsets()
batch = self.getBatch(start, limit)
data = dict(length=self.set_size,
start=start,
recordsReturned=len(batch),
sort=self.request.get('sort'),
dir=self.request.get('dir', "asc"),
nodes=batch)
session.close()
return simplejson.dumps(data)
def __call__( self ):
context = proxy.removeSecurityProxy( self.context )
self.domain_model = context.domain_model
self.domain_interface = queryModelInterface( self.domain_model )
self.domain_annotation = queryModelDescriptor( self.domain_interface )
session = Session()
self.set_size = 0
self.fields = list( getFields( self.context ) )
start, limit = self.getOffsets( )
batch = self.getBatch( start, limit)
data = dict( length=self.set_size,
start=start,
recordsReturned=len(batch),
sort = self.request.get('sort'),
dir = self.request.get('dir', "asc"),
nodes=batch )
session.close()
return simplejson.dumps( data )
def expand_containers(self,
items,
containers,
_url,
chain=(),
context=None):
#seen_context = False
current = False
for key, container in containers:
if IAlchemistContainer.providedBy(container):
descriptor = queryModelDescriptor(
proxy.removeSecurityProxy(container).domain_model)
if descriptor:
name = getattr(descriptor, 'container_name', None)
if name is None:
name = getattr(descriptor, 'display_name', None)
if not name:
name = container.domain_model.__name__
else:
assert IDCDescriptiveProperties.providedBy(container)
container = proxy.removeSecurityProxy(container)
name = container.title
if context is not None:
current = container.__name__ == context.__name__
selected = len(chain) == 0 and current
if current:
#seen_context = True
nodes = self.expand(chain)
else:
nodes = ()
items.append({
'title': name,
'url': "%s/%s" % (_url.rstrip('/'), key),
'current': current,
'selected': selected,
'kind': 'container',
'nodes': nodes,
})
def expand_containers(self,
items,
containers,
_url,
chain=(),
context=None):
#seen_context = False
current = False
for key, container in containers:
if IAlchemistContainer.providedBy(container):
descriptor = queryModelDescriptor(
proxy.removeSecurityProxy(container).domain_model)
if descriptor:
name = getattr(descriptor, 'container_name', None)
if name is None:
name = getattr(descriptor, 'display_name', None)
if not name:
name = container.domain_model.__name__
else:
assert IDCDescriptiveProperties.providedBy(container)
container = proxy.removeSecurityProxy(container)
name = container.title
if context is not None:
current = container.__name__ == context.__name__
selected = len(chain) == 0 and current
if current:
#seen_context = True
nodes = self.expand(chain)
else:
nodes = ()
items.append({
'title': name,
'url': "%s/%s" % (_url.rstrip('/'), key),
'current': current,
'selected': selected,
'kind': 'container',
'nodes': nodes,
})
def setUpColumns(domain_model):
"""
use model descriptor on domain model extract columns for table listings
"""
columns = []
domain_interface = model.queryModelInterface(domain_model)
if not domain_interface:
raise SyntaxError("Model must have domain interface %r" % (domain_model))
domain_annotation = model.queryModelDescriptor(domain_interface)
field_column_names = (
domain_annotation and domain_annotation.listing_columns or schema.getFieldNamesInOrder(domain_interface)
)
# quick hack for now, dates are last in listings
remainder = []
for field_name in field_column_names:
if not field_name in domain_interface:
# we can specify additional columns for tables that are not present in the
# the interface, iff they are fully spec'd as columns in the descriptor/annotation
if domain_annotation and field_name in domain_annotation and domain_annotation[field_name].listing_column:
pass
else:
# print "bad field, container", field_name, domain_interface.__name__
continue
info = domain_annotation and domain_annotation.get(field_name) or None
if info is not None and info.listing_column:
columns.append(info.listing_column)
continue
field = domain_interface[field_name]
if isinstance(field, schema.Datetime):
remainder.append(column.GetterColumn(title=field.title or field.__name__, getter=DateGetter(field.query)))
continue
columns.append(column.GetterColumn(title=(field.title or field.__name__), getter=Getter(field.query)))
columns.extend(remainder)
return columns
def __init__( self, context, request, view, manager ):
self.context = context
self.request = request
self.__parent__= context.__parent__
self.manager = manager
self.query = None
md = queryModelDescriptor(domain.MemberOfParliament)
self.form_fields=md.fields
session = Session()
trusted = removeSecurityProxy(self.context)
user_id = self.context.user_id
parliament_id = trusted.group.parent_group_id
self.query = session.query(domain.MemberOfParliament).filter(
sql.and_(
domain.MemberOfParliament.user_id == user_id,
domain.MemberOfParliament.group_id == parliament_id)
).order_by(
domain.MemberOfParliament.start_date.desc())
self.for_display = self.query.count() >0
def setUpViewlet(self, domain_model):
model_schema = list(interface.implementedBy(domain_model))[0]
mapper = orm.class_mapper(domain_model)
domain_annotation = model.queryModelDescriptor(model_schema)
grouped = util.OrderedDict()
for property in mapper.iterate_properties:
if not self.checkProperty(property, model_schema,
domain_annotation):
continue
property_name = property.key
descriptor = domain_annotation.get(property_name)
if descriptor.group in grouped:
grouped[descriptor.group].append(property_name)
else:
grouped[descriptor.group] = [property_name]
for group in grouped:
viewlet_name = self.viewlet_name_template % (domain_model.__name__,
group)
viewlet_name.replace('_', '')
if getattr(content, viewlet_name, None):
continue
inverse_model = mapper.get_property(
grouped[group][0]).mapper.class_
d = dict(group_name=group,
properties=grouped[group],
domain_model=inverse_model)
viewlet_class = type(viewlet_name, (self.base_viewlet, ), d)
zcml_snippet = self.zcml_template % (
"%s.%s" % (domain_model.__name__, group), named(model_schema),
viewlet_name)
setattr(content, viewlet_name, viewlet_class)
def filterFields(context, fields, mode):
"""
filter form fields, context should be an instance of the class.
field mode should be in set of ('add', 'edit', 'search', 'view')
There's a different set of use cases around field filtering,
which involves editable, then readable, then omit based on
permissions, but its a more involved as a use case with formlib
"""
unwrapped = removeSecurityProxy(context)
descriptor = model.queryModelDescriptor(unwrapped)
check = mode in ("add", "edit") and security.canAccess or security.canWrite
omit_names = []
for f in fields:
if check(context, f.__name__):
continue
omit_names.append(f.__name__)
return fields.omit(*omit_names)
def setUpViewlet( self, domain_model ):
model_schema = list( interface.implementedBy(domain_model) )[0]
mapper = orm.class_mapper( domain_model )
domain_annotation = model.queryModelDescriptor( model_schema )
grouped = util.OrderedDict()
for property in mapper.iterate_properties:
if not self.checkProperty( property, model_schema, domain_annotation ):
continue
property_name = property.key
descriptor = domain_annotation.get( property_name )
if descriptor.group in grouped:
grouped[ descriptor.group ].append( property_name )
else:
grouped[ descriptor.group ] = [ property_name ]
for group in grouped:
viewlet_name = self.viewlet_name_template % ( domain_model.__name__, group )
viewlet_name.replace('_', '')
if getattr( content, viewlet_name, None):
continue
inverse_model = mapper.get_property( grouped[group][0] ).mapper.class_
d = dict( group_name = group, properties=grouped[group], domain_model=inverse_model)
viewlet_class = type( viewlet_name, (self.base_viewlet,), d )
zcml_snippet = self.zcml_template%(
"%s.%s"%(domain_model.__name__, group),
named( model_schema ),
viewlet_name
)
setattr( content, viewlet_name, viewlet_class )
def setUpFields(domain_model, mode):
"""
setup form fields for add/edit/view/search modes, with custom widgets
enabled from model descriptor. this expects the domain model and mode
passed in and will return a form.Fields instance
"""
domain_model = removeSecurityProxy(domain_model)
t = time.time()
domain_interface = model.queryModelInterface(domain_model)
domain_annotation = model.queryModelDescriptor(domain_interface)
search_mode = mode == "search"
if not domain_annotation:
if search_mode:
form_fields = form.Fields(*setUpSearchFields(domain_interface))
else:
form_fields = form.Fields(domain_interface)
return form_fields
fields = []
columns = getattr(domain_annotation, "%s_columns" % mode)
for field_info in columns:
if not field_info.name in domain_interface:
# print "bad field", field_info.name, domain_interface.__name__
continue
custom_widget = getattr(field_info, "%s_widget" % mode)
if search_mode:
fields.append(form.Field(setUpSearchField(domain_interface[field_info.name]), custom_widget=custom_widget))
else:
fields.append(form.Field(domain_interface[field_info.name], custom_widget=custom_widget))
form_fields = form.Fields(*fields)
# print "field setup cost", time.time()-t
return form_fields
def filterFields(context, form_fields):
omit_names = []
if IAlchemistContent.providedBy(context):
md = queryModelDescriptor(context.__class__)
for field in form_fields:
try:
can_write = security.canWrite(context, field.__name__)
can_read = security.canAccess(context, field.__name__)
except AttributeError:
can_write = can_read = False
if can_write:
continue
if can_read:
field.for_display = True
field.custom_widget = md.get(field.__name__).view_widget
else:
omit_names.append(field.__name__)
elif not IAlchemistContainer.providedBy(context):
ctx = getattr(context, 'context', None)
if ctx:
filterFields(ctx, form_fields)
else:
raise NotImplementedError
return form_fields.omit(*omit_names)
def filterFields(context, form_fields):
omit_names = []
if IAlchemistContent.providedBy(context):
md = queryModelDescriptor(context.__class__)
for field in form_fields:
try:
can_write = security.canWrite( context, field.__name__)
can_read = security.canAccess( context, field.__name__)
except AttributeError:
can_write = can_read = False
if can_write:
continue
if can_read:
field.for_display = True
field.custom_widget = md.get(field.__name__).view_widget
else:
omit_names.append(field.__name__)
elif not IAlchemistContainer.providedBy(context):
ctx=getattr(context, 'context', None)
if ctx:
filterFields(ctx, form_fields)
else:
raise NotImplementedError
return form_fields.omit(*omit_names)
def filterFields( context, fields, mode ):
"""
filter form fields, context should be an instance of the class.
field mode should be in set of ('add', 'edit', 'search', 'view')
There's a different set of use cases around field filtering,
which involves editable, then readable, then omit based on
permissions, but its a more involved as a use case with formlib
"""
unwrapped = removeSecurityProxy( context )
descriptor = model.queryModelDescriptor( unwrapped )
check = mode in ('add', 'edit') \
and security.canAccess or security.canWrite
omit_names = []
for f in fields:
if check( context, f.__name__ ):
continue
omit_names.append( f.__name__)
return fields.omit( *omit_names )
def title(self):
descriptor = queryModelDescriptor(self.context.domain_model)
return descriptor.container_name
def form_name(self):
descriptor = queryModelDescriptor(self.factory)
return descriptor.display_name
def set_untranslatable_fields_for_display(self):
md = queryModelDescriptor(self.context.__class__)
for field in self.form_fields:
if field.__name__ not in self.translatable_field_names():
field.for_display = True
field.custom_widget = md.get(field.__name__).view_widget
def form_name(self):
descriptor = queryModelDescriptor(self.factory)
return descriptor.display_name
def set_untranslatable_fields_for_display(self):
md = queryModelDescriptor(self.context.__class__)
for field in self.form_fields:
if field.__name__ not in self.translatable_field_names():
field.for_display = True
field.custom_widget = md.get(field.__name__).view_widget
