Example #1
0
    def test_silva_name_chooser(self):
        """Test name chooser implementation for Silva contents.

        checkName should raise ContentErrror for invalid ids, return
        True for valid ones.
        """
        chooser = ISilvaNameChooser(self.root)
        self.assertTrue(verifyObject(ISilvaNameChooser, chooser))

        # simple case
        self.assertTrue(chooser.checkName('valid_id', None))
        # index is valid by default
        self.assertTrue(chooser.checkName('index', None))
        with self.assertRaises(ContentError):
            chooser.checkName('service_check', None)
        with self.assertRaises(ContentError):
            chooser.checkName('override.html', None)
        with self.assertRaises(ContentError):
            chooser.checkName('aq_parent', None)
        with self.assertRaises(ContentError):
            chooser.checkName('document__', None)
        with self.assertRaises(ContentError):
            chooser.checkName('__document', None)
        with self.assertRaises(ContentError):
            # index is not valid for folders
            chooser.checkName('index', None, interface=IFolder)
        with self.assertRaises(ContentError):
            # index is not valid for assets
            chooser.checkName('index', None, interface=IAsset)
Example #2
0
def manage_addImage(context, identifier, title=None, file=None):
    """Add an Image.
    """
    if file is not None:
        validate_image(file)

    filename = None
    if hasattr(file, 'name'):
        filename = os.path.basename(file.name)

    container = context
    if ISilvaFactoryDispatcher.providedBy(container):
        container = container.Destination()

    name_chooser = ISilvaNameChooser(container)
    identifier = name_chooser.chooseName(identifier or filename,
                                         None,
                                         file=file,
                                         interface=interfaces.IAsset)
    try:
        name_chooser.checkName(identifier, None)
    except ContentError as e:
        raise ValueError(
            _(u"Please provide a unique id: ${reason}",
              mapping=dict(reason=e.reason)))
    context._setObject(identifier, Image(identifier))
    content = context._getOb(identifier)
    if title is not None:
        content.set_title(title)
    if file is not None:
        content.set_image(file)
    notify(ObjectCreatedEvent(content))
    return content
 def _generate_id(self, string):
     """ This produces a chopped string id from a title, or
         text, or else uses unknown. For dublicates the
         method adds 1.
     """
     string = string.strip()
     if len(string) > 20:
         string = string[:20]
     chooser = ISilvaNameChooser(self)
     id = chooser.chooseName(string, None)
     # regex the cooked id and strip invalid characters
     # replace multiple underscores with single underscores
     # if no string use 'unknown'
     id = self.reg_start_under.sub(
         '', self.reg_under.sub('_', self.reg_nonword.sub('_', id)))
     if not id:
         id = 'unknown'
     if id in self.objectIds():
         highest = 1
         regex = re.compile('^%s_(\d+)$' % re.escape(id))
         for other_id in self.objectIds():
             match = regex.search(other_id)
             if match:
                 new_int = int(match.group(1))
                 if new_int > highest:
                     highest = new_int
         highest += 1
         id = '%s_%s' % (id, highest)
     return id
Example #4
0
    def renamer(self):
        any_renames = False

        data = yield
        while data is not None:
            content, to_identifier, to_title = data
            result = None

            # Rename identifier
            from_identifier = content.getId()
            if to_identifier is not None and from_identifier != to_identifier:
                result = self.__verify_moveable(content)
                if result is None:
                    try:
                        ISilvaNameChooser(self.context).checkName(
                            to_identifier, content)
                    except ContentError as e:
                        result = ContainerError(reason=e.reason,
                                                content=content)
                if result is None:
                    content = self.__move(content, self.context,
                                          from_identifier, to_identifier)
                    any_renames = True

            # Update title
            if to_title is not None:
                if not isinstance(to_title, str):
                    to_title = to_title.decode('utf-8')
                editable = content.get_editable()
                if editable is None:
                    if result is None:
                        result = ContentError(
                            _("There is no editable version to set the title on."
                              ), content)
                elif editable.get_title() != to_title:
                    try:
                        editable.set_title(to_title)
                    except ContentError as error:
                        result = error

            if result is None:
                result = content

            data = yield result

        if any_renames:
            notifyContainerModified(self.context)
Example #5
0
def image_factory(self, id, content_type, file):
    """Create an Image.
    """
    filename = None
    if hasattr(file, 'name'):
        filename = os.path.basename(file.name)
    name_chooser = ISilvaNameChooser(self)
    id = name_chooser.chooseName(id or filename,
                                 None,
                                 file=file,
                                 interface=interfaces.IAsset)
    try:
        name_chooser.checkName(id, None)
    except ContentError:
        return None

    img = Image(str(id)).__of__(self)
    return img
Example #6
0
    def test_zope_name_chooser(self):
        """Test name chooser implementation for Zope contents. This is
        used when adding a Silva root.

        checkName should ContentError for invalids ids, return True
        for valid ones.
        """
        factory = self.root.manage_addProduct['OFS']
        factory.manage_addFolder('folder', 'Folder')

        chooser = ISilvaNameChooser(self.root.folder)
        self.assertTrue(verifyObject(ISilvaNameChooser, chooser))

        # checkName. services are valid inside a Zope folder
        self.assertTrue(chooser.checkName('valid_id', None))
        self.assertTrue(chooser.checkName('service_check', None))
        self.assertTrue(chooser.checkName('override.html', None))
        with self.assertRaises(ContentError):
            chooser.checkName('aq_parent', None)
        with self.assertRaises(ContentError):
            chooser.checkName('document__', None)
        with self.assertRaises(ContentError):
            chooser.checkName('__document', None)