Пример #1
0
def decode(dump, target=None, target_class=None):
    data = simplejson.loads(dump)
    registry = get_current_registry()

    fields = {}

    # collect all target's fields by their name
    if target:
        for interface in target.__provides__.interfaces():
            for name in getFieldNamesInOrder(interface):
                fields[name] = interface[name]

    # collect all target_class' fields by their name
    if target_class:
        for interface in target_class.__implemented__.interfaces():
            for name in getFieldNamesInOrder(interface):
                fields[name] = interface[name]

    values = {}
    for k, v in data.iteritems():
        # convert dictionary keys from unicode to str
        if isinstance(k, unicode):
            k = k.encode("utf-8")
        # convert dictionary values to proper field values
        if k in fields:
            v = registry.queryMultiAdapter(
                (fields[k], v), IFieldValue, default=v)
        values[k] = v

    return values
Пример #2
0
 def test_renameField(self):
     s = self.s
     s.addField(u'alpha', self.alpha)
     s.renameField(u'alpha', 'beta')
     self.assertEquals(
         [u'beta'],
         getFieldNamesInOrder(s))
Пример #3
0
 def __init__(self, context, request=None):
     self.context = context
     self.request = request
     self.datasets = []
     self.datapoints = {}
     self.schema = IFormDefinition(self.context).schema
     self.fieldnames = getFieldNamesInOrder(self.schema)
Пример #4
0
    def setUpWidgets(self, ignore_request=False):
        self.adapters = self.adapters is not None and self.adapters or {}

        # grab all the adapters and fields from the entire wizard form
        # sequence (till the current step)
        adapters = self.wizard.data_manager.adapters
        fields = self.wizard.data_manager.fields

        # display widgets for bill/ship address
        bill_ship_fields = []
        form_schemas = component.getUtility(interfaces.IFormSchemas)
        for i in (form_schemas.getInterface('billing_address'),
                  form_schemas.getInterface('shipping_address')):
            bill_ship_fields.append(
                fields.select(*schema.getFieldNamesInOrder(i)))
        # make copies of custom widgets.. (typically for edit, we want display)
        bill_ship_fields = sanitize_custom_widgets(
            reduce(operator.__add__, bill_ship_fields))

        self.widgets = form.setUpEditWidgets(bill_ship_fields,
                                             self.prefix,
                                             self.context,
                                             self.request,
                                             adapters=adapters,
                                             for_display=True,
                                             ignore_request=ignore_request)
Пример #5
0
    def search_form(self):
        uuid = self.data.get('uuid', None)
        obj = uuidToObject(uuid)
        if not self.has_listing_search(obj):
            return

        available_fields = []
        tileType = queryUtility(ITileType, name=self.__name__)
        conf = self.get_tile_configuration()
        for name in getFieldNamesInOrder(tileType.schema):
            if name in conf:
                field_conf = conf[name]
                if ('visibility' in field_conf and
                        field_conf['visibility'] == u'off'):
                    # If the field was configured to be invisible, then just
                    # ignore it
                    continue
            if name.startswith('form_'):
                available_fields.append(name.split('form_')[1])

        search_form = ListingSearchForm(aq_inner(obj), self.request)
        search_form.fields = search_form.fields.select(*available_fields)
        search_form.search_url = self.search_url()
        if HAS_WRAPPED_FORM:
            alsoProvides(search_form, IWrappedForm)
        search_form.update()
        return search_form
Пример #6
0
    def _set_default_configuration(self):
        defaults = {}
        tile_type = getUtility(ITileType, name=self.tile.__name__)
        fields = getFieldNamesInOrder(tile_type.schema)

        for name, field in getFieldsInOrder(tile_type.schema):
            order = unicode(fields.index(name))
            # default configuration attributes for all fields
            defaults[name] = {'order': order, 'visibility': u'on'}
            if name == 'css_class':
                # css_class, set default
                defaults[name] = field.default
            if ITextLine.providedBy(field):
                # field is TextLine, we should add 'htmltag'
                defaults[name]['htmltag'] = u'h2'
            elif INamedBlobImageField.providedBy(field):
                # field is an image, we should add 'position' and 'imgsize'
                defaults[name]['position'] = u'left'
                defaults[name]['imgsize'] = u'mini 200:200'
            elif IInt.providedBy(field):
                defaults[name][name] = field.default
            elif IDatetime.providedBy(field):
                # field is Datetime, we should add 'format'
                defaults[name]['format'] = 'datetime'

        return defaults
Пример #7
0
    def _set_default_configuration(self):
        defaults = {}
        tile_type = getUtility(ITileType, name=self.tile.__name__)
        fields = getFieldNamesInOrder(tile_type.schema)

        for name, field in getFieldsInOrder(tile_type.schema):
            order = unicode(fields.index(name))
            # default configuration attributes for all fields
            defaults[name] = {"order": order, "visibility": u"on"}
            if name == "css_class":
                # css_class, set default
                defaults[name] = field.default
            if ITextLine.providedBy(field):
                # field is TextLine, we should add 'htmltag'
                defaults[name]["htmltag"] = u"h2"
            elif INamedBlobImageField.providedBy(field):
                # field is an image, we should add 'position' and 'imgsize'
                defaults[name]["position"] = u"left"
                defaults[name]["imgsize"] = u"mini 200:200"
            elif IInt.providedBy(field):
                defaults[name][name] = field.default
            elif IDatetime.providedBy(field):
                # field is Datetime, we should add 'format'
                defaults[name]["format"] = "datetime"

        return defaults
Пример #8
0
    def _set_default_configuration(self):
        defaults = {}
        tile_type = getUtility(ITileType, name=self.tile.__name__)
        fields = getFieldNamesInOrder(tile_type.schema)

        for name, field in getFieldsInOrder(tile_type.schema):
            order = unicode(fields.index(name))
            # default configuration attributes for all fields
            defaults[name] = {'order': order, 'visibility': u'on'}
            if name == 'css_class':
                # css_class, set default
                defaults[name] = field.default
            if ITextLine.providedBy(field):
                # field is TextLine, we should add 'htmltag'
                defaults[name]['htmltag'] = u'h2'
            elif INamedBlobImageField.providedBy(field):
                # field is an image, we should add 'position' and 'imgsize'
                defaults[name]['position'] = u'left'
                defaults[name]['imgsize'] = u'mini 200:200'
            elif IInt.providedBy(field):
                defaults[name][name] = field.default
            elif IDatetime.providedBy(field):
                # field is Datetime, we should add 'format'
                defaults[name]['format'] = 'datetime'

        return defaults
Пример #9
0
class DisplayView(BrowserView):
    """Simple display-view base class.

    Subclasses should provide a `schema` attribute defining the schema
    to be displayed.
    """

    errors = ()
    update_status = ''
    label = ''

    # Fall-back field names computes from schema
    fieldNames = property(lambda self: getFieldNamesInOrder(self.schema))

    def __init__(self, context, request):
        super(DisplayView, self).__init__(context, request)
        self._setUpWidgets()

    def _setUpWidgets(self):
        self.adapted = self.schema(self.context)
        setUpDisplayWidgets(self,
                            self.schema,
                            source=self.adapted,
                            names=self.fieldNames)

    def setPrefix(self, prefix):
        for widget in self.widgets():
            widget.setPrefix(prefix)

    def widgets(self):
        return [getattr(self, name + '_widget') for name in self.fieldNames]
Пример #10
0
def format_street_address(item, formatter):
    address_parts = []
    for attribute in getFieldNamesInOrder(IAddress):
        address_part = getattr(item, attribute, None)
        if address_part is not None:
            address_parts.append(address_part)
    return ", ".join(address_parts)
Пример #11
0
    def _normalize(self):
        if self.for_ is None:
            self.for_ = self.schema

        if self.class_ is None:
            self.bases = (self.view,)
        else:
            self.bases = (self.class_, self.view)

        if self.template is not None:
            self.template = os.path.abspath(str(self.template))
            if not os.path.isfile(self.template):
                raise ConfigurationError("No such file", self.template)
        else:
            self.template = self.default_template

        self.names = getFieldNamesInOrder(self.schema)

        if self.fields:
            for name in self.fields:
                if name not in self.names:
                    raise ValueError("Field name is not in schema",
                                     name, self.schema)
        else:
            self.fields = self.names
Пример #12
0
 def test_removeField(self):
     s = self.s
     s.addField(u'alpha', self.alpha)
     s.removeField(u'alpha')
     self.assertEquals(
         [],
         getFieldNamesInOrder(s))
Пример #13
0
def format_street_address(item, formatter):
    address_parts = []
    for attribute in getFieldNamesInOrder(IAddress):
        address_part = getattr(item, attribute, None)
        if address_part is not None:
            address_parts.append(address_part)
    return ", ".join(address_parts)
Пример #14
0
 def __init__(self, context, request=None):
     ## context should be context of API view, not API view itself
     self.context = context
     self.__parent__ = context  # may be re-parented by API to view
     self.request = getRequest() if request is None else request
     self.definition = IFormDefinition(self.context)
     self._schema = self.definition.schema
     self._fieldnames = getFieldNamesInOrder(self._schema)
Пример #15
0
 def test_insertField(self):
     s = self.s
     s.addField(u'alpha', self.alpha)
     beta = Text(title=u"Beta")
     s.insertField(u'beta', beta, 0)
     self.assertEquals(
         [u'beta', u'alpha'],
         getFieldNamesInOrder(s))
Пример #16
0
 def __init__(self, schema, **kwargs):
     if IInterface.providedBy(schema):
         self.identifier = schema.__identifier__
     else:
         self.identifier = str(schema)
     for name in getFieldNamesInOrder(interfaces.IFlavor):
         if name in kwargs:
             setattr(self, name, kwargs.get(name))
Пример #17
0
def get_unknown_fields(action_data, schema):
    """Return an error list of unknown fields that are not part of the schema.
    """
    errors = []
    known_field_names = getFieldNamesInOrder(schema)
    for key in action_data:
        if key not in known_field_names:
            errors.append((key, UnknownField(key)))
    return errors
Пример #18
0
def getFields(context):
    domain_model = proxy.removeSecurityProxy(context.domain_model)
    domain_interface = queryModelInterface(domain_model)
    field_names = schema.getFieldNamesInOrder(domain_interface)
    for f in field_names:
        field = domain_interface[f]
        if isinstance(field, (schema.Choice, schema.Object, schema.List, schema.Tuple, schema.Bytes)):
            continue
        yield field
Пример #19
0
def get_unknown_fields(action_data, schema):
    """Return an error list of unknown fields that are not part of the schema.
    """
    errors = []
    known_field_names = getFieldNamesInOrder(schema)
    for key in action_data:
        if key not in known_field_names:
            errors.append((key, UnknownField(key)))
    return errors
Пример #20
0
 def test_insertFieldCornerCases(self):
     s = self.s
     gamma = Text(title=u"Gamma")
     # it's still possible to insert at beginning
     s.insertField(u'gamma', gamma, 0)
     self.assertEquals(
         [u'gamma'],
         getFieldNamesInOrder(s))
     # should be allowed to insert field at the end
     s.insertField(u'alpha', self.alpha, 1)
     self.assertEquals(
         [u'gamma', u'alpha'],
         getFieldNamesInOrder(s))
     # should be allowed to insert field at the beginning still
     delta = Text(title=u"Delta")
     s.insertField(u'delta', delta, 0)
     self.assertEquals(
         [u'delta', u'gamma', u'alpha'],
         getFieldNamesInOrder(s))
Пример #21
0
def getFields( context ):
    domain_model = proxy.removeSecurityProxy( context.domain_model )
    domain_interface = queryModelInterface( domain_model )
    field_names = schema.getFieldNamesInOrder( domain_interface )
    for f in field_names:
        field = domain_interface[ f ]
        if isinstance( field,  ( schema.Choice, schema.Object,
                                 schema.List, schema.Tuple, schema.Bytes ) ):
            continue
        yield field
 def available_fields(self):
     fields = []
     names = [
         name for name in getFieldNamesInOrder(IListingSearchTile)
         if name.startswith('form_')
     ]
     for name in names:
         if self.data.get(name, False):
             fields.append(name.split('form_')[1])
     return fields
Пример #23
0
    def push_data(self):
        data = self.request.get('json', '[]')
        data_list = json.loads(data)
        names = getFieldNamesInOrder(IAnalysisResults)
        names.remove('uuid')
        names.remove('sample_no')
        success_count = 0

        for entry in data_list:
            return_obj = ReturnData()
            [setattr(return_obj, key, entry[key]) for key in entry]
            errors = schema.getValidationErrors(IAnalysisResults, return_obj)

            if errors:
                msg = []
                for error in errors:
                    error_type = error[1].__class__.__name__
                    field_value = unicode(error[1])
                    err = u'{0}: {1}; '.format(error_type, field_value)
                    msg.append(err)
                msg = ''.join(msg)
                entry.update(dict(_back_success=False, _back_message=msg))
                logger.warn(msg)
                continue
            else:
                uuid = entry['uuid']
                obj = api.content.uuidToObject(uuid)
                if obj:
                    [setattr(obj, k, entry[k]) for k in entry if k in names]
                    old_steps = obj.steps
                    new_steps = u'step5'
                    obj.steps = new_steps
                    notify(StepsChangedEvent(obj, old_steps, new_steps))
                    modified(obj)
                    try:
                        api.content.transition(obj=obj, transition='submit')
                    except (MissingParameterError,
                            InvalidParameterError) as error:
                        msg = 'Warning, {0}'.format(str(error))
                        logger.warn(error)
                    else:
                        msg = 'Success.'
                    success_count += 1
                    entry.update(dict(_back_success=True, _back_message=msg))
                else:
                    msg = u'Warning, ' \
                          u'uuid "{0}" not found, skipping.'.format(uuid)
                    entry.update(dict(_back_success=False, _back_message=msg))
                    logger.warn(msg)

        failed_count = len(data_list) - success_count
        msg = u'Analysis of Results: {0} Item Succeeded, ' \
              u'{1} Item Failed.'.format(success_count, failed_count)
        logger.info(msg)
        return json.dumps(data_list)
Пример #24
0
def values(obj):
    registry = get_current_registry()
    values = {}
    for interface in obj.__provides__.interfaces():
        for name in getFieldNamesInOrder(interface):
            field = interface[name]
            bound = field.bind(obj)
            value = bound.get(obj)
            values[name] = registry.queryMultiAdapter(
                (field, value), IJSONValue, default=value)
    return values
Пример #25
0
    def __init__(cls, name, bases, dct, map_kind=True):
        """Initializes a class that might implement interfaces"""

        registry = get_current_registry()
        implements = getattr(cls, "__implements_advice_data__", None)
        for interface in (implements and implements[0] or ()):
            for name in schema.getFieldNamesInOrder(interface):
                field = interface[name]
                setattr(cls, name, registry.getAdapter(field, IProperty))
                dct.update({name: getattr(cls, name)})
        super(SchemaPropertiedClass, cls).__init__(name, bases, dct, map_kind)
Пример #26
0
 def __init__(self, context, request):
     self.context = context
     self.request = request
     self.portal = getSite()
     self.definition = IFormDefinition(self.context)
     self.series = context.__parent__  # assumes series <>--- form
     self.title = '%s: %s' % (self.series.Title().strip(), context.Title())
     self.seriesinfo = dict(
         [(k, v) for k, v in self.series.__dict__.items()
          if v is not None and k in getFieldNamesInOrder(IFormSeries)]
         )
Пример #27
0
 def renameField(self, orig_name, target_name):
     """See zope.app.interfaces.utilities.IMutableSchema"""
     fields = getFieldNamesInOrder(self)
     if orig_name not in fields:
         raise KeyError("Field %s does not exists." % orig_name)
     if target_name in fields:
         raise KeyError("Field %s already exists." % target_name)
     field = self[orig_name]
     del self[orig_name]
     field.__name__ = None
     self[target_name] = field
Пример #28
0
 def __init__(self, context, request):
     self.context = context
     self.request = request
     self.portal = getSite()
     self.definition = IFormDefinition(self.context)
     self.series = context.__parent__  # assumes series <>--- form
     self.title = '%s: %s' % (self.series.Title().strip(), context.Title())
     self.seriesinfo = dict([
         (k, v) for k, v in self.series.__dict__.items()
         if v is not None and k in getFieldNamesInOrder(IFormSeries)
     ])
Пример #29
0
    def getContent(self):
        data = {'batch_list': []}
        names = getFieldNamesInOrder(self._list_schema)

        for obj in self.items:
            record = {}
            for name in names:
                record[name] = getattr(obj, name, None)
            record['uuid'] = obj.UID()
            data['batch_list'].append(record)

        return data
Пример #30
0
    def testSA2ZS(self):

        iusers = transmute(users)
        self.assertEqual(tuple(schema.getFieldNamesInOrder(iusers)), ("user_id", "user_name"))

        fields = dict(schema.getFieldsInOrder(iusers))
        # assert types and constraints
        self.assertTrue(isinstance(fields["user_id"], schema.Int))
        self.assertTrue(fields["user_id"].required)
        self.assertTrue(isinstance(fields["user_name"], schema.TextLine))
        self.assertEqual(fields["user_name"].max_length, 40)
        self.assertEqual(fields["user_name"].default, u"hello world")
Пример #31
0
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
Пример #32
0
    def test_syncSchema_overwrite(self):
        class ISource(Interface):
            one = schema.TextLine(title=u"A")
            two = schema.Int(title=u"B")

        class IDest(Interface):
            one = schema.TextLine(title=u"C")
            three = schema.Int(title=u"D")

        ISource.setTaggedValue("tag1", "tag one")
        ISource.setTaggedValue("tag2", "tag two")
        IDest.setTaggedValue("tag1", "first tag")

        utils.syncSchema(ISource, IDest, overwrite=True)

        self.assertEquals(u"A", IDest['one'].title)

        self.assertEquals(['one', 'two'], getFieldNamesInOrder(ISource))
        self.assertEquals(['one', 'two'], getFieldNamesInOrder(IDest))

        self.assertEquals("tag one", IDest.getTaggedValue("tag1"))
        self.assertEquals("tag two", IDest.getTaggedValue("tag2"))
Пример #33
0
 def __getattr__(self, name):
     """If field, return default for attribute value"""
     if name.startswith('_v_'):
         raise AttributeError(name)  # no magic tricks with these.
     schema = self.__class__.schema.__get__(self)  # aq property workaround!
     if name == 'schema':
         return schema
     if schema is not None:
         fieldnames = getFieldNamesInOrder(schema)
         if name in fieldnames:
             field = schema.get(name)
             return field.default
     raise AttributeError(name)
Пример #34
0
    def testSA2ZS(self):

        iusers = transmute(users)
        self.assertEqual(tuple(schema.getFieldNamesInOrder(iusers)),
                         ('user_id', 'user_name'))

        fields = dict(schema.getFieldsInOrder(iusers))
        # assert types and constraints
        self.assertTrue(isinstance(fields['user_id'], schema.Int))
        self.assertTrue(fields['user_id'].required)
        self.assertTrue(isinstance(fields['user_name'], schema.TextLine))
        self.assertEqual(fields['user_name'].max_length, 40)
        self.assertEqual(fields['user_name'].default, u'hello world')
Пример #35
0
    def test_syncSchema(self):
        class ISource(Interface):
            one = schema.TextLine(title=u"A")  # order: 0
            two = schema.Int(title=u"B")  # order: 1

        class IDest(Interface):
            one = schema.TextLine(title=u"C")  # order: 0
            three = schema.Int(title=u"D")  # order: 1

        ISource.setTaggedValue("tag1", "tag one")
        ISource.setTaggedValue("tag2", "tag two")
        IDest.setTaggedValue("tag1", "first tag")

        utils.syncSchema(ISource, IDest)

        self.assertEqual(u"C", IDest['one'].title)

        self.assertEqual(['one', 'two'], getFieldNamesInOrder(ISource))
        self.assertEqual(['two', 'one', 'three'], getFieldNamesInOrder(IDest))

        self.assertEqual("first tag", IDest.getTaggedValue("tag1"))
        self.assertEqual("tag two", IDest.getTaggedValue("tag2"))
Пример #36
0
 def __getattr__(self, name):
     """If field, return default for attribute value"""
     if name.startswith('_v_'):
         raise AttributeError(name)  # no magic tricks with these.
     schema = self.__class__.schema.__get__(self)  # aq property workaround!
     if name == 'schema':
         return schema
     if schema is not None:
         fieldnames = getFieldNamesInOrder(schema)
         if name in fieldnames:
             field = schema.get(name)
             return field.default
     raise AttributeError(name)
Пример #37
0
    def test_syncSchema_overwrite(self):
        class ISource(Interface):
            one = schema.TextLine(title=u"A")
            two = schema.Int(title=u"B")

        class IDest(Interface):
            one = schema.TextLine(title=u"C")
            three = schema.Int(title=u"D")

        ISource.setTaggedValue("tag1", "tag one")
        ISource.setTaggedValue("tag2", "tag two")
        IDest.setTaggedValue("tag1", "first tag")

        utils.syncSchema(ISource, IDest, overwrite=True)

        self.assertEqual(u"A", IDest["one"].title)

        self.assertEqual(["one", "two"], getFieldNamesInOrder(ISource))
        self.assertEqual(["one", "two"], getFieldNamesInOrder(IDest))

        self.assertEqual("tag one", IDest.getTaggedValue("tag1"))
        self.assertEqual("tag two", IDest.getTaggedValue("tag2"))
Пример #38
0
    def setUpWidgets(self, ignore_request=False):
        self.adapters = self.adapters is not None and self.adapters or {}

        # grab all the adapters and fields from the entire wizard form sequence
        # (till the current step)
        adapters = self.wizard.data_manager.adapters
        fields = self.wizard.data_manager.fields

        formSchemas = component.getUtility(interfaces.IFormSchemas)
        # edit widgets for payment info
        self.widgets = form.setUpEditWidgets(
            self.form_fields.select(
                *schema.getFieldNamesInOrder(
                    formSchemas.getInterface('payment')
                )
            ),
            self.prefix, self.context, self.request,
            adapters=adapters, ignore_request=ignore_request
            )

        # display widgets for bill/ship address
        bill_ship_fields = []
        for i in (formSchemas.getInterface('billing_address'),
                  formSchemas.getInterface('shipping_address')):
            bill_ship_fields.append(
                fields.select(
                    *schema.getFieldNamesInOrder(i)
                )
            )
        # make copies of custom widgets.. (typically for edit, we want display)
        bill_ship_fields = sanitize_custom_widgets(
            reduce(operator.__add__, bill_ship_fields)
            )

        self.widgets += form.setUpEditWidgets(
            bill_ship_fields,  self.prefix, self.context, self.request,
            adapters=adapters, for_display=True, ignore_request=ignore_request
            )
Пример #39
0
 def test_moveField(self):
     s = self.s
     s.addField(u'alpha', self.alpha)
     beta = Text(title=u'Beta')
     s.addField(u'beta', beta)
     gamma = Text(title=u'Gamma')
     s.addField(u'gamma', gamma)
     s.moveField(u'beta', 3)
     self.assertEquals(
         [u'alpha', u'gamma', u'beta'],
         getFieldNamesInOrder(s))
     s.moveField(u'beta', 2)
     self.assertEquals(
         [u'alpha', u'gamma', u'beta'],
         getFieldNamesInOrder(s))
     s.moveField(u'beta', 1)
     self.assertEquals(
         [u'alpha', u'beta', u'gamma'],
         getFieldNamesInOrder(s))
     s.moveField(u'beta', 0)
     self.assertEquals(
         [u'beta', u'alpha', u'gamma'],
         getFieldNamesInOrder(s))
Пример #40
0
    def attributes(self):
        context = removeSecurityProxy(self.context)
        attrs = [{'name': (ns and context.prefixes[ns]+':' or '') + name,
                  'value': value, 'url': None, 'values': []}
                 for (ns, name), value in context.attrs.items()]

        names = context.schema.names(True)
        rootURL = absoluteURL(findDocModule(self), self.request)
        for attr in attrs:
            name = (attr['name'] in names) and attr['name'] or attr['name']+'_'
            field = context.schema.get(name)

            if isinstance(field, (GlobalObject, GlobalInterface)):
                attr['url'] = self.objectURL(attr['value'], field, rootURL)

            elif isinstance(field, Tokens):
                field = field.value_type
                values = attr['value'].strip().split()
                if len(values) == 1:
                    attr['value'] = values[0]
                    attr['url'] = self.objectURL(values[0], field, rootURL)
                else:
                    for value in values:
                        if isinstance(field,
                                           (GlobalObject, GlobalInterface)):
                            url = self.objectURL(value, field, rootURL)
                        else:
                            break
                        attr['values'].append({'value': value, 'url': url})

        # Make sure that the attributes are in the same order they are defined
        # in the schema.
        fieldNames = getFieldNamesInOrder(context.schema)
        fieldNames = [name.endswith('_') and name[:-1] or name
                      for name in fieldNames]
        attrs.sort(lambda x, y: _compareAttrs(x, y, fieldNames))

        if not IRootDirective.providedBy(context):
            return attrs

        xmlns = []
        for uri, prefix in context.prefixes.items():
            name = prefix and ':'+prefix or ''
            xmlns.append({'name': 'xmlns'+name,
                          'value': uri,
                          'url': None,
                          'values': []})

        xmlns.sort(lambda x, y: cmp(x['name'], y['name']))
        return xmlns + attrs
Пример #41
0
    def test_syncSchema(self):

        class ISource(Interface):
            one = schema.TextLine(title=u"A") # order: 0
            two = schema.Int(title=u"B")      # order: 1

        class IDest(Interface):
            one = schema.TextLine(title=u"C") # order: 0
            three = schema.Int(title=u"D")    # order: 1

        ISource.setTaggedValue("tag1", "tag one")
        ISource.setTaggedValue("tag2", "tag two")
        IDest.setTaggedValue("tag1", "first tag")

        utils.syncSchema(ISource, IDest)

        self.assertEquals(u"C", IDest['one'].title)

        self.assertEquals(['one', 'two'], getFieldNamesInOrder(ISource))
        self.assertEquals(['two', 'one', 'three'], getFieldNamesInOrder(IDest))

        self.assertEquals("first tag", IDest.getTaggedValue("tag1"))
        self.assertEquals("tag two", IDest.getTaggedValue("tag2"))
Пример #42
0
def setUpColumns(domain_model):
    """Use model descriptor on domain model extract columns for table listings
    """
    columns = []
    table_schema = bungeni.alchemist.utils.get_derived_table_schema(
        domain_model)
    if not table_schema:
        raise SyntaxError(
            "Model must have domain interface %r" % (domain_model))
    descriptor_model = bungeni.alchemist.utils.get_descriptor(table_schema)

    field_column_names = \
        descriptor_model and descriptor_model.listing_columns \
        or schema.getFieldNamesInOrder(table_schema)

    # quick hack for now, dates are last in listings
    remainder = []

    for field_name in field_column_names:
        if not field_name in table_schema:
            # 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 (descriptor_model and field_name in descriptor_model
                    and descriptor_model[field_name].listing_column):
                pass
            else:
                #print "bad field, container", field_name, table_schema.__name__
                continue

        info = descriptor_model and descriptor_model.get(field_name) or None

        if info is not None and info.listing_column:
            columns.append(info.listing_column)
            continue

        field = table_schema[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
Пример #43
0
    def getContent(self):
        data = {'batch_list': []}
        names = getFieldNamesInOrder(self._list_schema)

        for obj in self.items:
            record = {}
            for name in names:
                record[name] = getattr(obj, name, None)
            record['uuid'] = obj.UID()
            record['review_state'] = translate(_(
                api.content.get_state(obj).title()),
                                               context=api.portal.getRequest())
            data['batch_list'].append(record)

        return data
Пример #44
0
 def _flex_form_hasdata(self, form):
     groups = self._datagroups(form)
     # form.data will not contain fieldset records on created but
     # otherwise unsaved form:
     _fieldsets = dict([(k, form.data.get(k)) for k in groups.keys()])
     # scenario 1: form exists, but no fieldset records (never entered):
     if not all(_fieldsets.values()):
         return False
     # scenario 2: form exists, but fieldset records may or may not be
     #             empty; if empty, return False -- otherwise True.
     return any(
         fieldset_nonempty(r,
                           groups.get(k).schema)
         for k, r in _fieldsets.items()
         if getFieldNamesInOrder(groups.get(k).schema))
Пример #45
0
 def _flex_form_hasdata(self, form):
     groups = self._datagroups(form)
     # form.data will not contain fieldset records on created but
     # otherwise unsaved form:
     _fieldsets = dict([(k, form.data.get(k)) for k in groups.keys()])
     # scenario 1: form exists, but no fieldset records (never entered):
     if not all(_fieldsets.values()):
         return False
     # scenario 2: form exists, but fieldset records may or may not be
     #             empty; if empty, return False -- otherwise True.
     return any(
         fieldset_nonempty(r, groups.get(k).schema)
         for k, r in _fieldsets.items()
         if getFieldNamesInOrder(groups.get(k).schema)
         )
    def _get_scss_variables(self, obj):
        schema = queryMultiAdapter((obj, obj.REQUEST),
                                   ICustomDesignVariablesSchema)
        if not schema:
            return

        annotations = IAnnotations(obj, None)
        if not annotations:
            return
        variables = annotations.get(VARIABLES_ANNOTATION_KEY) or {}

        form_fields = getFields(schema)
        for field_name in getFieldNamesInOrder(schema):
            yield (form_fields[field_name].variable_name,
                   variables.get(field_name))
    def _get_scss_variables(self, obj):
        schema = queryMultiAdapter((obj, obj.REQUEST),
                                   ICustomDesignVariablesSchema)
        if not schema:
            return

        annotations = IAnnotations(obj, None)
        if not annotations:
            return
        variables = annotations.get(VARIABLES_ANNOTATION_KEY) or {}

        form_fields = getFields(schema)
        for field_name in getFieldNamesInOrder(schema):
            yield (form_fields[field_name].variable_name,
                   variables.get(field_name))
Пример #48
0
def setUpColumns(domain_model):
    """Use model descriptor on domain model extract columns for table listings
    """
    columns = []
    table_schema = bungeni.alchemist.utils.get_derived_table_schema(
        domain_model)
    if not table_schema:
        raise SyntaxError("Model must have domain interface %r" %
                          (domain_model))
    descriptor_model = bungeni.alchemist.utils.get_descriptor(table_schema)

    field_column_names = \
        descriptor_model and descriptor_model.listing_columns \
        or schema.getFieldNamesInOrder(table_schema)

    # quick hack for now, dates are last in listings
    remainder = []

    for field_name in field_column_names:
        if not field_name in table_schema:
            # 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 (descriptor_model
                    and field_name in descriptor_model.fields_by_name
                    and descriptor_model.get(field_name).listing_column):
                pass
            else:
                print "bad field, container", field_name, table_schema.__name__
                continue

        info = descriptor_model and descriptor_model.get(field_name) or None

        if info is not None and info.listing_column:
            columns.append(info.listing_column)
            continue

        field = table_schema[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
Пример #49
0
    def test_syncSchema_overwrite_no_bases(self):
        class IBase(Interface):
            base = schema.TextLine(title=u"Base")

        class ISource(IBase):
            one = schema.TextLine(title=u"A")
            two = schema.Int(title=u"B")

        class IDest(Interface):
            one = schema.TextLine(title=u"C")
            three = schema.Int(title=u"D")

        utils.syncSchema(ISource, IDest, overwrite=False, sync_bases=False)

        self.assertEquals((Interface, ), IDest.__bases__)
        self.assertEquals(['two', 'one', 'three'], getFieldNamesInOrder(IDest))
Пример #50
0
    def __init__(self, context, request, factory, **kw):
        super(ObjectWidget, self).__init__(context, request)

        # define view that renders the widget
        self.view = ObjectWidgetView(self, request)

        # factory used to create content that this widget (field)
        # represents
        self.factory = factory

        # handle foo_widget specs being passed in
        self.names = getFieldNamesInOrder(self.context.schema)
        for k, v in kw.items():
            if k.endswith('_widget'):
                setattr(self, k, v)

        # set up my subwidgets
        self._setUpEditWidgets()
Пример #51
0
    def test_syncSchema_overwrite_with_bases(self):
        class IBase(Interface):
            base = schema.TextLine(title=u"Base")

        class IOtherBase(Interface):
            foo = schema.TextLine(title=u"Foo")

        class ISource(IBase):
            one = schema.TextLine(title=u"A")
            two = schema.Int(title=u"B")

        class IDest(IOtherBase):
            one = schema.TextLine(title=u"C")
            three = schema.Int(title=u"D")

        utils.syncSchema(ISource, IDest, overwrite=True, sync_bases=True)

        self.assertEqual((IBase, ), IDest.__bases__)
        self.assertEqual(['base', 'one', 'two'], getFieldNamesInOrder(IDest))
Пример #52
0
 def update(self, data):
     """
     Update from JSON data or equivalent dict.
     """
     if isinstance(data, basestring):
         data = json.loads(data)
     queries = []
     fieldnames = getFieldNamesInOrder(self.schema)
     for query_row in data.get('rows', []):
         fieldname = query_row.get('fieldname')
         if fieldname not in fieldnames:
             continue  # ignore possibly removed fields
         field = self.schema[fieldname]
         comparator = query_row.get('comparator')
         value = self.normalize_value(
             field,
             query_row.get('value'),
         )
         queries.append(FieldQuery(fieldname, comparator, value))
     self.context.reset()  # clear queries
     self.context.operator = data.get('operator', 'AND')
     r = map(self.context.add, queries)  # add all  # noqa
    def __iter__(self):
        key = self.options.get('key')
        for item in self.previous:
            if self.condition(item):
                if '_object' in item and key:
                    item[key] = marshall(item['_object'])

                # For Topics, also marshall required fields for collections
                if item['_type'] == 'Topic':
                    ob = item['_object']
                    message = marshall_topic_as_collection(ob)
                    for name in getFieldNamesInOrder(IMockCollection):
                        item[key][name] = message[name]

                    # Because sub-collections are not supported, re-create
                    # the main topic as separate collection...
                    if has_subtopics(ob):
                        id_ = item['_path'].split('/')[-1]
                        while id_ in ob.objectIds():
                            id_ += '-{0:s}'.format(id_)
                        item['_path'] += '/{0:s}'.format(id_)

            yield item
    def __iter__(self):
        context = self.transmogrifier.context
        key = self.options.get('key')
        for item in self.previous:
            if item.get('_type') == 'Topic':
                obj = resolve_object(context, item)
                item[key] = marshall(obj)

                # For Topics, also marshall required fields for collections
                obj = item['_object']
                message = marshall_topic_as_collection(obj)
                for name in getFieldNamesInOrder(IMockCollection):
                    item[key][name] = message[name]

                # Because sub-collections are not supported, re-create
                # the main topic as separate collection...
                if has_subtopics(obj):
                    id_ = item['_path'].split('/')[-1]
                    while id_ in obj.objectIds():
                        id_ += '-{0:s}'.format(id_)
                    item['_path'] += '/{0:s}'.format(id_)

            yield item
    def testSA2ZS(self):

        metadata = rdb.DynamicMetaData("principals")

        users = rdb.Table(
            'users', metadata,
            rdb.Column('user_id',
                       rdb.Integer,
                       rdb.Sequence('user_id_seq', optional=True),
                       primary_key=True),
            rdb.Column('user_name', rdb.String(40), default=u'hello world'))

        iusers = transmute(users)
        self.assertEqual(tuple(schema.getFieldNamesInOrder(iusers)),
                         ('user_id', 'user_name'))

        fields = dict(schema.getFieldsInOrder(iusers))
        # assert types and constraints
        self.assertTrue(isinstance(fields['user_id'], schema.Int))
        self.assertTrue(fields['user_id'].required)
        self.assertTrue(isinstance(fields['user_name'], schema.TextLine))
        self.assertEqual(fields['user_name'].max_length, 40)
        self.assertEqual(fields['user_name'].default, u'hello world')
Пример #56
0
class ProjectSnapshot(object):

    implements(IProjectSnapshot)

    NAMES = schema.getFieldNamesInOrder(IProjectSnapshot)

    def __init__(self, **kwargs):

        # initially empty sets for users, can be intersected later
        self.all_users = set()
        self.other_users = set()
        self.managers = set()
        self.form_users = set()
        for k, v in kwargs.items():
            if k in self.NAMES:
                IProjectSnapshot[k].validate(v)
                setattr(self, k, v)

    def __setattr__(self, name, value):
        """Validating setattr for any schema fields"""
        if name in self.NAMES:
            IProjectSnapshot[name].validate(value)
        self.__dict__[name] = value
Пример #57
0
class EditView(BrowserView):
    """Simple edit-view base class

    Subclasses should provide a `schema` attribute defining the schema
    to be edited.

    The automatically generated widgets are available by name through
    the attributes `*_widget`.
    (E.g. ``view.title_widget for the title widget``)
    """

    errors = ()
    update_status = None
    label = ''

    # Fall-back field names computes from schema
    fieldNames = property(lambda self: getFieldNamesInOrder(self.schema))
    # Fall-back template
    generated_form = ViewPageTemplateFile('edit.pt')

    def __init__(self, context, request):
        super(EditView, self).__init__(context, request)
        self._setUpWidgets()

    def _setUpWidgets(self):
        self.adapted = self.schema(self.context)
        setUpEditWidgets(self,
                         self.schema,
                         source=self.adapted,
                         names=self.fieldNames)

    def setPrefix(self, prefix):
        for widget in self.widgets():
            widget.setPrefix(prefix)

    def widgets(self):
        return [getattr(self, name + '_widget') for name in self.fieldNames]

    def changed(self):
        # This method is overridden to execute logic *after* changes
        # have been made.
        pass

    def update(self):
        if self.update_status is not None:
            # We've been called before. Just return the status we previously
            # computed.
            return self.update_status

        status = ''

        content = self.adapted

        if Update in self.request:
            changed = False
            try:
                changed = applyWidgetsChanges(self,
                                              self.schema,
                                              target=content,
                                              names=self.fieldNames)
                # We should not generate events when an adapter is used.
                # That's the adapter's job.
                if changed and self.context is self.adapted:
                    description = Attributes(self.schema, *self.fieldNames)
                    notify(ObjectModifiedEvent(content, description))
            except WidgetsError, errors:
                self.errors = errors
                status = _("An error occurred.")
                transaction.doom()
            else:
                setUpEditWidgets(self,
                                 self.schema,
                                 source=self.adapted,
                                 ignoreStickyValues=True,
                                 names=self.fieldNames)
                if changed:
                    self.changed()
                    formatter = self.request.locale.dates.getFormatter(
                        'dateTime', 'medium')
                    status = _("Updated on ${date_time}",
                               mapping={
                                   'date_time':
                                   formatter.format(datetime.utcnow())
                               })

        self.update_status = status
        return status