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 _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 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 _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 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 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