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

plone 2.1 version with blogging APIs support.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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) 
Note: See TracChangeset for help on using the changeset viewer.