def prepareContents(self, registry, register_subdirs=0):
     # Creates objects for each file.
     fp = expandpath(self.filepath)
     data = {}
     l = listdir(fp)
     types = self._readTypesFile()
     for entry in l:
         if not self._isAllowableFilename(entry):
             continue
         e_filepath = path.join(self.filepath, entry)
         e_fp = expandpath(e_filepath)
         if path.isdir(e_fp):
             # Add a subdirectory only if it was previously registered,
             # unless register_subdirs is set.
             info = registry.getDirectoryInfo(e_filepath)
             if info is None and register_subdirs:
                 # Register unknown subdirs
                 if entry not in ('CVS', 'SVN', '.', '..'):
                     registry.registerDirectoryByPath(e_fp)
                     info = registry.getDirectoryInfo(e_filepath)
             if info is not None:
                 mt = types.get(entry)
                 t = None
                 if mt is not None:
                     t = registry.getTypeByMetaType(mt)
                 if t is None:
                     t = DirectoryView
                 ob = t(entry, e_filepath)
                 data[ob.getId()] = ob
         else:
             pos = rfind(entry, '.')
             if pos >= 0:
                 name = entry[:pos]
                 ext = normalize(entry[pos + 1:])
             else:
                 name = entry
                 ext = ''
             if not name or bad_id(entry) != -1 or name == 'REQUEST':
                 # Not an allowable id.
                 continue
             t = None
             mt = types.get(entry, None)
             if mt is None:
                 mt = types.get(name, None)
             if mt is not None:
                 t = registry.getTypeByMetaType(mt)
             if t is None:
                 t = registry.getTypeByExtension(ext)
             if t is not None:
                 ob = t(name, e_filepath, fullname=entry)
                 data[ob.getId()] = ob
     return data

 def _checkId(self, id):
     """See if an id is valid CMF/Plone id"""
     portal = getToolByName(self, 'portal_url').getPortalObject()
     if not id:
         return 'Empty id'
     s = bad_id(id)
     if s:
         return '\'%s\' is not a valid id' % (id)
     # extra checks for Plone sites
     if portal.__class__.__name__ == 'PloneSite':
         if hasattr(portal, 'portal_properties') and \
             hasattr(portal.portal_properties, 'site_properties') and \
             hasattr(portal.portal_properties.site_properties, 'invalid_ids'):
             if id in portal.portal_properties.site_properties.invalid_ids:
                 return '\'%s\' is a reserved id' % (id)

 def good_id(self, id):
     # Exposes ObjectManager's bad_id test to skin scripts.
     m = bad_id(id)
     if m is not None:
         return 0
     return 1

    def prepareContents(self, registry, register_subdirs=0):
        # Creates objects for each file.
        data = {}
        objects = []
        types = self._readTypesFile()
        for entry in _filtered_listdir(self._filepath, ignore=self.ignore):
            if not self._isAllowableFilename(entry):
                continue
            entry_filepath = path.join(self._filepath, entry)
            if path.isdir(entry_filepath):
                # Add a subdirectory only if it was previously registered,
                # unless register_subdirs is set.
                entry_minimal_fp = '/'.join( (self._minimal_fp, entry) )
                info = registry.getDirectoryInfo(entry_minimal_fp)
                if info is None and register_subdirs:
                    # Register unknown subdirs
                    registry.registerDirectoryByPath(entry_filepath)
                    info = registry.getDirectoryInfo(entry_minimal_fp)
                if info is not None:
                    # Folders on the file system have no extension or
                    # meta_type, as a crutch to enable customizing what gets
                    # created to represent a filesystem folder in a
                    # DirectoryView we use a fake type "FOLDER". That way
                    # other implementations can register for that type and
                    # circumvent the hardcoded assumption that all filesystem
                    # directories will turn into DirectoryViews.
                    mt = types.get(entry) or 'FOLDER'
                    t = registry.getTypeByMetaType(mt)
                    if t is None:
                        t = DirectoryView
                    metadata = FSMetadata(entry_filepath)
                    metadata.read()
                    ob = t( entry
                          , entry_minimal_fp
                          , properties=metadata.getProperties()
                          )
                    ob_id = ob.getId()
                    data[ob_id] = ob
                    objects.append({'id': ob_id, 'meta_type': ob.meta_type})
            else:
                pos = entry.rfind('.')
                if pos >= 0:
                    name = entry[:pos]
                    ext = path.normcase(entry[pos + 1:])
                else:
                    name = entry
                    ext = ''
                if not name or name == 'REQUEST':
                    # Not an allowable id.
                    continue
                mo = bad_id(name)
                if mo is not None and mo != -1:  # Both re and regex formats
                    # Not an allowable id.
                    continue
                t = None
                mt = types.get(entry, None)
                if mt is None:
                    mt = types.get(name, None)
                if mt is not None:
                    t = registry.getTypeByMetaType(mt)
                if t is None:
                    t = registry.getTypeByExtension(ext)

                if t is not None:
                    metadata = FSMetadata(entry_filepath)
                    metadata.read()
                    try:
                        ob = t(name, entry_filepath, fullname=entry,
                               properties=metadata.getProperties())
                    except:
                        import sys
                        import traceback
                        typ, val, tb = sys.exc_info()
                        try:
                            logger.exception("prepareContents")

                            exc_lines = traceback.format_exception( typ,
                                                                    val,
                                                                    tb )
                            ob = BadFile( name,
                                          entry_filepath,
                                          exc_str='\r\n'.join(exc_lines),
                                          fullname=entry )
                        finally:
                            tb = None   # Avoid leaking frame!

                    # FS-based security
                    permissions = metadata.getSecurity()
                    if permissions is not None:
                        for name in permissions.keys():
                            acquire, roles = permissions[name]
                            try:
                                ob.manage_permission(name,roles,acquire)
                            except ValueError:
                                logger.exception("Error setting permissions")

                    # only DTML Methods and Python Scripts can have proxy roles
                    if hasattr(ob, '_proxy_roles'):
                        try:
                            ob._proxy_roles = tuple(metadata.getProxyRoles())
#.........这里部分代码省略.........

def checkId(id):
    res = bad_id(id)
    if res != -1 and res is not None:
        raise ValueError, 'Illegal ID'
    return 1

    def prepareContents(self, registry, register_subdirs=0):
        # Creates objects for each file.
        fp = expandpath(self.filepath)
        data = {}
        objects = []
        types = self._readTypesFile()
        for entry in _filtered_listdir(fp):
            if not self._isAllowableFilename(entry):
                continue
            e_filepath = path.join(self.filepath, entry)
            e_fp = expandpath(e_filepath)
            if path.isdir(e_fp):
                # Add a subdirectory only if it was previously registered,
                # unless register_subdirs is set.
                info = registry.getDirectoryInfo(e_filepath)
                if info is None and register_subdirs:
                    # Register unknown subdirs
                    registry.registerDirectoryByPath(e_fp)
                    info = registry.getDirectoryInfo(e_filepath)
                if info is not None:
                    mt = types.get(entry)
                    t = None
                    if mt is not None:
                        t = registry.getTypeByMetaType(mt)
                    if t is None:
                        t = DirectoryView
                    ob = t(entry, e_filepath)
                    ob_id = ob.getId()
                    data[ob_id] = ob
                    objects.append({'id': ob_id, 'meta_type': ob.meta_type})
            else:
                pos = rfind(entry, '.')
                if pos >= 0:
                    name = entry[:pos]
                    ext = path.normcase(entry[pos + 1:])
                else:
                    name = entry
                    ext = ''
                if not name or name == 'REQUEST':
                    # Not an allowable id.
                    continue
                mo = bad_id(name)
                if mo is not None and mo != -1:  # Both re and regex formats
                    # Not an allowable id.
                    continue
                t = None
                mt = types.get(entry, None)
                if mt is None:
                    mt = types.get(name, None)
                if mt is not None:
                    t = registry.getTypeByMetaType(mt)
                if t is None:
                    t = registry.getTypeByExtension(ext)
                
                if t is not None:
                    properties = self._readProperties(
                        e_fp + '.properties')
                    try:
                        ob = t(name, e_filepath, fullname=entry,
                               properties=properties)
                    except:
                        import traceback
                        typ, val, tb = exc_info()
                        try:
                            exc_lines = traceback.format_exception( typ,
                                                                    val,
                                                                    tb )
                            LOG( 'DirectoryView',
                                 ERROR,
                                 join( exc_lines, '\n' ) )
                            
                            ob = BadFile( name,
                                          e_filepath,
                                          exc_str=join( exc_lines, '\r\n' ),
                                          fullname=entry )
                        finally:
                            tb = None   # Avoid leaking frame!
                            
                    # FS-based security
                    try:
                        permissions = self._readSecurity(e_fp + '.security')
                        if permissions is not None:
                            for name in permissions.keys():
                                acquire,roles = permissions[name]
                                ob.manage_permission(name,roles,acquire)
                    except:
                        LOG('DirectoryView',
                            ERROR,
                            'Error setting permission from .security file information',
                            error=exc_info())

                    ob_id = ob.getId()
                    data[ob_id] = ob
                    objects.append({'id': ob_id, 'meta_type': ob.meta_type})
                    
        return data, tuple(objects)

    def prepareContents(self, registry, register_subdirs=0):
        # Creates objects for each file.
        data = {}
        objects = []
        types = self._readTypesFile()
        for entry in _filtered_listdir(self._filepath):
            if not self._isAllowableFilename(entry):
                continue
            entry_minimal_fp = '/'.join( (self._minimal_fp, entry) )
            entry_filepath = path.join(self._filepath, entry)
            if path.isdir(entry_filepath):
                # Add a subdirectory only if it was previously registered,
                # unless register_subdirs is set.
                info = registry.getDirectoryInfo(entry_minimal_fp)
                if info is None and register_subdirs:
                    # Register unknown subdirs
                    registry.registerDirectoryByPath(entry_filepath)
                    info = registry.getDirectoryInfo(entry_minimal_fp)
                if info is not None:
                    mt = types.get(entry)
                    t = None
                    if mt is not None:
                        t = registry.getTypeByMetaType(mt)
                    if t is None:
                        t = DirectoryView
                    ob = t(entry, entry_minimal_fp)
                    ob_id = ob.getId()
                    data[ob_id] = ob
                    objects.append({'id': ob_id, 'meta_type': ob.meta_type})
            else:
                pos = entry.rfind('.')
                if pos >= 0:
                    name = entry[:pos]
                    ext = path.normcase(entry[pos + 1:])
                else:
                    name = entry
                    ext = ''
                if not name or name == 'REQUEST':
                    # Not an allowable id.
                    continue
                mo = bad_id(name)
                if mo is not None and mo != -1:  # Both re and regex formats
                    # Not an allowable id.
                    continue
                t = None
                mt = types.get(entry, None)
                if mt is None:
                    mt = types.get(name, None)
                if mt is not None:
                    t = registry.getTypeByMetaType(mt)
                if t is None:
                    t = registry.getTypeByExtension(ext)

                if t is not None:
                    metadata = FSMetadata(entry_filepath)
                    metadata.read()
                    try:
                        ob = t(name, entry_minimal_fp, fullname=entry,
                               properties=metadata.getProperties())
                    except:
                        import traceback
                        typ, val, tb = exc_info()
                        try:
                            exc_lines = traceback.format_exception( typ,
                                                                    val,
                                                                    tb )
                            LOG( 'DirectoryView', ERROR,
                                 '\n'.join(exc_lines) )

                            ob = BadFile( name,
                                          entry_minimal_fp,
                                          exc_str='\r\n'.join(exc_lines),
                                          fullname=entry )
                        finally:
                            tb = None   # Avoid leaking frame!

                    # FS-based security
                    permissions = metadata.getSecurity()
                    if permissions is not None:
                        for name in permissions.keys():
                            acquire, roles = permissions[name]
                            try:
                                ob.manage_permission(name,roles,acquire)
                            except ValueError:
                                LOG('DirectoryView',
                                    ERROR,
                                    'Error setting permissions',
                                    error=exc_info())

                    # only DTML Methods can have proxy roles
                    if hasattr(ob, '_proxy_roles'):
                        try:
                            ob._proxy_roles = tuple(metadata.getProxyRoles())
                        except:
                            LOG('DirectoryView',
                                ERROR,
                                'Error setting proxy role',
                                error=exc_info())

                    ob_id = ob.getId()
#.........这里部分代码省略.........

    def __iter__(self):
        for item in self.previous:
            yield item

        filename = os.path.join(self.source, 'wp_posts.csv')
        assert os.path.isfile(filename), 'Missing file: ' + filename

        with open(filename) as csvfile:
            csv.field_size_limit(self.field_size_limit)
            reader = csv.DictReader(csvfile, **csv_options)
            for row in reader:

                if _skip(row, self.skip):  # should we process this row?
                    continue

                item = dict()
                post_type = row['post_type']

                if post_type == 'post':
                    # posts are imported as portal_type
                    item['portal_type'] = self.portal_type
                elif post_type == 'page':
                    # pages are imported as Page
                    item['portal_type'] = 'Page'
                elif post_type == 'attachment':
                    # attachments are imported as Image or File
                    is_image = row['post_mime_type'].startswith('image')
                    item['portal_type'] = 'Image' if is_image else 'File'
                    item['_mimetype'] = row['post_mime_type']
                    item['_guid'] = row['guid']  # store for later

                if post_type != 'attachment':
                    # for posts and pages the id is the post name
                    item_id = row['post_name']
                    # Zope ids need to be ASCII
                    item_id = fix_id(item_id)
                    item['title'] = strip_tags(row['post_title'])
                else:
                    # for attachments we need to parse the guid
                    # and use the file name as title
                    url = urlparse(row['guid'])
                    item_id = item['title'] = url.path.split('/')[-1]
                    item_id = fix_id(item_id)

                # on Zope ids can't start with "_"
                if bad_id(item_id) is not None:
                    logger.warn('Invalid object id on row ID: ' + row['ID'])
                    continue

                # WordPress stores only publication and modification times
                # we use publication date as creation date
                item['creation_date'] = item['effective_date'] = row['post_date']
                item['modification_date'] = row['post_modified']

                try:
                    item['_path'] = self.get_path(row['ID'], item_id, post_type, item)
                except KeyError:
                    # files defining taxonomies are probably outdated
                    logger.warn('No taxonomies found for row ID: ' + row['ID'])
                    continue

                item['description'] = row['post_excerpt']

                # quotes are escaped; we need to fix that
                item['text'] = row['post_content'].replace('\\"', '"')
                # TODO: validate HTML to avoid post-processing surprises

                # use display_name instead of author_id, if match found
                author_id = row['post_author']
                item['creators'] = self.display_names.get(author_id, author_id)

                if row['post_status'] == 'publish':
                    item['_transitions'] = 'publish'

                item['_pinged'] = row['pinged']  # store for later

                yield item

 def prepareContents(self, registry, register_subdirs=0):
     # Creates objects for each file.
     fp = expandpath(self.filepath)
     data = {}
     objects = []
     l = listdir(fp)
     types = self._readTypesFile()
     for entry in l:
         if not self._isAllowableFilename(entry):
             continue
         e_filepath = path.join(self.filepath, entry)
         e_fp = expandpath(e_filepath)
         if path.isdir(e_fp):
             # Add a subdirectory only if it was previously registered,
             # unless register_subdirs is set.
             info = registry.getDirectoryInfo(e_filepath)
             if info is None and register_subdirs:
                 # Register unknown subdirs
                 if entry not in ('CVS', 'SVN', '.', '..'):
                     registry.registerDirectoryByPath(e_fp)
                     info = registry.getDirectoryInfo(e_filepath)
             if info is not None:
                 mt = types.get(entry)
                 t = None
                 if mt is not None:
                     t = registry.getTypeByMetaType(mt)
                 if t is None:
                     t = DirectoryView
                 ob = t(entry, e_filepath)
                 ob_id = ob.getId()
                 data[ob_id] = ob
                 objects.append({'id': ob_id, 'meta_type': ob.meta_type})
         else:
             pos = rfind(entry, '.')
             if pos >= 0:
                 name = entry[:pos]
                 ext = path.normcase(entry[pos + 1:])
             else:
                 name = entry
                 ext = ''
             if not name or name == 'REQUEST':
                 # Not an allowable id.
                 continue
             mo = bad_id(name)
             if mo is not None and mo != -1:  # Both re and regex formats
                 # Not an allowable id.
                 continue
             t = None
             mt = types.get(entry, None)
             if mt is None:
                 mt = types.get(name, None)
             if mt is not None:
                 t = registry.getTypeByMetaType(mt)
             if t is None:
                 t = registry.getTypeByExtension(ext)
             if t is not None:
                 try:
                     ob = t(name, e_filepath, fullname=entry)
                 except:
                     from zLOG import LOG, ERROR
                     import sys, traceback
                     typ, val, tb = sys.exc_info()
                     exc_lines = traceback.format_exception( typ, val, tb )
                     LOG( 'DirectoryView', ERROR, join( exc_lines, '\n' ) )
                     ob = BadFile( name
                                 , e_filepath
                                 , exc_str=join( exc_lines, '\r\n' )
                                 , fullname=entry
                                 )
                 ob_id = ob.getId()
                 data[ob_id] = ob
                 objects.append({'id': ob_id, 'meta_type': ob.meta_type})
     return data, tuple(objects)