Changeset 694

Show
Ignore:
Timestamp:
12/15/06 08:10:49
Author:
mylan
Message:

Merge trunk to 610 rev. of branches/plone 2.5: (svn merge -r 575:610 http://svn.quintagroup.com/products/SimpleBlog/branches/plone-2.5 and use svn del for superfluous files)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • SimpleBlog/trunk/Extensions/Install.py

    • Property svn:eol-style set to native
    r693 r694  
    44from StringIO import StringIO 
    55from Products.CMFCore.CMFCorePermissions import setDefaultRoles 
    6  
     6from Products.CMFDynamicViewFTI.migrate import migrateFTIs 
    77from Products.SimpleBlog.config import * 
    8  
    9 from Products.SimpleBlog import MetaWeblogAPI 
    10 from Products.SimpleBlog import BloggerAPI 
    11 from Products.SimpleBlog import MovableTypeAPI 
    128 
    139portlets=['here/portlet_simpleblog/macros/portletBlogFull_local',  
    …… 
    1612          'here/portlet_simpleblog/macros/portletBlogRecent_global'] 
    1713 
    18  
    19  
    20  
    2114def install(self): 
    2215 
    …… 
    2922    install_subskin(self, out, GLOBALS) 
    3023 
     24    # Migrate FTI, to make sure we get the necessary infrastructure for the 
     25    # 'display' menu to work. 
     26    migrated = migrateFTIs(self, product=PROJECTNAME) 
     27    print >>out, "Switched to DynamicViewFTI: %s" % ', '.join(migrated) 
     28 
     29    # Enable portal_factory 
     30    factory = getToolByName(self, 'portal_factory') 
     31    types = factory.getFactoryTypes().keys() 
     32    if 'TrackBack' not in types: 
     33        types.append('TrackBack') 
     34        factory.manage_setPortalFactoryTypes(listOfTypeIds = types) 
     35    if 'BlogEntry' not in types: 
     36        types.append('BlogEntry') 
     37        factory.manage_setPortalFactoryTypes(listOfTypeIds = types) 
     38    if 'BlogFolder' not in types: 
     39        types.append('BlogFolder') 
     40        factory.manage_setPortalFactoryTypes(listOfTypeIds = types) 
     41    if 'Blog' not in types: 
     42        types.append('Blog') 
     43        factory.manage_setPortalFactoryTypes(listOfTypeIds = types) 
     44 
    3145    portal = getToolByName(self,'portal_url').getPortalObject() 
    3246 
    …… 
    3549        addTool(type='SimpleBlog manager')     
    3650     
     51    # register the css 
     52    # Install stylesheet 
     53    # Make it work for the entire portal because the portlets can 
     54    # be used everywhere 
     55    portal_css = getToolByName(self, 'portal_css') 
     56    portal_css.manage_addStylesheet(id = 'SimpleBlogCSS.css', 
     57                                    expression = '', 
     58                                    media = 'all', 
     59                                    title = 'SimpleBlog styles', 
     60                                    enabled = True)     
     61     
    3762    #register the folderish items in portal_properties/site_properties for folder-contents views etc 
    3863    site_props = getToolByName(self, 'portal_properties').site_properties 
     64     
    3965    use_folder_tabs = site_props.getProperty('use_folder_tabs') 
    4066    if not 'Blog' in use_folder_tabs: 
    41         site_props._updateProperty('use_folder_tabs', tuple(use_folder_tabs) + ('Blog','BlogFolder','BlogEntry')) 
    42      
     67        site_props._updateProperty('use_folder_tabs', tuple(use_folder_tabs) + ('Blog','BlogFolder')) 
     68 
     69    use_folder_contents = site_props.getProperty('use_folder_contents') 
     70    if not 'Blog' in use_folder_contents: 
     71        site_props._updateProperty('use_folder_contents', tuple(use_folder_contents) + ('Blog','BlogFolder')) 
     72 
     73    if ENTRY_IS_FOLDERISH: 
     74        if not 'BlogEntry' in use_folder_tabs: 
     75            site_props._updateProperty('use_folder_tabs', tuple(use_folder_tabs) + ('BlogEntry',)) 
     76        if not 'BlogEntry' in use_folder_contents: 
     77            site_props._updateProperty('use_folder_contents', tuple(use_folder_contents) + ('BlogEntry',)) 
     78         
     79 
     80    #Make sure blog entries aren't shown in the navtree by default 
     81    nav_props = getToolByName(self, 'portal_properties').navtree_properties 
     82    metaTypesNotToList = nav_props.getProperty('metaTypesNotToList') 
     83    if not 'BlogEntry' in metaTypesNotToList: 
     84        nav_props._updateProperty('metaTypesNotToList', tuple(metaTypesNotToList) + ('BlogEntry',)) 
     85         
     86    # Add to default_page_types 
     87    # Allow people to have a Blog as the default page 
     88    propsTool = getToolByName(self, 'portal_properties') 
     89    siteProperties = getattr(propsTool, 'site_properties')     
     90    defaultPageTypes = list(siteProperties.getProperty('default_page_types')) 
     91    if 'Blog' not in defaultPageTypes: 
     92        defaultPageTypes.append('Blog') 
     93    siteProperties.manage_changeProperties(default_page_types = defaultPageTypes) 
     94 
    4395    if not portal.hasProperty('trackback_notification_email'): 
    4496        portal.manage_addProperty('trackback_notification_email', '', 'string') 
    45      
    46     # check for property use_folder_contents. This property seems not to be always there: 
    47     if not site_props.hasProperty('use_folder_contents'): 
    48         site_props.manage_addProperty('use_folder_contents', '', 'lines') 
    49  
    50     use_folder_contents = site_props.getProperty('use_folder_contents') 
    51     if not 'Blog' in use_folder_contents: 
    52         site_props._updateProperty('use_folder_contents', tuple(use_folder_contents) + ('Blog','BlogFolder', 'BlogEntry')) 
    53   
     97 
    5498    # discussion enabled by default for BlogEntries 
    5599    getToolByName(self, 'portal_types').BlogEntry.allow_discussion=1 
    …… 
    64108                     category='Products', 
    65109                     appId='SimpleBlog', 
    66                      imageUrl='SimpleBlog/simpleblog_icon.gif', 
     110                     imageUrl='simpleblog_icon.gif', 
    67111                     description='Configure SimpleBlog global settings') 
    68112    except: 
    69113        pass 
    70114 
    71     from Products.SimpleBlog import SimpleBlogWorkflow 
     115    # install the workflow 
     116    from Products.SimpleBlog import SimpleBlogWorkflow, TrackbackWorkflow 
    72117    reload(SimpleBlogWorkflow) 
     118    reload(TrackbackWorkflow) 
     119 
    73120 
    74121    # Remove workflows for BlogEntry and BlogFolder 
    …… 
    77124     
    78125    add_workflow(self, 'simpleblog_workflow', 'simpleblog_workflow (Workflow for Blog Entries)', ('BlogEntry',), out) 
    79     wf_tool.setChainForPortalTypes(('Blog','BlogFolder'), 'folder_workflow') 
    80  
    81     from Products.SimpleBlog import TrackbackWorkflow 
    82     reload(TrackbackWorkflow) 
    83  
    84126    add_workflow(self, 'trackback_workflow', 'trackback_workflow (TrackBack Workflow)', ('TrackBack',), out) 
    85     wf_tool.setChainForPortalTypes( ('TrackBack'), 'trackback_workflow')  
    86  
    87     # Create an RPCAuth if there is not one already 
    88     installRPCAuth(self)     
    89     RPCAuth = self.simpleblog_tool.findRPCAuth(self) 
    90      
    91     # add the blogger object to the portal's root 
    92     # Setup the MetaWeblog API 
    93     portal.metaWeblog = MetaWeblogAPI.MetaWeblogAPI().__of__(self) 
    94     portal.metaWeblog.setupRPCAuth(RPCAuth) 
    95      
    96     # Setup the Blogger API 
    97     portal.blogger = BloggerAPI.BloggerAPI().__of__(self) 
    98     portal.blogger.setupRPCAuth(RPCAuth)     
    99      
    100     # Setup the MovableTypeAPI API 
    101     portal.mt = MovableTypeAPI.MovableTypeAPI().__of__(self) 
    102     portal.mt.setupRPCAuth(RPCAuth)     
    103      
     127 
     128    wf_tool.setChainForPortalTypes(('Blog','BlogFolder'), 'folder_workflow')         
     129 
    104130    print >> out, "Successfully installed %s." % PROJECTNAME 
    105131    return out.getvalue() 
    …… 
    118144    out.write('Added workflow "%s"\n'%wf_id) 
    119145 
    120 def installRPCAuth(self): 
    121     if not hasattr(self, 'RPCAuth'): 
    122         try: 
    123             self.manage_addProduct['RPCAuth'].manage_addRPCAuth('RPCAuth') 
    124         except: 
    125             raise "An RPCAuth instance could not be created.  Please make sure RPCAuth is installed correctly." 
    126  
    127146 
    128147def uninstall(self): 

  • SimpleBlog/trunk/Extensions/utils.py

    • Property svn:eol-style set to native
    r693 r694  
    3030 
    3131 
    32 from Products.SimpleBlog import MetaWeblogAPI 
    33 from Products.SimpleBlog import BloggerAPI 
    34 from Products.SimpleBlog import MovableTypeAPI 
    3532 
    36 def migrateToAPIs(self): 
    37     """ migrate existing SimpleBlog instance to support BloggingAPIs """ 
    38     RPCAuth = self.simpleblog_tool.findRPCAuth(self) 
    39     # Setup the MetaWeblog API 
    40     self.metaWeblog = MetaWeblogAPI.MetaWeblogAPI().__of__(self) 
    41     self.metaWeblog.setupRPCAuth(RPCAuth) 
    42     # Setup the Blogger API 
    43     self.blogger = BloggerAPI.BloggerAPI().__of__(self) 
    44     self.blogger.setupRPCAuth(RPCAuth) 
    45     # Setup the MovableTypeAPI API 
    46     self.mt = MovableTypeAPI.MovableTypeAPI().__of__(self) 
    47     self.mt.setupRPCAuth(RPCAuth)     
     33#from Products.SimpleBlog import MetaWeblogAPI 
     34#from Products.SimpleBlog import BloggerAPI 
     35#from Products.SimpleBlog import MovableTypeAPI 
     36 
     37#def migrateToAPIs(self): 
     38    #""" migrate existing SimpleBlog instance to support BloggingAPIs """ 
     39    #RPCAuth = self.simpleblog_tool.findRPCAuth(self) 
     40    ## Setup the MetaWeblog API 
     41    #self.metaWeblog = MetaWeblogAPI.MetaWeblogAPI().__of__(self) 
     42    #self.metaWeblog.setupRPCAuth(RPCAuth) 
     43    ## Setup the Blogger API 
     44    #self.blogger = BloggerAPI.BloggerAPI().__of__(self) 
     45    #self.blogger.setupRPCAuth(RPCAuth) 
     46    ## Setup the MovableTypeAPI API 
     47    #self.mt = MovableTypeAPI.MovableTypeAPI().__of__(self) 
     48    #self.mt.setupRPCAuth(RPCAuth)     

  • SimpleBlog/trunk/Permissions.py

    • Property svn:eol-style set to native
    r693 r694  
    11from Products.CMFCore.CMFCorePermissions import setDefaultRoles 
     2from Products.Archetypes.public import listTypes 
     3from Products.SimpleBlog.config import PROJECTNAME 
    24 
    35# Add Entry 
    4 ADD_BLOGENTRY_PERMISSION = 'SimpleBlog: Add BlogEntry' 
    5 ADD_SIMPLEBLOG_PERMISSION='SimpleBlog: Add Blog' 
     6CROSS_POST_PERMISSION='SimpleBlog: Cross-post' 
    67 
    7 setDefaultRoles(ADD_BLOGENTRY_PERMISSION, ( 'Manager', 'Owner' ) ) 
     8setDefaultRoles(CROSS_POST_PERMISSION, ( 'Manager', 'Owner' ) ) 
    89 
     10TYPE_ROLES = ('Manager', 'Owner') 
     11 
     12permissions = {} 
     13def wireAddPermissions(): 
     14    """Creates a list of add permissions for all types in this project 
     15     
     16    Must be called **after** all types are registered! 
     17    """ 
     18    global permissions 
     19    blog_types = listTypes(PROJECTNAME) 
     20    for btype in blog_types: 
     21        permission = "%s: Add %s" % (PROJECTNAME, btype['portal_type']) 
     22        setDefaultRoles(permission, TYPE_ROLES) 
     23         
     24        permissions[btype['portal_type']] = permission 
     25    return permissions 

  • SimpleBlog/trunk/SimpleBlogTool.py

    • Property svn:eol-style set to native
    r693 r694  
    2929        self.manage_addProperty('maxItemsInPortlet', 5, 'int') 
    3030        self.manage_addProperty('globalCategories', '', 'lines') 
    31         self.manage_addProperty('showStandardButtons', 1,'boolean') 
    3231        self.manage_addProperty('createPortletOnBlogCreation', 1,'boolean') 
    33         self.manage_addProperty('showIcons', 1,'boolean') 
    3432 
    3533    security.declarePublic('getByUID') 
    …… 
    4947                return RPCAuth 
    5048            parent = parent.aq_parent 
    51         return None     
    52      
     49        return None 
     50 
     51 
    5352    security.declarePublic('idFromTitle') 
    5453    def idFromTitle(self, title): 
    5554        id = re.sub('[^A-Za-z0-9_]', '', re.sub(' ', '_', title)).lower() 
    56         return id         
     55        return id 
    5756 
    5857    def _getState(self): 
    …… 
    7776        except: 
    7877            return [] 
    79         
    80     def _getShowStandardButtons(self): 
    81         try: 
    82             return self.showStandardButtons 
    83         except: 
    84             return 1 
    85  
    86     def _getShowIcons(self): 
    87         if not self.hasProperty('showIcons'): 
    88             self.manage_addProperty('showIcons', 1,'boolean') 
    89         try: 
    90             return self.showIcons 
    91         except: 
    92             return 1 
    9378         
    9479    def _getCreatePortletOnBlogCreation(self): 
    …… 
    9984 
    10085    security.declareProtected(CMFCorePermissions.ManagePortal,'setProperties')         
    101     def setProperties(self, publishedState='published', createPortletOnBlogCreation=None, maxItemsInPortlet=5, globalCategories='', showStandardButtons=1, showIcons=None): 
     86    def setProperties(self, publishedState='published', createPortletOnBlogCreation=None, maxItemsInPortlet=5, globalCategories=''): 
    10287        self.publishedState = publishedState 
    10388        if createPortletOnBlogCreation==1 or createPortletOnBlogCreation=='on': 
    …… 
    10691            self.createPortletOnBlogCreation=0 
    10792 
    108         if showIcons==1 or showIcons=='on': 
    109             self.showIcons = 1 
    110         else: 
    111             self.showIcons = 0 
    112              
    11393        self.maxItemsInPortlet=int(maxItemsInPortlet) 
    11494 
    …… 
    120100 
    121101        self.globalCategories=value 
    122         self.showStandardButtons=int(showStandardButtons) 
    123102     
    124103    security.declarePublic('getPublishedState') 
    125104    def getPublishedState(self): 
    126105        return self._getState() 
     106     
    127107     
    128108    security.declarePublic('getMaxItemsInPortlet') 
    …… 
    154134        else: 
    155135            return context 
     136    security.declarePublic('getStartpointForSearch') 
     137    def getStartpointForSearch(self, context): 
     138        """ 
     139        When in the context of a blog, return the blog 
     140        Outside the context of a blog, return context or if context isn't 
     141        folderish, it's parent container 
     142        """ 
     143        plone_utils = getToolByName(context, 'plone_utils') 
     144         
     145        startpoint = self.getFrontPage(context) 
     146        if not startpoint: 
     147            # we weren't in the context of a blog 
     148            if plone_utils.isStructuralFolder(context): 
     149                return context 
     150            else: 
     151                return context.aq_parent 
     152        else: 
     153            return startpoint 
    156154      
    157155    security.declarePublic('getAvailableCategories') 
    158     def getAvailableCategories(self, context): 
     156    def getAvailableCategories(self, context, startpoint=None): 
    159157        """ 
    160158        returns a dict of all the available categories with the number of posts inside 
    …… 
    165163        # in that case we just search for categories starting in context. 
    166164 
    167         startpoint = self.getStartpoint(context, fromHere=0) 
     165        if not startpoint: 
     166            startpoint = self.getStartpoint(context, fromHere=0) 
    168167 
    169168        # now we have the starting point for our search 
    …… 
    191190            result = startpoint.portal_catalog.searchResults(review_state=self._getState(), meta_type='BlogEntry', EntryCategory=c,  path={'query':self.getObjectPath(startpoint),'level':0}) 
    192191            rescats[c]=len(result) 
    193         return rescats         
     192        return rescats 
    194193     
    195194    security.declarePublic('getSortedKeys') 
    …… 
    203202        return self._getGlobalCategories() 
    204203     
    205     security.declarePublic('searchForEntries') 
     204    security.declarePublic('getStartpoint') 
    206205    def getStartpoint(self, context, fromHere=0): 
    207206        if context.portal_type!='Blog' and fromHere==0: 
    …… 
    231230     
    232231    security.declarePublic('searchForEntries') 
    233     def searchForEntries(self, context, category=None, maxResults=None, fromHere=0): 
     232    def searchForEntries(self, context, category=None, maxResults=None, fromHere=0, filterState=1, **kwargs): 
    234233        # set maxResults=0 for all the results, 
    235234        # leave it to None to get the max from the properties 
    …… 
    239238        # when inside a Blog: search for the frontpage 
    240239        # when outside a Blog: use context (or its container) 
     240         
     241        #filterState controls whether you want to return only published entries 
    241242             
    242243        startpoint = self.getStartpoint(context, fromHere) 
    243244        # now we have the starting point for our search 
    244245         
    245         query={} 
     246        query=kwargs 
     247 
     248        publishedState = self._getState() 
    246249         
    247250        if category!=None: 
    248251            query['EntryCategory']=category 
     252 
     253        query['getAlwaysOnTop']=1 
     254         
     255        if filterState: 
     256            query['review_state']=publishedState             
     257 
    249258             
    250         query['getAlwaysOnTop']=1 
    251         resultsTop = startpoint.portal_catalog.searchResults(query, review_state=self._getState(), meta_type='BlogEntry', path={'query':self.getObjectPath(startpoint),'level':0}, sort_order='reverse', sort_on='effective') 
     259        resultsTop = startpoint.portal_catalog.searchResults(query, meta_type='BlogEntry', path={'query':self.getObjectPath(startpoint),'level':0}, sort_order='reverse', sort_on='effective') 
    252260         
    253261        query['getAlwaysOnTop']=0 
    254         resultsNoTop = startpoint.portal_catalog.searchResults(query, review_state=self._getState(), meta_type='BlogEntry', path={'query':self.getObjectPath(startpoint),'level':0}, sort_order='reverse', sort_on='effective') 
     262        resultsNoTop = startpoint.portal_catalog.searchResults(query, meta_type='BlogEntry', path={'query':self.getObjectPath(startpoint),'level':0}, sort_order='reverse', sort_on='effective') 
    255263         
    256264        results = resultsTop + resultsNoTop 
    257265 
    258          
    259266        if maxResults==0: 
    260267            return results 
    …… 
    264271            return results[:maxResults]     
    265272 
     273 
     274    security.declarePublic('searchForEntries') 
     275    def collectEntries(self, context, category=None, maxResults=None,  filterState=1, allBlogs=0, **kwargs): 
     276        # first get all the blogs 
     277        if allBlogs: 
     278            query = {'meta_type':'Blog', 
     279                        'path':{'query':self.getObjectPath(context),'level':0} 
     280                        } # used meta_type because for some reason, syndication objects also show up. 
     281            blogs = [b.getObject() for b in self.portal_catalog.searchResults(query)] 
     282            onTop=[] 
     283            atBottom=[] 
     284            # now collect all the entries 
     285            for blog in blogs: 
     286                tmpTop, tmpBottom = blog.getEntries(category=category, maxResults=maxResults, filterState = filterState, sort=0, **kwargs) 
     287                onTop = onTop+tmpTop 
     288                atBottom = atBottom+tmpBottom 
     289            #sort 
     290            onTop.sort((lambda x,y:cmp(y.effective(), x.effective()))) 
     291            atBottom.sort((lambda x,y:cmp(y.effective(), x.effective()))) 
     292     
     293            results = onTop+atBottom 
     294        else: 
     295            results = context.getEntries(category=category, maxResults=maxResults, filterState = filterState, sort=0, join=1, skipOnTop=1, **kwargs) 
     296             
     297 
     298        if maxResults==0: 
     299            return results 
     300        elif maxResults==None: 
     301            return results[:self._getMaxItemsInPortlet()] 
     302        else: 
     303            return results[:maxResults] 
     304 
    266305    security.declarePublic('searchForDay') 
    267306    def searchForDay(self, context, date): 
    268307        startpoint = self.getStartpoint(context, fromHere=0) 
    269308        # now we have the starting point for our search 
    270          
    271         query={'start': DateTime(date).earliestTime(), 'start_usage': 'range:min',  
     309 
     310        query={'start': DateTime(date).earliestTime(), 'start_usage': 'range:min', 
    272311                    'end': DateTime(date).latestTime(), 'end_usage':'range:max'} 
    273312        query['getAlwaysOnTop']=1 
    274         resultsTop = startpoint.portal_catalog.searchResults(query,  
    275                                                              review_state=self._getState(),  
    276                                                              meta_type='BlogEntry',  
    277                                                              path={'query':self.getObjectPath(startpoint),'level':0},  
     313        resultsTop = startpoint.portal_catalog.searchResults(query, 
     314                                                             review_state=self._getState(), 
     315                                                             meta_type='BlogEntry', 
     316                                                             path={'query':self.getObjectPath(startpoint),'level':0}, 
    278317                                                             sort_order='reverse', sort_on='effective') 
    279          
    280          
    281318        query['getAlwaysOnTop']=0 
    282         resultsNoTop = startpoint.portal_catalog.searchResults(query,  
    283                                                              review_state=self._getState(),  
    284                                                              meta_type='BlogEntry',  
    285                                                              path={'query':self.getObjectPath(startpoint),'level':0},  
     319        resultsNoTop = startpoint.portal_catalog.searchResults(query, 
     320                                                             review_state=self._getState(), 
     321                                                             meta_type='BlogEntry', 
     322                                                             path={'query':self.getObjectPath(startpoint),'level':0}, 
    286323                                                             sort_order='reverse', sort_on='effective') 
    287          
    288324        results = resultsTop + resultsNoTop 
    289325        return results 
    290     
     326 
     327    security.declarePublic('getUnpublishedEntries') 
     328    def getUnpublishedEntries(self, blog): 
     329        states = self. getEntryWorkflowStates(blog) 
     330        pubstate = self.getPublishedState() 
     331        states = [s for s in states if s!=pubstate] 
     332        query={'review_state':states} 
     333        entries = self.searchForEntries(blog, filterState=0, maxResults=0, fromHere=1, **query) 
     334        return entries 
     335 
    291336    security.declarePublic('blogHasEntries') 
    292337    def blogHasEntries(self, context, fromHere=0): 
    …… 
    297342        """ 
    298343        startpoint = self.getStartpoint(context, fromHere=0) 
    299          
     344 
    300345        # get all entries, doesn't matter what state they're in 
    301346        results = startpoint.portal_catalog.searchResults(meta_type='BlogEntry', path={'query':self.getObjectPath(startpoint),'level':0})         
    302          
     347 
    303348        if results: 
    304349            return True 
    …… 
    313358            return context.EffectiveDate() 
    314359 
    315     security.declarePublic('getShowStandardButtons') 
    316     def getShowStandardButtons(self): 
    317         return self._getShowStandardButtons() 
    318  
    319     security.declarePublic('getShowIcons') 
    320     def getShowIcons(self): 
    321         return self._getShowIcons() 
    322      
    323360    security.declarePublic('getCreatePortletOnBlogCreation') 
    324361    def getCreatePortletOnBlogCreation(self): 

  • SimpleBlog/trunk/SimpleBlogWorkflow.py

    • Property svn:eol-style set to native
    r693 r694  
    2828""" 
    2929 
    30 __version__ = "$Revision: 1.3 $"[11:-2] 
     30__version__ = "$Revision: 12627 $"[11:-2] 
    3131 
    3232from Products.CMFCore.WorkflowTool import addWorkflowFactory 

  • SimpleBlog/trunk/Todo.txt

    • Property svn:eol-style set to native
    r693 r694  
    1 Todo: 
    2 ==== 
    3 Atom, blogger-api support. 
     1Check translations 
    42 
    53 
    6  

  • SimpleBlog/trunk/TrackbackWorkflow.py

    • Property svn:eol-style set to native

  • SimpleBlog/trunk/__init__.py

    • Property svn:eol-style set to native
    r693 r694  
    33from Products.CMFCore import utils 
    44from Products.CMFCore.DirectoryView import registerDirectory 
    5 import os, os.path 
     5import os, os.path, sys, content 
     6 
     7from Products.CMFCore.utils import ContentInit 
     8from Products.CMFCore.utils import ToolInit 
    69 
    710from config import SKINS_DIR, GLOBALS, PROJECTNAME 
    8 from config import ADD_BLOGENTRY_PERMISSION,ADD_SIMPLEBLOG_PERMISSION 
    911 
    1012from Globals import InitializeClass 
    1113 
    12 import xmlrpcMonkeyPatch 
     14registerDirectory(SKINS_DIR, GLOBALS) 
    1315 
    14 registerDirectory(SKINS_DIR, GLOBALS) 
     16from Products.SimpleBlog.Permissions import wireAddPermissions 
     17 
     18# Module aliases - we don't always get it right on the first try, but and we 
     19# can't move modules around because things are stored in the ZODB with the 
     20# full module path. However, we can create aliases for backwards compatability. 
     21 
     22sys.modules['Products.SimpleBlog.Blog'] = content.blog 
     23sys.modules['Products.SimpleBlog.BlogEntry'] = content.blogentry 
     24sys.modules['Products.SimpleBlog.BlogFolder'] = content.blogfolder 
     25sys.modules['Products.SimpleBlog.TrackBack'] = content.trackback 
    1526 
    1627def initialize(context): 
    …… 
    2132    ModuleSecurityInfo('Products.SimpleBlog.util').declarePublic('encodeURLData') 
    2233 
    23     #allow_module('Products.SimpleBlog.Extensions.utils') 
     34    from content import BlogEntry 
     35    from content import Blog 
     36    from content import BlogFolder 
     37    from content import TrackBack 
    2438 
    2539 
    26     ##Import Types here to register them 
    27     import BlogEntry 
    28     import Blog 
    29     import BlogFolder 
    30     import TrackBack     
     40    listOfTypes = listTypes(PROJECTNAME) 
     41 
     42    content_types, constructors, ftis = process_types( 
     43        listOfTypes, 
     44        PROJECTNAME) 
     45 
     46    from Products.SimpleBlog.Permissions import permissions 
    3147     
    32     content_types, constructors, ftis = process_types( 
    33         listTypes(PROJECTNAME), 
    34         PROJECTNAME) 
    35      
    36      
    37     blogIndex = getTypeIndex(content_types, 'Blog') 
    38     entryIndex=getTypeIndex(content_types, 'BlogEntry') 
    39     folderIndex = getTypeIndex(content_types, 'BlogFolder')     
    40     trackbackIndex = getTypeIndex(content_types, 'TrackBack')     
     48    allTypes = zip(content_types, constructors) 
     49    wireAddPermissions() 
     50    for atype, constructor in allTypes: 
     51        kind = "%s: %s" % (PROJECTNAME, atype.archetype_name) 
     52        ContentInit( 
     53            kind, 
     54            content_types      = (atype,), 
     55            permission         = permissions[atype.portal_type], 
     56            extra_constructors = (constructor,), 
     57            fti                = ftis, 
     58            ).initialize(context) 
    4159 
    42     blog_contstructor = [] 
    43     blog_contstructor.append(constructors[blogIndex]) 
    44     entry_contstructor = [] 
    45     entry_contstructor.append(constructors[entryIndex]) 
    46     entry_contstructor.append(constructors[folderIndex]) 
    47     entry_contstructor.append(constructors[trackbackIndex]) 
    48  
    49     blog_type = [] 
    50     blog_type.append(content_types[blogIndex]) 
    51     entry_type = [] 
    52     entry_type.append(content_types[entryIndex]) 
    53     entry_type.append(content_types[folderIndex]) 
    54     entry_type.append(content_types[trackbackIndex]) 
    55      
    56      
    57     utils.ContentInit( 
    58         PROJECTNAME + ' Content', 
    59         content_types      = tuple(blog_type), 
    60         permission         = ADD_SIMPLEBLOG_PERMISSION, 
    61         extra_constructors = tuple(blog_contstructor), 
    62         fti                = ftis, 
    63         ).initialize(context) 
    64      
    65     utils.ContentInit( 
    66         PROJECTNAME + ' Content', 
    67         content_types      = tuple(entry_type), 
    68         permission         = ADD_BLOGENTRY_PERMISSION, 
    69         extra_constructors = tuple(entry_contstructor), 
    70         fti                = ftis, 
    71         ).initialize(context) 
    72      
    7360         
    7461    from SimpleBlogTool import SimpleBlogManager 
    …… 
    7966        icon='tool.gif', ).initialize(context) 
    8067     
    81 def getTypeIndex(content_types, meta_type): 
    82     for i in range(len(content_types)): 
    83         if content_types[i].meta_type==meta_type: 
    84             return i 
    85              
     68 
    8669     
    87      
    88      
    89      
    90      

  • SimpleBlog/trunk/config.py

    • Property svn:eol-style set to native
    r693 r694  
    1 from Permissions import * 
    21from Products.Archetypes.public import DisplayList 
    32 
    …… 
    65 
    76GLOBALS = globals() 
     7ENABLE_ADSENSE = 1 
    88 
     9# deprecated, just here for compatability 
    910DISPLAY_MODE = DisplayList(( 
    10     ('full', 'Full', 'display_full'),  
    11     ('descriptionOnly', 'Description only', 'display_description_only'),  
    12