Changeset 1010

Show
Ignore:
Timestamp:
11/28/07 11:21:46
Author:
piv
Message:

portlets dump bug fixes and improvements

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • qPloneSkinDump/branches/plone_3.0/HISTORY.txt

    r999 r1010  
     1qPloneSkinDump 0.8.1 
     2 
     3    - essential improvements of dumping portlets 
     4 
    15qPloneSkinDump 0.8.0 
    26    - configlet form improvement 

  • qPloneSkinDump/branches/plone_3.0/TODO.txt

    r999 r1010  
    1 *** Under consideration *** 
     1*** TODO LIST *** 
    22 
    3   - improvement portlets dumping 
    43  - improvements in resource dumping 
    54  - refactor portal_view_customizations dump 
    65  - add dump of portal_properties 
    7   - add dump of viewlets.xml and portlets.xml 
     6  - add dump of viewlets.xml 
     7  - add dump of portlets.xml 
    88  - core refactorization, divide into small chunks all functionality (too difficult to upgrade current skindump structure) 
    9    
     9       * maybe using zope 3 component architecture 
    1010maybe in future: 
    1111  - refactor qPloneSkinDump to work with python paster package, for use ZopeSkel templates styling 

  • qPloneSkinDump/branches/plone_3.0/skin_template/setuphandlers.py

    r999 r1010  
     1from zope.dottedname.resolve import resolve 
    12from zope.component import getUtility, getSiteManager, getMultiAdapter 
    23 
    3 from plone.portlets.interfaces import IPortletAssignmentMapping, IPortletManager, ILocalPortletAssignmentManager 
    4 from plone.app.customerize.registration import * 
     4from plone.portlets.interfaces import IPortletAssignmentMapping, IPortletManager, IPlacelessPortletManager 
     5from plone.portlets.interfaces import IPortletContext, IPortletDataProvider 
     6from plone.portlets.interfaces import ILocalPortletAssignmentManager 
     7from plone.portlets.storage import PortletCategoryMapping, PortletAssignmentMapping 
    58from plone.app.portlets import portlets 
    69 
     10from plone.app.customerize.registration import * 
     11 
    712from Products.CMFCore.utils import getToolByName 
     13from Products.GenericSetup.utils import _getDottedName, _resolveDottedName 
    814 
    915from Products.%(product_name)s.config import * 
    …… 
    1420logger = getLogger('%(product_name)s') 
    1521 
    16 def assignPortlet(mapping, portlet_name, portlet_type, **kwargs): 
    17     portlet = None 
    18     if hasattr(portlets, portlet_type): 
    19         portlet = getattr(portlets, portlet_type).Assignment 
    20         if portlet: 
    21             portlet = portlet(**kwargs) 
    22             mapping[portlet_name] = portlet 
    23             return portlet 
    24     return False 
     22def assignPortlet(mapping, info): 
     23    name = info['name'] 
     24    try: 
     25        assignment = _resolveDottedName(info['class']) 
     26    except: 
     27        e,v,tr = sys.exc_info() 
     28        logger.info('Debug from setup portlets handler: %%s: %%s (%%s)' , info['class'], str(v), str(e)) 
     29        return False 
     30    else: 
     31        portlet = assignment(**info['kwargs']) 
     32        if mapping.get(name, None) is not None: 
     33            del mapping[name] 
     34        mapping[name] = portlet 
     35        return portlet 
    2536 
    26 def setupPortletsForContext(context, info): 
     37def setupSiteWidePortlets(site, data, managers): 
    2738 
    28     leftColumn = getUtility(IPortletManager, name=u'plone.leftcolumn', context=context) 
    29     rightColumn = getUtility(IPortletManager, name=u'plone.rightcolumn', context=context) 
     39    for name, info in data: 
     40        manager = managers.get(name, None) 
     41        if manager is not None: 
     42            for category, keys in info.items(): 
     43                catmapping = manager.get(category, None) 
     44                if catmapping is None: 
     45                    catmapping = manager[category] = PortletCategoryMapping() 
     46                for key, assignments in keys.items(): 
     47                    mapping = catmapping.get(key, None) 
     48                    if mapping is None: 
     49                        mapping = catmapping[key] = PortletAssignmentMapping() 
     50                    for assignment in assignments.values(): 
     51                        assignPortlet(mapping, assignment) 
    3052 
    31     left = getMultiAdapter((context, leftColumn,), IPortletAssignmentMapping, context=context) 
    32     right = getMultiAdapter((context, rightColumn,), IPortletAssignmentMapping, context=context) 
     53def setupPortletsForContext(context, data, managers): 
    3354 
    34     leftassignable = getMultiAdapter((context, leftColumn,), ILocalPortletAssignmentManager) 
    35     rightassignable = getMultiAdapter((context, rightColumn,), ILocalPortletAssignmentManager) 
    36  
    37     for cat, val in info.get('left_slots_blacklists', {}).items(): 
    38         leftassignable.setBlacklistStatus(cat, val) 
    39  
    40     for cat, val in info.get('right_slots_blacklists', {}).items(): 
    41         rightassignable.setBlacklistStatus(cat, val) 
    42  
    43     for slot in info.get('remove_left_slots', ()) or left.keys(): 
    44         if slot in left: 
    45             del left[slot] 
    46  
    47     for slot in info.get('remove_right_slots', ()) or right.keys(): 
    48         if slot in right: 
    49             del right[slot] 
    50  
    51     for slot in info.get('add_left_slots', ()): 
    52         if slot['name'] not in left: 
    53             assignPortlet(left, slot['name'], slot['type'], **slot['kwargs']) 
    54  
    55     for slot in info.get('add_right_slots', ()): 
    56         if slot['name'] not in right: 
    57             assignPortlet(right, slot['name'], slot['type'], **slot['kwargs']) 
     55    for name, info in data: 
     56        manager = managers.get(name, None) 
     57        if manager is not None: 
     58            if info['assignments']: 
     59                # set portlet assignments 
     60                mapping = getMultiAdapter((context, manager), IPortletAssignmentMapping, context=context) 
     61                for assignment in info['assignments']: 
     62                    assignPortlet(mapping, assignment) 
     63            if info['blacklists']: 
     64                # set blacklists 
     65                localassignmentmanager = getMultiAdapter((context, manager), ILocalPortletAssignmentManager, context=context) 
     66                for category, status in info['blacklists']: 
     67                    localassignmentmanager.setBlacklistStatus(category, status) 
    5868 
    5969def importPortlets(context): 
    6070    site = context.getSite() 
    6171 
     72    components = getSiteManager(site) 
     73    ms = [r for r in components.registeredUtilities() if r.provided.isOrExtends(IPortletManager)] 
     74    context_managers = {} 
     75    for m in ms: 
     76        if not m.provided.isOrExtends(IPlacelessPortletManager): 
     77            context_managers[m.name] = getUtility(IPortletManager, name=m.name, context=site) 
     78 
     79    managers = {} 
     80    for m in ms: 
     81        managers[m.name] = getUtility(IPortletManager, name=m.name, context=site) 
     82 
    6283    for path, info in SLOT_STRUCTURE: 
    63         try: 
    64             obj = site.restrictedTraverse(path) 
    65         except: 
    66             e,v,tr = sys.exc_info() 
    67             logger.info('Debug from importPortlets handler: %%s: %%s (%%s)' , path, str(v), str(e)) 
     84        if path == '__site-wide-portlets__': 
     85            setupSiteWidePortlets(site, info, managers) 
    6886        else: 
    69             setupPortletsForContext(obj, info) 
     87            try: 
     88                obj = site.restrictedTraverse(path) 
     89            except: 
     90                e,v,tr = sys.exc_info() 
     91                logger.info('Debug from importPortlets handler: %%s: %%s (%%s)' , path, str(v), str(e)) 
     92            else: 
     93                setupPortletsForContext(obj, info, context_managers) 
    7094 
    7195def importZexps(context): 
    …… 
    79103    if FINAL_CUSTOMIZATION_FUNCTIONS: 
    80104        dummy = [func(site, out) for func in FINAL_CUSTOMIZATION_FUNCTIONS] 
    81  
    82 def old_install(context): 
    83     site = context.getSite() 
    84     self = site 
    85  
    86     # Checking base condition for installation 
    87 #    skinsTool = getToolByName(self, 'portal_skins') 
    88     # Checking for absence of SKIN_NAME skin in site 
    89 #    skin_names = skinsTool.getSkinSelections() 
    90 #    if SKIN_NAME in skin_names: 
    91 #        raise AttributeError("Installation aborted due to '%%s' skin already present in your site." %% SKIN_NAME) 
    92     # Checking for BASE_SKIN_NAME presenting in portal 
    93 #    skin_names = skinsTool.getSkinSelections() 
    94 #    if not BASE_SKIN_NAME in skin_names: 
    95 #        raise AttributeError("Impossible installation without %%s skin." %% BASE_SKIN_NAME) 
    96     # Checking for presenting lower_SKIN_NAME directory in portal skins 
    97 #    lower_SKIN_NAME = string.lower(SKIN_NAME) 
    98     #if lower_SKIN_NAME in skinsTool.objectIds(): 
    99     #    raise AttributeError("%%s skin layer already exist in portal skins. Installation Impossible." %% lower_SKIN_NAME) 
    100      
    101     #return CHECKED_MESSAGE 
    102  
    103     # AFTER INSTALL 
    104     #out=StringIO() 
    105     # get all needed tools and some portal's core objects 
    106     #portal = getToolByName(self, 'portal_url').getPortalObject() 
    107     #pp = getToolByName(portal, 'portal_properties') 
    108     #portal_css = getToolByName(portal, 'portal_css', None) 
    109     #portal_js = getToolByName(portal, 'portal_javascripts', None) 
    110     # Make main prepare procedures 
    111     #pp_up = prepareInstallation(portal, pp, out) # create 'uninstall_properties' propertySheet in portal_properties 
    112     # Install skin 
    113     #installSkin(portal, pp_up, out)    # performed with portal_setup 
    114     #prepareUninstallSkin(portal, pp_up, out) 
    115  
    116     # Register css resources 
    117     #if portal_css and DOES_COSTOMIZE_CSS: 
    118         #registerResource(pp_up, portal_css, portal_css.registerStylesheet, out \ 
    119                         #,CSS_LIST, SKIN_CSS_REGDATA, 'q_registered_css', CSS_REG_PROPS) 
    120         #print >> out, "Completed tuning CSS registry for new skin needs." 
    121     # Register js resources 
    122     #if portal_js and DOES_COSTOMIZE_JS: 
    123         #registerResource(pp_up, portal_js, portal_js.registerScript, out \ 
    124                         #,JS_LIST, SKIN_JS_REGDATA, 'q_registered_js', JS_REG_PROPS)#---installJS--- 
    125         #print >> out, "Completed tuning JS registry for new skin needs." 
    126     # Customize slots     
    127     #if LEFT_SLOTS or RIGHT_SLOTS: 
    128         #customizeSlots(portal, pp_up, out) 
    129     # Import object(s) to portal 
    130     #if checkIfImport(): 
    131         #res_import = performImportToPortal(portal) 
    132         #print >> out, res_import 
    133     # FINAL customization call additional functions from config  
    134     #if FINAL_CUSTOMIZATION_FUNCTIONS: 
    135         #dummy = [func(portal, out) for func in FINAL_CUSTOMIZATION_FUNCTIONS] 
    136     print >> out, "%%s generated product." %% GENERATOR_PRODUCT 
    137     print >> out, '=== Installation successfully completed. ===' 
    138     #product.log(out.getvalue()) 
    139     #product._p_changed = 1 #XXX:NEED for stable writing 'out' log to qi on afterinstallation. 
    140     return out.getvalue() 
    141105 
    142106def importCustomViews(context): 

  • qPloneSkinDump/branches/plone_3.0/utils.py

    r1002 r1010  
    1212from zope.publisher.interfaces.browser import IBrowserRequest 
    1313from five.customerize.interfaces import IViewTemplateContainer, ITTWViewTemplate 
    14 from plone.portlets.interfaces import IPortletAssignmentMapping, IPortletManager, IPortletDataProvider 
    15 from plone.portlets.constants import CONTEXT_CATEGORY, GROUP_CATEGORY, CONTENT_TYPE_CATEGORY 
     14from plone.portlets.interfaces import IPortletAssignmentMapping, IPortletManager, IPlacelessPortletManager 
     15from plone.portlets.interfaces import IPortletContext, IPortletDataProvider 
    1616from plone.portlets.interfaces import ILocalPortletAssignmentManager 
    1717from plone.app.customerize.registration import generateIdFromRegistration, interfaceName 
    1818 
     19from Products.GenericSetup.utils import _getDottedName, _resolveDottedName 
    1920from Products.GenericSetup.interfaces import IBody 
    2021from Products.GenericSetup.context import BaseContext 
    …… 
    7475    return result 
    7576 
    76 def extractPortletsFromContext(context, slot_structure, typesToShow): 
     77def extractInfoFromAssignment(name, assignment): 
     78    klass = assignment.__class__ 
     79    a = {'name' : name, 'class' : '%s' % _getDottedName(klass)} 
     80    data = assignment.data 
     81    kwargs = {} 
     82    for i in list(providedBy(data)): 
     83        if i.isOrExtends(IPortletDataProvider): 
     84            for field_name, field in getFields(i).items(): 
     85                kwargs[field_name] = field.get(assignment) 
     86    a['kwargs'] = kwargs 
     87    return a 
     88 
     89def extractSiteWidePortlets(context, managers): 
     90    """ Extract site-wide portlets  
     91        Data structure: 
     92            '__site-wide-portlets__', [(<manager1_name>, <manager1_info>), 
     93                                       (<manager2_name>, <manager2_info>), 
     94                                       (<manager3_name>, <manager3_info>)]) 
     95            <manager_info>: 
     96                {'category1' : <catmapping1>, 
     97                 'category2' : <catmapping2>} 
     98            <catmapping>: 
     99                {'key1' : <mapping1>, 
     100                 'key2' : <mapping2>} 
     101            <mapping>: 
     102                {'assignment_name1' : <assignment1>, 
     103                 'assignment_name2' : <assignment2>} 
     104            <assignment>: 
     105                {'name'   : 'Assignment', 
     106                 'class'  : 'dotted.path.to.assignment.class', 
     107                 'kwargs' : {'parameter1' : 'value1', 
     108                             'parameter2' : 'value2'} 
     109    """ 
     110    info = [] 
     111    for manager_name, manager in managers: 
     112        manager_info = {} 
     113        for category, catmapping in manager.items(): 
     114            catmapping_info = {} 
     115            for key, mapping in catmapping.items(): 
     116                mapping_info = {} 
     117                for name, assignment in mapping.items(): 
     118                    mapping_info[name] = extractInfoFromAssignment(name, assignment) 
     119                catmapping_info[key] = mapping_info 
     120            manager_info[category] = catmapping_info 
     121        info.append((manager_name, manager_info)) 
     122    return info 
     123 
     124def extractContextPortletsFromManager(context, manager): 
     125    """ Extract all contextual portlets from given object and portlet manager, and portlets blacklists 
     126        Data structure: 
     127        <manager_info> = 
     128            {'blacklists'  : [(GROUP_CATEGORY, True), 
     129                              (CONTENT_TYPE_CATEGORY, False), 
     130                              (CONTEXT_CATEGORY, None)], 
     131             'assignments' : [{'name'   : 'Assignment-2', 
     132                               'class'  : 'dotted.path.to.assignment.class', 
     133                               'kwargs' : {'parameter1' : 'value1', 
     134                                          'parameter2' : 'value2'}}, 
     135                              {'name'   : 'Assignment', 
     136                               'class'  : 'dotted.path.to.assignment.class', 
     137                               'kwargs' : {'parameter1' : 'value1', 
     138                                            'parameter2' : 'value2'}]} 
     139    """ 
    77140 
    78141    info = {} 
    79  
    80     leftColumn = getUtility(IPortletManager, name=u'plone.leftcolumn', context=context) 
    81     rightColumn = getUtility(IPortletManager, name=u'plone.rightcolumn', context=context) 
    82  
    83     left = getMultiAdapter((context, leftColumn,), IPortletAssignmentMapping, context=context) 
    84     right = getMultiAdapter((context, rightColumn,), IPortletAssignmentMapping, context=context) 
    85  
    86     leftassignable = getMultiAdapter((context, leftColumn,), ILocalPortletAssignmentManager) 
    87     rightassignable = getMultiAdapter((context, rightColumn,), ILocalPortletAssignmentManager) 
    88  
    89     info['left_slots_blacklists'] = {GROUP_CATEGORY        : leftassignable.getBlacklistStatus(GROUP_CATEGORY), 
    90                                      CONTENT_TYPE_CATEGORY : leftassignable.getBlacklistStatus(CONTENT_TYPE_CATEGORY), 
    91                                      CONTEXT_CATEGORY      : leftassignable.getBlacklistStatus(CONTEXT_CATEGORY)} 
    92  
    93     info['right_slots_blacklists'] = {GROUP_CATEGORY        : rightassignable.getBlacklistStatus(GROUP_CATEGORY), 
    94                                       CONTENT_TYPE_CATEGORY : rightassignable.getBlacklistStatus(CONTENT_TYPE_CATEGORY), 
    95                                       CONTEXT_CATEGORY      : rightassignable.getBlacklistStatus(CONTEXT_CATEGORY)} 
    96  
    97     info['add_left_slots'] = [] 
    98     for name, portlet in left.items(): 
    99         for i in list(providedBy(portlet)): 
    100             if i.isOrExtends(IPortletDataProvider): 
    101                 kwargs = {} 
    102                 for fn, field in getFields(i).items(): 
    103                     kwargs[fn] = field.get(portlet) 
    104                 info['add_left_slots'].append({'name'   : name, 
    105                                                'type'   : name, 
    106                                                'kwargs' : kwargs}) 
    107  
    108     info['add_right_slots'] = [] 
    109     for name, portlet in right.items(): 
    110         for i in list(providedBy(portlet)): 
    111             if i.isOrExtends(IPortletDataProvider): 
    112                 kwargs = {} 
    113                 for fn, field in getFields(i).items(): 
    114                     kwargs[fn] = field.get(portlet) 
    115                 info['add_right_slots'].append({'name'   : name, 
    116                                                 'type'   : name, 
    117                                                 'kwargs' : kwargs}) 
    118  
    119     info['remove_left_slots'] = [] 
    120     info['remove_right_slots'] = [] 
    121  
    122     slot_structure.append(('/'.join(context.getPhysicalPath()[2:]), info)) 
     142    info['assignments'] = assignments = [] 
     143    info['blacklists'] = blacklists = [] 
     144 
     145    # Extract contextual portlets 
     146    mapping = getMultiAdapter((context, manager), IPortletAssignmentMapping, context=context) 
     147    for name, assignment in mapping.items(): 
     148        assignments.append(extractInfoFromAssignment(name, assignment)) 
     149 
     150    # Extract blacklists for given object and manager 
     151    localassignmentmanager = getMultiAdapter((context, manager), ILocalPortletAssignmentManager) 
     152    blacklist = localassignmentmanager._getBlacklist() 
     153    if blacklist is not None: 
     154        for category, key in blacklist.items(): 
     155            blacklists.append((category, key)) 
     156 
     157    return info 
     158 
     159def extractPortletsFromContext(context, slot_structure, typesToShow, managers): 
     160    """ Extract portlets for given object assigned through all portlet managers. 
     161        Data structure: 
     162            ('unique/path/to/context', [(<manager1_name>, <manager1_info>), 
     163                                        (<manager2_name>, <manager2_info>), 
     164                                        (<manager3_name>, <manager3_info>)]) 
     165    """ 
     166 
     167 
     168    info = [] 
     169    key = '/'.join(context.getPhysicalPath()[2:]) 
     170 
     171    for name, manager in managers: 
     172        info.append((name, extractContextPortletsFromManager(context, manager))) 
     173 
     174    slot_structure.append((key, info)) 
    123175 
    124176    return slot_structure 
    125177 
    126 def dumpAllPortlets(context, slot_structure, typesToShow): 
    127     extractPortletsFromContext(context, slot_structure, typesToShow) 
     178def dumpAllPortlets(context, slot_structure, typesToShow, managers): 
     179    extractPortletsFromContext(context, slot_structure, typesToShow, managers) 
    128180    if getattr(context.aq_base, 'isPrincipiaFolderish', 0): 
    129181        for id, obj in context.contentItems(): 
    130182            if obj.portal_type in typesToShow: 
    131                 dumpAllPortlets(obj, slot_structure, typesToShow) 
     183                dumpAllPortlets(obj, slot_structure, typesToShow, managers) 
    132184 
    133185    return slot_structure 
    134186 
    135187def dumpPortlets(context, dump_policy, dump_portlets_selection): 
     188    """ Extract portlets from given set of objects and site-wide portlets too. 
     189        Data structure: 
     190            SLOT_STRUCTURE = 
     191                [(), (), ()] 
     192    """ 
    136193 
    137194    portal = getToolByName(context, 'portal_url').getPortalObject() 
    …… 
    139196    typesToShow = portal_state.friendly_types() 
    140197 
     198    components = getSiteManager(context) 
     199    managers = [r for r in components.registeredUtilities() if r.provided.isOrExtends(IPortletManager)] 
     200    context_managers = [(m.name, getUtility(IPortletManager, name=m.name, context=context)) for m in managers 
     201                                                                               if not IPlacelessPortletManager.providedBy(m.component)] 
     202    managers = [(m.name, getUtility(IPortletManager, name=m.name, context=context)) for m in managers] 
     203 
    141204    slot_structure = [] 
    142205    if dump_policy == 'root': 
    143         extractPortletsFromContext(portal, slot_structure, typesToShow) 
     206        extractPortletsFromContext(portal, slot_structure, typesToShow, context_managers) 
    144207    elif dump_policy == 'all': 
    145         dumpAllPortlets(portal, slot_structure, typesToShow) 
     208        dumpAllPortlets(portal, slot_structure, typesToShow, context_managers) 
    146209    elif dump_policy == 'selection': 
    147210        for ppath in dump_portlets_selection: 
    148211            obj = portal.restrictedTraverse(ppath) 
    149             extractPortletsFromContext(obj, slot_structure, typesToShow) 
     212            extractPortletsFromContext(obj, slot_structure, typesToShow, context_managers) 
     213 
     214    slot_structure.append(('__site-wide-portlets__', extractSiteWidePortlets(portal, managers))) 
    150215 
    151216    return slot_structure 

  • qPloneSkinDump/branches/plone_3.0/version.txt

    r999 r1010  
    1 0.8.0 
     10.8.1