def handleSave(self, action):
        data, errors = self.extractData()

        if errors:
            return False

        types = api.portal.get_tool('portal_types')
        type_info = types.getTypeInfo('eea.meeting.email')

        name_chooser = INameChooser(self.context)
        content_id = name_chooser.chooseName(data['subject'], self.context)

        obj = type_info._constructInstance(self.context, content_id)

        obj.title = data['subject']
        obj.sender = data['sender']
        obj.receiver = data['receiver']
        obj.cc = data['cc']
        obj.subject = data['subject']
        obj.body = data['body']

        obj.reindexObject()

        notify(SendEmailAddEvent(self.context, data))

        msg = _(u"Email successfully sent")
        IStatusMessage(self.request).addStatusMessage(msg, type='info')
        self.request.response.redirect(
            self.context.getParentNode().absolute_url())

    def choose_name(self):
        if self._id is not None:
            return self._id

        title = self.arguments.get('title', self.portal_type)
        chooser = INameChooser(self.container)
        return chooser.chooseName(title, self.container)

def _createObj(context, event):
    parent = context.aq_parent
    column = getUtility(IPortletManager, name=u'plone.leftcolumn', context=context)
    manager = getMultiAdapter((context, column,), IPortletAssignmentMapping)
    assignment = burgermenuportlet.Assignment()
    chooser = INameChooser(manager)
    assignment.path = '/'.join(context.getPhysicalPath())
    manager[chooser.chooseName(None, assignment)] = assignment

    id = context.getId()
    object_Ids = []
    catalog = getToolByName(context, 'portal_catalog')
    brains = catalog.unrestrictedSearchResults(object_provides = IPilgrimageApp.__identifier__)
    for brain in brains:
        object_Ids.append(brain.id)
    
    last_name = str(idnormalizer.normalize(context.title))
    temp_new_id = last_name
    new_id = temp_new_id.replace("-","")
    test = ''
    if new_id in object_Ids:
        test = filter(lambda name: new_id in name, object_Ids)
        if '-' not in (max(test)):
            new_id = new_id + '-1'
        if '-' in (max(test)):
            new_id = new_id +'-' +str(int(max(test).split('-')[-1])+1) 

    parent.manage_renameObject(id, new_id )
    new_title = last_name
    context.setTitle(context.title)


    context.reindexObject()
    return

def copy(source=None, target=None, id=None, safe_id=False):
    """Copy the object to the target container.

    :param source: [required] Object that we want to copy.
    :type source: Content object
    :param target: Target container to which the source object will
        be moved. If no target is specified, the source object's container will
        be used as a target.
    :type target: Folderish content object
    :param id: Id of the copied object on the target location. If no id is
        provided, the copied object will have the same id as the source object
        - however, if the new object's id conflicts with another object in the
        target container, a suffix will be added to the new object's id.
    :type id: string
    :returns: Content object that was created in the target location
    :param safe_id: When True, the given id will be enforced. If the id is
        conflicting with another object in the target container, raise a
        InvalidParameterError. When True, choose a new, non-conflicting id.
    :type safe_id: boolean
    :raises:
        KeyError,
        ValueError
    :Example: :ref:`content_copy_example`
    """
    source_id = source.getId()
    target.manage_pasteObjects(source.manage_copyObjects(source_id))

    if id:
        if not safe_id:
            new_id = id
        else:
            chooser = INameChooser(target)
            new_id = chooser.chooseName(id, source)

        target.manage_renameObject(source_id, new_id)

    def __call__(self, filename, title, description, content_type, data,
                 portal_type):
        context = aq_inner(self.context)
        error = ''
        result = {}
        result['success'] = None
        newid = get_id_from_filename(filename, context)
        chooser = INameChooser(context)
        newid = chooser.chooseName(newid, context)
        # consolidation because it's different upon Plone versions
        if not title:
            # try to split filenames because we don't want
            # big titles without spaces
            title = filename.rsplit('.', 1)[0]\
                .replace('_', ' ')\
                .replace('-', ' ')

        if newid in context:
            # only here for flashupload method since a check_id is done
            # in standard uploader - see also XXX in quick_upload.py
            raise NameError, 'Object id %s already exists' % newid
        else:
            upload_lock.acquire()
            try:
                transaction.begin()
                try:
                    from zope.publisher.browser import TestRequest
                    request = TestRequest()
                    dataobj = FileObj(data)
                    dataobj.filename = filename
                    request.form['doc'] = dataobj
                    request.form['ajax'] = '1'
                    from fhnw.office2plone.browser.docx_importer import DocxImporter
                    docximport = DocxImporter(self.context, request)
                    docximport.docx_import()
                except ImportError:
                    error = ''
                except Unauthorized:
                    error = u'serverErrorNoPermission'
                except ConflictError:
                    # rare with xhr upload / happens sometimes with flashupload
                    error = u'serverErrorZODBConflict'
                except ValueError:
                    error = u'serverErrorDisallowedType'
                except Exception, e:
                    error = u'serverError'
                    logger.exception(e)

                if error:
                    if error == u'serverError':
                        logger.info(
                            "An error happens with setId from filename, "
                            "the file has been created with a bad id, "
                            "can't find %s", newid)
                else:
                    pass

                #@TODO : rollback if there has been an error
                transaction.commit()
            finally:

    def drop(self, mail):
        """ drop a mail into this mail box. The mail is
        a string with the complete email content """
        
        # code unicode to utf-8
        if isinstance(mail,unicode):
            mail = mail.encode( 'utf-8' )
        type = 'Email'
        format = 'text/plain'
        content_type='text/plain'

        #generate title
        mailobj = email.message_from_string(mail)
        # Subject
        for key in "Subject subject Betreff betreff".split():
            subject = mailobj.get(key)
            if subject:
                subject = self.decodeheader(subject)
                break

        id = subject or DEFAULT_ID
        title = id

        # generate id
        normalizer = component.getUtility(IIDNormalizer)
        chooser = INameChooser(self.context)
        id = chooser.chooseName(normalizer.normalize(id), aq_base(self.context))

        self.context.invokeFactory(type ,id=id , title=title, format=format, \
                                   content_type=content_type, file=mail)
        getattr(self.context, id, None).setContentType(content_type)
        getattr(self.context, id, None).processForm()
        notify(MailDroppedEvent(getattr(self.context, id, None), self.context))

    def handleApply(self, action):
        data, errors = self.extractData()
        if errors:
            return
        
        title = data['title']
        
        # Generate a name based on the title..
        util = queryUtility(IIDNormalizer)
        id = util.normalize(title)
        
        # Context may not be a container, get one.
        context_state = getMultiAdapter((self.context, self.request), name="plone_context_state")
        container = context_state.folder()
        
        # Make sure our chosen id is unique, iterate until we get one that is.
        chooser = INameChooser(container)
        id = chooser._findUniqueName(id, None)

        # create the object
        type_name = data['type_name']
        container.invokeFactory(type_name, id=id, title=title)
        if type_name in [u'Folder']:
            self.request.response.redirect("%s/@@cmsui-structure" % container[id].absolute_url())
        else:
            self.request.response.redirect("%s/edit" % container[id].absolute_url())

    def __call__(self, name, content_type, data):
        ctr = getToolByName(self.context, 'content_type_registry')
        type_ = ctr.findTypeName(name.lower(), '', '') or 'File'

        # XXX: quick fix for german umlauts
        name = name.decode("utf8")

        normalizer = getUtility(IFileNameNormalizer)
        chooser = INameChooser(self.context)

        # otherwise I get ZPublisher.Conflict ConflictErrors
        # when uploading multiple files
        upload_lock.acquire()

        # this should fix #8
        newid = chooser.chooseName(normalizer.normalize(name),
                                   self.context.aq_parent)
        try:
            transaction.begin()
            obj = ploneutils._createObjectByType(type_,
                                                 self.context, newid)
            mutator = obj.getPrimaryField().getMutator(obj)
            mutator(data, content_type=content_type)
            obj.setTitle(name)
            obj.reindexObject()

            notify(ObjectInitializedEvent(obj))
            notify(ObjectModifiedEvent(obj))

            transaction.commit()
        finally:
            upload_lock.release()
        return obj

 def createNewDaviz(self):
     """ Create new visualization
     """
     davizsettings = queryUtility(IDavizSettings)
     strFolder = davizsettings.settings.get("daviz.defaultfolder", "")
     if strFolder != "":
         portal = getSite()
         folder = portal.restrictedTraverse(strFolder)
     else:
         folder = self.context.aq_parent
         found = False
         while True:
             try:
                 allowedContentTypes = folder.allowedContentTypes()
             except AttributeError:
                 break
             for allowedContentType in allowedContentTypes:
                 if allowedContentType.id == "DavizVisualization":
                     found = True
             if found:
                 break
             folder = folder.aq_parent
         if not found:
             return
     chooser = INameChooser(folder)
     newId = chooser.chooseName(self.context.title, folder)
     if newId in folder.objectIds():
         raise NameError, 'Object id %s already exists' % newId
     else:
         folder.invokeFactory("DavizVisualization", newId)
     newObj = folder[newId]
     newObj.title = self.context.title
     newObj.setRelatedItems([self.context])
     self.request.response.redirect(newObj.absolute_url()+"/daviz-edit.html")

def setup_department_portlets(obj, event):

    # equaldepartments-portlet
    manager = getUtility(IPortletManager, name=u"plone.leftcolumn")
    mapping = getMultiAdapter((obj, manager), IPortletAssignmentMapping)

    has_equaldepartments = False
    for value in mapping.values():
        if value.__name__ == "label_equaldepartmentsportlet":
            has_equaldepartments = True

    if not has_equaldepartments:
        assignment_equaldepartments = equaldepartmentsportlet.EqualDepartmentsPortletAssignment(
            department_uid=obj.UID()
        )
        chooser = INameChooser(mapping)
        equaldepartments_name = chooser.chooseName(None, assignment_equaldepartments)
        mapping[equaldepartments_name] = assignment_equaldepartments

    # departmentportlet
    manager = getUtility(IPortletManager, name=u"plone.rightcolumn")
    mapping = getMultiAdapter((obj, manager), IPortletAssignmentMapping)

    has_department = False
    for value in mapping.values():
        if value.__name__ == "label_departmentportlet":
            has_department = True
    if not has_department:
        assignment_department = departmentportlet.DepartmentPortletAssignment(department_uid=obj.UID())
        chooser = INameChooser(mapping)
        department_name = chooser.chooseName(None, assignment_department)
        mapping[department_name] = assignment_department

def new_user(principal, event):
    """Initialise the dashboard for a new user
    """
    defaults = IDefaultDashboard(principal, None)
    if defaults is None:
        return

    userid = principal.getId()
    portlets = defaults()

    for name in ('plone.dashboard1', 'plone.dashboard2', 'plone.dashboard3', 'plone.dashboard4'):
        assignments = portlets.get(name)
        if assignments:
            column = queryUtility(IPortletManager, name=name)
            if column is not None:
                category = column.get(USER_CATEGORY, None)
                if category is not None:
                    manager = category.get(userid, None)
                    if manager is None:
                        manager = category[userid] = UserPortletAssignmentMapping(manager=name,
                                                                                  category=USER_CATEGORY,
                                                                                  name=userid)
                    chooser = INameChooser(manager)
                    for assignment in assignments:
                        manager[chooser.chooseName(None, assignment)] = assignment

    def _create_file(self, item, files, title, description, rights):
        namechooser = INameChooser(self.context)
        content_type = item.headers.get('Content-Type')
        filename = safe_unicode(item.filename)
        data = item.read()
        id_name = ''
        title = title and title[0] or filename
        id_name = namechooser.chooseName(title, self.context)

        if content_type in IMAGE_MIMETYPES:
            portal_type = 'Image'
            wrapped_data = NamedBlobImage(data=data, filename=filename)
        else:
            portal_type = 'File'
            wrapped_data = NamedBlobFile(data=data, filename=filename)

        self.context.invokeFactory(portal_type,
                                   id=id_name,
                                   title=title,
                                   description=description[0],
                                   rights=rights[0])
        newfile = self.context[id_name]
        if portal_type == 'File':
            if IATFile.providedBy(newfile):
                newfile.setFile(data, filename=filename)
            else:
                newfile.file = wrapped_data
        elif portal_type == 'Image':
            if IATImage.providedBy(newfile):
                newfile.setImage(data, filename=filename)
            else:
                newfile.image = wrapped_data
        newfile.reindexObject()
        notify(ObjectModifiedEvent(newfile))
        return newfile

    def __call__(self, name, content_type, data):
        ctr = getToolByName(self.context, 'content_type_registry')
        type_ = ctr.findTypeName(name.lower(), '', '') or 'File'

        # otherwise I get ZPublisher.Conflict ConflictErrors
        # when uploading multiple files
        upload_lock.acquire()

        name = safe_unicode(name)
        chooser = INameChooser(self.context)
        newid = chooser.chooseName(name, self.context.aq_parent)
        try:
            transaction.begin()
            obj = ploneutils._createObjectByType(type_,
                                                 self.context, newid)
            mutator = obj.getPrimaryField().getMutator(obj)
            mutator(data, content_type=content_type, filename=name)
            obj.setTitle(name)
            if hasattr(obj, 'setFilename'):
                # if chunk uploaded, needs override
                obj.setFilename(name)
            obj.reindexObject()

            notify(ObjectInitializedEvent(obj))
            notify(ObjectModifiedEvent(obj))

            transaction.commit()
        finally:
            upload_lock.release()
        return obj

def _create_project(cell, context):
    STATUS = {'17': 'active', '18': 'inactive', '19': 'archive'}
    chooser = INameChooser(context)
    project_id = chooser.chooseName(cell[2].decode('latin-1'), context)

    # Create project
    context.invokeFactory("Project", project_id)
    project = context[project_id]
    project.setExcludeFromNav(True)

    # Set project attributes
    project.setCode(cell[2].decode('latin-1'))
    project.setName_fr(cell[16].decode('latin-1'))
    project.setName_en(cell[4].decode('latin-1'))
    project.setName_nl(cell[3].decode('latin-1'))
    project.setContent_fr(cell[13].decode('latin-1'))
    project.setContent_en(cell[20].decode('latin-1'))
    project.setContent_nl(cell[7].decode('latin-1'))
    project.setComments(cell[11].decode('latin-1'))
    project.setUrl(cell[6].decode('latin-1'))
    project.setOrganisationtype(cell[5].decode('latin-1'))
    project.setStatus(STATUS.get(cell[18].decode('latin-1'), ''))
    project.setRelationtype(cell[19].decode('latin-1'))
    project.setStart(_get_datetime(cell[10].decode('latin-1')))
    project.setEnd(_get_datetime(cell[15].decode('latin-1')))

    return project

    def moveTo(self, target, new_name=None):
        """Move this object to the `target` given.

        Returns the new name within the `target`
        """

        obj = self.context
        container = obj.__parent__

        orig_name = obj.__name__
        if new_name is None:
            new_name = orig_name

        checkObject(target, new_name, obj)

        if target is container and new_name == orig_name:
            # Nothing to do
            return

        chooser = INameChooser(target)
        new_name = chooser.chooseName(new_name, obj)

        if target is container and new_name == orig_name:
            # obstinate namechooser
            return

        target[new_name] = obj
        del container[orig_name]
        return new_name

 def add(self, schoolyear):
     """Add `schoolyear` to the container."""
     chooser = INameChooser(self.context)
     name = chooser.chooseName(schoolyear.title, schoolyear)
     self.context[name] = schoolyear
     self.importData(schoolyear)
     return schoolyear

def addUtility(root_folder, utility_type, utility_factory,
               asObject=_marker, **kw):
    """ Add a Utility to the root folder's site manager.

    The utility is added to the default package and activated.
    """
    if asObject is not _marker:
        warnings.warn("asObject argument is deprecated and will be "
                      "removed in Zope 3.6", DeprecationWarning, 2)

    package = getSiteManagerDefault(root_folder)
    chooser = INameChooser(package)
    utility = utility_factory()
    name = chooser.chooseName(utility_type, utility)
    package[name] = utility

    # the utility might have been location-proxied; we need the name
    # information (__name__) so let's get it back again from the
    # container
    utility = package[name]

    # Set additional attributes on the utility
    for k, v in kw.iteritems():
        setattr(utility, k, v)
    return utility

def new_user(principal, event):
    """Initialise the dashboard for a new user
    """

    #import pdb; pdb.set_trace()
    defaults = IDefaultPersonalPortlet(principal, None)
    if defaults is None:
        return

    userid = principal.getId()
    portlets = defaults()

 
    for name in ('plone.rightcolumn', ):
        assignments = portlets.get(name)
        if assignments:
            column = queryUtility(IPortletManager, name=name)
            if column is not None:
                # Add the default portlets only, if this is our manager.
                # We must check this to avoid adding the default portlets 
                # when the product is not installed into the portal
                # (but the event triggers even in this case)
                if IPersonalPortletManager in providedBy(column):
                    category = column.get(USER_CATEGORY, None)
                    if category is not None:
                        manager = category.get(userid, None)
                        if manager is None:
                            manager = category[userid] = UserPortletAssignmentMapping(manager=name,
                                                                                      category=USER_CATEGORY,
                                                                                      name=userid)
                        chooser = INameChooser(manager)
                        for assignment in assignments:
                            manager[chooser.chooseName(None, assignment)] = assignment

def _createObject(context, event):
    column = getUtility(IPortletManager, name=u'plone.leftcolumn', context=context)
    manager = getMultiAdapter((context, column,), IPortletAssignmentMapping)
    assignment = mydocs_portlet.Assignment()
    chooser = INameChooser(manager)
    assignment.button_label = 'My Documents'
    manager[chooser.chooseName(None, assignment)] = assignment

    def add(self, content):
        """See zope.browser.interfaces.IAdding
        """
        container = self.context
        name = self.contentName
        chooser = INameChooser(container)

        # check precondition
        checkObject(container, name, content)

        if IContainerNamesContainer.providedBy(container):
            # The container picks its own names.
            # We need to ask it to pick one.
            name = chooser.chooseName(self.contentName or '', content)
        else:
            request = self.request
            name = request.get('add_input_name', name)

            if name is None:
                name = chooser.chooseName(self.contentName or '', content)
            elif name == '':
                name = chooser.chooseName('', content)
            else:
                # Invoke the name chooser even when we have a
                # name. It'll do useful things with it like converting
                # the incoming unicode to an ASCII string.
                name = chooser.chooseName(name, content)

        content.id = name
        container._setObject(name, content)
        self.contentName = name  # Set the added object Name
        return container._getOb(name)