Changeset 319 in products


Ignore:
Timestamp:
Apr 12, 2006 3:24:08 PM (15 years ago)
Author:
mylan
Message:

plone 2.1 version with blogging APIs support.

Location:
SimpleBlog/branches/plone-2.1-Blogging-APIs
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • SimpleBlog/branches/plone-2.1-Blogging-APIs/Blog.py

    r211 r319  
    66import Permissions 
    77from Products.CMFCore.utils import getToolByName 
     8 
     9import MetaWeblogAPI 
     10import BloggerAPI 
     11import MovableTypeAPI 
     12 
    813 
    914schema = BaseFolderSchema +  Schema(( 
     
    96101                                                    condition="python:0", # this line have to be removed in order to be visible/editable 
    97102                                    description="Enter administrator's email for receaving notification about blog's activity"), 
    98                ) 
     103               ), 
     104    BooleanField('allowDelicious', 
     105                default = 1, 
     106                accessor = 'isDeliciousEnabled', 
     107                schemata = 'interface',  
     108                widget=BooleanWidget(label="Turn Delicious bookmarklet", 
     109                                    label_msgid="label_allow_delicious", 
     110                                    description_msgid="help_allow_delicious"), 
     111                ), 
     112    BooleanField('allowDigg', 
     113                default = 1, 
     114                accessor = 'isDiggEnabled', 
     115                schemata = 'interface', 
     116                widget=BooleanWidget(label="Turn Digg bookmarklet", 
     117                                    label_msgid="label_allow_digg", 
     118                                    description_msgid="help_allow_digg"), 
     119                ), 
     120    BooleanField('allowYahoo', 
     121                default = 1, 
     122                accessor = 'isYahooEnabled', 
     123                schemata = 'interface',  
     124                widget=BooleanWidget(label="Turn Yahoo bookmarklet", 
     125                                    label_msgid="label_allow_yahoo", 
     126                                    description_msgid="help_allow_yahoo"), 
     127                ), 
     128    BooleanField('allowGoogle', 
     129                default = 1, 
     130                accessor = 'isGoogleEnabled', 
     131                schemata = 'interface', 
     132                widget=BooleanWidget(label="Turn Google bookmarklet", 
     133                                    label_msgid="label_allow_google", 
     134                                    description_msgid="help_allow_google"), 
     135                ), 
     136    BooleanField('allowSpurl', 
     137                default = 1, 
     138                accessor = 'isSpurlEnabled', 
     139                schemata = 'interface',  
     140                widget=BooleanWidget(label="Turn Spurl bookmarklet", 
     141                                    label_msgid="label_allow_spurl", 
     142                                    description_msgid="help_allow_spurl"), 
     143                ), 
    99144    #BooleanField('allowComments', 
    100145    #              default = 1, 
     
    123168    global_allow=1 
    124169    schema=schema 
     170 
     171    blogger = None 
     172    metaWeblog = None 
    125173     
    126174    content_icon='simpleblog_icon.gif' 
     
    141189          'visible':0}) 
    142190 
     191    def initializeArchetype(self, **kwargs): 
     192        BaseFolder.initializeArchetype(self, **kwargs) 
     193        RPCAuth = self.simpleblog_tool.findRPCAuth(self) 
     194 
     195        # Setup the MetaWeblog API 
     196        self.metaWeblog = MetaWeblogAPI.MetaWeblogAPI().__of__(self) 
     197        self.metaWeblog.setupRPCAuth(RPCAuth) 
     198         
     199        # Setup the Blogger API 
     200        self.blogger = BloggerAPI.BloggerAPI().__of__(self) 
     201        self.blogger.setupRPCAuth(RPCAuth) 
     202 
     203        # Setup the MovableTypeAPI API 
     204        self.mt = MovableTypeAPI.MovableTypeAPI().__of__(self) 
     205        self.mt.setupRPCAuth(RPCAuth)     
     206 
    143207    def manage_afterAdd(self, item, container): 
    144208        BaseFolder.manage_afterAdd(self, item, container) 
     
    171235        return val 
    172236 
     237    def listCategories(self): 
     238        cats=self.getCategories() 
     239            
     240        # add the global categories 
     241        for c in self.simpleblog_tool.getGlobalCategories(): 
     242            if not c in cats: 
     243                cats.append(c)            
     244        cats = list(cats) 
     245        cats.sort() 
     246        return tuple(cats)                 
     247 
    173248registerType(Blog) 
    174249 
  • SimpleBlog/branches/plone-2.1-Blogging-APIs/Extensions/Install.py

    r211 r319  
    66 
    77from Products.SimpleBlog.config import * 
     8 
     9from Products.SimpleBlog import MetaWeblogAPI 
     10from Products.SimpleBlog import BloggerAPI 
     11from Products.SimpleBlog import MovableTypeAPI 
    812 
    913portlets=['here/portlet_simpleblog/macros/portletBlogFull_local',  
     
    8084    add_workflow(self, 'trackback_workflow', 'trackback_workflow (TrackBack Workflow)', ('TrackBack',), out) 
    8185    wf_tool.setChainForPortalTypes( ('TrackBack'), 'trackback_workflow')  
    82          
     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     
    83104    print >> out, "Successfully installed %s." % PROJECTNAME 
    84105    return out.getvalue() 
     
    96117        wf_tool.setChainForPortalTypes(types, wf_id) 
    97118    out.write('Added workflow "%s"\n'%wf_id) 
     119 
     120def 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." 
    98126 
    99127 
  • SimpleBlog/branches/plone-2.1-Blogging-APIs/Extensions/utils.py

    • Property svn:eol-style deleted
    r28 r319  
    3030 
    3131 
     32from Products.SimpleBlog import MetaWeblogAPI 
     33from Products.SimpleBlog import BloggerAPI 
     34from Products.SimpleBlog import MovableTypeAPI 
    3235 
    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)     
     36def 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)     
  • SimpleBlog/branches/plone-2.1-Blogging-APIs/SimpleBlogTool.py

    • Property svn:eol-style deleted
    r28 r319  
    1818    meta_type= 'SimpleBlog manager'  
    1919    plone_tool = 1 
    20  
     20         
    2121    manage_options=PropertyManager.manage_options 
    22  
     22     
    2323    security = ClassSecurityInfo() 
    2424    calendar_types=['BlogEntry'] 
    2525    use_session="" 
    26  
     26     
    2727    def __init__(self): 
    2828        self.manage_addProperty('publishedState', 'published', 'string') 
    2929        self.manage_addProperty('maxItemsInPortlet', 5, 'int') 
    3030        self.manage_addProperty('globalCategories', '', 'lines') 
     31        self.manage_addProperty('showStandardButtons', 1,'boolean') 
    3132        self.manage_addProperty('createPortletOnBlogCreation', 1,'boolean') 
     33        self.manage_addProperty('showIcons', 1,'boolean') 
    3234 
    3335    security.declarePublic('getByUID') 
     
    4749                return RPCAuth 
    4850            parent = parent.aq_parent 
    49         return None 
    50  
    51  
     51        return None     
     52     
    5253    security.declarePublic('idFromTitle') 
    5354    def idFromTitle(self, title): 
    5455        id = re.sub('[^A-Za-z0-9_]', '', re.sub(' ', '_', title)).lower() 
    55         return id 
     56        return id         
    5657 
    5758    def _getState(self): 
     
    7677        except: 
    7778            return [] 
    78  
     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 
     93         
    7994    def _getCreatePortletOnBlogCreation(self): 
    8095        try: 
     
    8499 
    85100    security.declareProtected(CMFCorePermissions.ManagePortal,'setProperties')         
    86     def setProperties(self, publishedState='published', createPortletOnBlogCreation=None, maxItemsInPortlet=5, globalCategories=''): 
     101    def setProperties(self, publishedState='published', createPortletOnBlogCreation=None, maxItemsInPortlet=5, globalCategories='', showStandardButtons=1, showIcons=None): 
    87102        self.publishedState = publishedState 
    88103        if createPortletOnBlogCreation==1 or createPortletOnBlogCreation=='on': 
     
    91106            self.createPortletOnBlogCreation=0 
    92107 
     108        if showIcons==1 or showIcons=='on': 
     109            self.showIcons = 1 
     110        else: 
     111            self.showIcons = 0 
     112             
    93113        self.maxItemsInPortlet=int(maxItemsInPortlet) 
    94114 
     
    100120 
    101121        self.globalCategories=value 
    102  
     122        self.showStandardButtons=int(showStandardButtons) 
     123     
    103124    security.declarePublic('getPublishedState') 
    104125    def getPublishedState(self): 
    105126        return self._getState() 
    106  
     127     
    107128    security.declarePublic('getMaxItemsInPortlet') 
    108129    def getMaxItemsInPortlet(self): 
    109130        return self._getMaxItemsInPortlet() 
    110  
     131     
    111132    security.declarePublic('getFrontPage') 
    112133    def getFrontPage(self, context): 
     
    126147                    break 
    127148                parent=parent.aq_parent 
    128  
     149             
    129150            if found==1: 
    130151                return parent 
     
    133154        else: 
    134155            return context 
    135     security.declarePublic('getStartpointForSearch') 
    136     def getStartpointForSearch(self, context): 
    137         """ 
    138         When in the context of a blog, return the blog 
    139         Outside the context of a blog, return context or if context isn't 
    140         folderish, it's parent container 
    141         """ 
    142         plone_utils = getToolByName(context, 'plone_utils') 
    143  
    144         startpoint = self.getFrontPage(context) 
    145         if not startpoint: 
    146             # we weren't in the context of a blog 
    147             if plone_utils.isStructuralFolder(context): 
    148                 return context 
    149             else: 
    150                 return context.aq_parent 
    151         else: 
    152             return startpoint 
    153  
     156      
    154157    security.declarePublic('getAvailableCategories') 
    155     def getAvailableCategories(self, context, startpoint=None): 
     158    def getAvailableCategories(self, context): 
    156159        """ 
    157160        returns a dict of all the available categories with the number of posts inside 
     
    161164        # if we are higher in the tree than any Blog then we will end up in the portalobject itself 
    162165        # in that case we just search for categories starting in context. 
    163         if not startpoint: 
    164             startpoint = self.getStartpoint(context, fromHere=0) 
    165         categories = context.portal_catalog.uniqueValuesFor('EntryCategory') 
    166         path = self.getObjectPath(startpoint) 
    167  
     166 
     167        startpoint = self.getStartpoint(context, fromHere=0) 
     168 
     169        # now we have the starting point for our search 
     170         
     171        result = startpoint.portal_catalog.searchResults(meta_type=['BlogFolder', 'Blog'], path={'query':self.getObjectPath(startpoint),'level':0}) 
     172         
     173        # now fetch all the available categories 
     174        categories=[] 
     175        for o in result: 
     176            obj=o.getObject() 
     177            cats = obj.getCategories() 
     178            for c in cats: 
     179                if not c in categories: 
     180                    categories.append(c) 
     181         
     182        # add the global categories 
     183        for c in self.getGlobalCategories(): 
     184            if not c in categories: 
     185                categories.append(c) 
     186         
    168187        # now we have a list of unique categories available from startpoint and deeper in tree 
    169188        # next step is to count the number of entries for each category 
    170189        rescats={} 
    171         [rescats.update({c:0}) for c in categories] 
    172         result = startpoint.portal_catalog.searchResults(review_state=self._getState(), meta_type='BlogEntry', path={'query':path,'level':0}) 
    173  
    174         for r in result: 
    175             for c in r.EntryCategory: rescats[c] = rescats[c]+1 
    176         for c,n in rescats.items(): 
    177             if n==0: del rescats[c] 
    178         return rescats 
    179  
     190        for c in categories: 
     191            result = startpoint.portal_catalog.searchResults(review_state=self._getState(), meta_type='BlogEntry', EntryCategory=c,  path={'query':self.getObjectPath(startpoint),'level':0}) 
     192            rescats[c]=len(result) 
     193        return rescats         
     194     
    180195    security.declarePublic('getSortedKeys') 
    181196    def getSortedKeys(self, dict): 
     
    183198        keys.sort() 
    184199        return keys 
    185  
     200     
    186201    security.declarePublic('getGlobalCategories') 
    187202    def getGlobalCategories(self): 
    188203        return self._getGlobalCategories() 
    189  
    190     security.declarePublic('getStartpoint') 
     204     
     205    security.declarePublic('searchForEntries') 
    191206    def getStartpoint(self, context, fromHere=0): 
    192207        if context.portal_type!='Blog' and fromHere==0: 
     
    202217                    break 
    203218                parent=parent.aq_parent 
    204  
     219             
    205220            if found==1: 
    206221                startpoint=parent 
     
    214229 
    215230        return startpoint 
    216  
     231     
    217232    security.declarePublic('searchForEntries') 
    218     def searchForEntries(self, context, category=None, maxResults=None, fromHere=0, filterState=1, **kwargs): 
     233    def searchForEntries(self, context, category=None, maxResults=None, fromHere=0): 
    219234        # set maxResults=0 for all the results, 
    220235        # leave it to None to get the max from the properties 
    221236        # set fromHere=1 to search from the current location. Is used for BlogFolders 
    222  
     237         
    223238        # first, get the context right 
    224239        # when inside a Blog: search for the frontpage 
    225240        # when outside a Blog: use context (or its container) 
    226  
    227         #filterState controls whether you want to return only published entries 
    228  
     241             
    229242        startpoint = self.getStartpoint(context, fromHere) 
    230         query=kwargs 
    231         publishedState = self._getState() 
     243        # now we have the starting point for our search 
     244         
     245        query={} 
     246         
    232247        if category!=None: 
    233248            query['EntryCategory']=category 
    234  
    235         if filterState: 
    236             query['review_state']=publishedState             
    237  
    238         results = startpoint.portal_catalog.searchResults(query, meta_type='BlogEntry',  
    239                   path={'query':self.getObjectPath(startpoint),'level':0}, sort_order='reverse',  
    240                   sort_on='effective', sort_limit=maxResults and maxResults or None) 
    241  
    242         if  maxResults==0: 
     249             
     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') 
     252         
     253        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') 
     255         
     256        results = resultsTop + resultsNoTop 
     257 
     258         
     259        if maxResults==0: 
    243260            return results 
    244261        elif maxResults==None: 
     
    246263        else: 
    247264            return results[:maxResults]     
    248  
    249265 
    250266    security.declarePublic('searchForDay') 
     
    252268        startpoint = self.getStartpoint(context, fromHere=0) 
    253269        # now we have the starting point for our search 
    254  
    255         query={'start': DateTime(date).earliestTime(), 'start_usage': 'range:min', 
     270         
     271        query={'start': DateTime(date).earliestTime(), 'start_usage': 'range:min',  
    256272                    'end': DateTime(date).latestTime(), 'end_usage':'range:max'} 
    257273        query['getAlwaysOnTop']=1 
    258         resultsTop = startpoint.portal_catalog.searchResults(query, 
    259                                                              review_state=self._getState(), 
    260                                                              meta_type='BlogEntry', 
    261                                                              path={'query':self.getObjectPath(startpoint),'level':0}, 
     274        resultsTop = startpoint.portal_catalog.searchResults(query,  
     275                                                             review_state=self._getState(),  
     276                                                             meta_type='BlogEntry',  
     277                                                             path={'query':self.getObjectPath(startpoint),'level':0},  
    262278                                                             sort_order='reverse', sort_on='effective') 
     279         
     280         
    263281        query['getAlwaysOnTop']=0 
    264         resultsNoTop = startpoint.portal_catalog.searchResults(query, 
    265                                                              review_state=self._getState(), 
    266                                                              meta_type='BlogEntry', 
    267                                                              path={'query':self.getObjectPath(startpoint),'level':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},  
    268286                                                             sort_order='reverse', sort_on='effective') 
     287         
    269288        results = resultsTop + resultsNoTop 
    270289        return results 
    271  
    272     security.declarePublic('getUnpublishedEntries') 
    273     def getUnpublishedEntries(self, blog): 
    274         states = self. getEntryWorkflowStates(blog) 
    275         pubstate = self.getPublishedState() 
    276         states = [s for s in states if s!=pubstate] 
    277         query={'review_state':states} 
    278         entries = self.searchForEntries(blog, filterState=0, maxResults=0, fromHere=1, **query) 
    279         return entries 
    280  
     290    
    281291    security.declarePublic('blogHasEntries') 
    282292    def blogHasEntries(self, context, fromHere=0): 
     
    287297        """ 
    288298        startpoint = self.getStartpoint(context, fromHere=0) 
    289  
     299         
    290300        # get all entries, doesn't matter what state they're in 
    291301        results = startpoint.portal_catalog.searchResults(meta_type='BlogEntry', path={'query':self.getObjectPath(startpoint),'level':0})         
    292  
     302         
    293303        if results: 
    294304            return True 
     
    303313            return context.EffectiveDate() 
    304314 
     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     
    305323    security.declarePublic('getCreatePortletOnBlogCreation') 
    306324    def getCreatePortletOnBlogCreation(self): 
     
    316334                    lst.append(states[s].id) 
    317335        return lst 
    318  
     336     
    319337    security.declareProtected(CMFCorePermissions.ManagePortal,'getEntryWorkflowStates') 
    320338    def getEntryWorkflowStates(self, context): 
     
    326344                if not states[s].id in lst: 
    327345                    lst.append(states[s].id) 
    328  
     346         
    329347        return lst 
    330348 
     
    332350    def getObjectPath(self, object): 
    333351        return os.path.join(*object.getPhysicalPath()).replace('\\', '/') 
    334  
     352         
    335353    # ====================================================== 
    336354    # calendar stuff, copied from CMFCalender 
     
    351369        """ Returns a list of days with the correct start day first """         
    352370        return calendar.weekheader(2).split() 
    353  
     371         
    354372    security.declarePublic('getWeeksList') 
    355373    def getWeeksList(self, month='1', year='2002'): 
     
    364382        #  [28, 29, 30, 31, 0, 0, 0]] 
    365383        daysByWeek=calendar.monthcalendar(year, month) 
    366  
     384     
    367385        return daysByWeek 
    368386 
     
    382400        daysByWeek=calendar.monthcalendar(year, month) 
    383401        weeks=[] 
    384  
     402         
    385403        events=self.catalog_getevents(context, year, month) 
    386  
     404     
    387405        for week in daysByWeek: 
    388406            days=[] 
     
    392410                else: 
    393411                    days.append({'day': day, 'event': 0, 'eventslist':[]}) 
    394  
     412                 
    395413            weeks.append(days) 
    396  
     414             
    397415        return weeks 
    398  
     416     
    399417    security.declarePublic('catalog_getevents') 
    400418    def catalog_getevents(self, context, year, month): 
     
    406424        ## last_date=DateTime(str(month)+'/'+str(last_day)+'/'+str(year)) 
    407425        last_date=first_date + last_day     
    408  
     426         
    409427        # get the starting point for our search. This is where we depart from the standard catalog_tool: 
    410428        startpoint = self.getStartpoint(context, fromHere=0) 
    411  
     429         
    412430        query=self.portal_catalog(portal_type=self.calendar_types, 
    413431                              review_state=self._getState(), 
     
    418436                              path={'query':self.getObjectPath(startpoint),'level':0}, 
    419437                              sort_on='start') 
    420  
     438         
    421439        # compile a list of the days that have events 
    422440        eventDays={} 
     
    468486        # end calendar stuff 
    469487        # ================== 
    470  
     488     
     489     
     490     
    471491InitializeClass(SimpleBlogManager) 
  • SimpleBlog/branches/plone-2.1-Blogging-APIs/__init__.py

    • Property svn:eol-style deleted
    r28 r319  
    33from Products.CMFCore import utils 
    44from Products.CMFCore.DirectoryView import registerDirectory 
    5 import os, os.path, sys, content 
    6  
    7 from Products.CMFCore.utils import ContentInit 
    8 from Products.CMFCore.utils import ToolInit 
     5import os, os.path 
    96 
    107from config import SKINS_DIR, GLOBALS, PROJECTNAME 
     8from config import ADD_BLOGENTRY_PERMISSION,ADD_SIMPLEBLOG_PERMISSION 
    119 
    1210from Globals import InitializeClass 
    1311 
     12import xmlrpcMonkeyPatch 
     13 
    1414registerDirectory(SKINS_DIR, GLOBALS) 
    15  
    16 from 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  
    22 sys.modules['Products.SimpleBlog.Blog'] = content.blog 
    23 sys.modules['Products.SimpleBlog.BlogEntry'] = content.blogentry 
    24 sys.modules['Products.SimpleBlog.BlogFolder'] = content.blogfolder 
    25 sys.modules['Products.SimpleBlog.TrackBack'] = content.trackback 
    2615 
    2716def initialize(context): 
     
    3221    ModuleSecurityInfo('Products.SimpleBlog.util').declarePublic('encodeURLData') 
    3322 
    34     from content import BlogEntry 
    35     from content import Blog 
    36     from content import BlogFolder 
    37     from content import TrackBack 
     23    #allow_module('Products.SimpleBlog.Extensions.utils') 
    3824 
    3925 
    40     listOfTypes = listTypes(PROJECTNAME) 
     26    ##Import Types here to register them 
     27    import BlogEntry 
     28    import Blog 
     29    import BlogFolder 
     30    import TrackBack     
     31     
     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')     
    4141 
    42     content_types, constructors, ftis = process_types( 
    43         listOfTypes, 
    44         PROJECTNAME) 
     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]) 
    4548 
    46     from Products.SimpleBlog.Permissions import permissions 
     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]) 
    4755     
    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) 
    59  
     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     
    6073         
    6174    from SimpleBlogTool import SimpleBlogManager 
     
    6679        icon='tool.gif', ).initialize(context) 
    6780     
    68  
     81def 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             
    6986     
     87     
     88     
     89     
     90     
  • SimpleBlog/branches/plone-2.1-Blogging-APIs/version.txt

    r211 r319  
    1 1.4.0qg 
     11.5qg 
Note: See TracChangeset for help on using the changeset viewer.