[zopeorg-checkins] CVS: Products/ZopeOrg-NV - ZopeOrgMemberDataTool.py:1.4 ZopeOrgMembershipTool.py:1.6 __init__.py:1.32

[Jens Vagelpohl]

Update of /cvs-zopeorg/Products/ZopeOrg-NV
In directory cvs.zope.org:/tmp/cvs-serv572

Modified Files:
	__init__.py 
Added Files:
	ZopeOrgMemberDataTool.py ZopeOrgMembershipTool.py 
Log Message:
- new day, new CMF tools



=== Products/ZopeOrg-NV/ZopeOrgMemberDataTool.py 1.3 => 1.4 ===
+#####################################################################
+#
+# ZopeOrgMemberDataTool       LDAP-enabled CMF Memberdata Tool
+#
+# This software is governed by a license. See
+# LICENSE.txt for the terms of this license.
+#
+#####################################################################
+__version__='$Revision$'[11:-2]
+
+
+from Products.CMFCore.utils import getToolByName
+from Products.CMFLDAP.LDAPMemberDataTool import LDAPMemberDataTool
+from Products.CMFLDAP.LDAPMemberDataTool import LDAPMemberData
+from Globals import Acquisition, InitializeClass, DTMLFile
+from Acquisition import aq_base
+from ZPublisher.Converters import type_converters
+from AccessControl import ClassSecurityInfo
+from time import strftime, localtime, time
+import string, re
+
+_marker=[]
+
+
+class ZopeOrgMemberData( LDAPMemberData ):
+    security = ClassSecurityInfo()
+
+    def __init__( self, tool, id ):
+        self.id = id
+        # Make a temporary reference to the tool.
+        # The reference will be removed by notifyModified().
+        self._tool = tool
+
+
+    def getProperty( self, id, default=_marker ):
+        """ Need to "defuse" the exception-happy standard implementation"""
+        try:
+            inherited_method = ZopeOrgMemberData.inheritedAttribute( 'getProperty' )
+            prop_val = apply( inherited_method, ( self, id, default ) )
+        except:
+            prop_val = ''
+
+        return prop_val
+
+
+    security.declarePrivate('setLastLogin')
+    def setLastLogin( self ):
+        """ Reset my last login times """
+        user_obj = self.getUser()
+        user_dn = user_obj.getUserDN()
+        acl_manager = self.acl_users
+
+        last_login = user_obj.getProperty('lastLogin') or '20000101000000Z'
+        acl_manager.manage_setUserProperty( user_dn = user_dn
+                                          , prop_name = 'prevLogin'
+                                          , prop_value = last_login
+                                          )
+
+        new_login = strftime('%Y%m%d%H%M%SZ', localtime(time())) 
+        acl_manager.manage_setUserProperty( user_dn = user_dn
+                                          , prop_name = 'lastLogin'
+                                          , prop_value = new_login
+                                          )
+        acl_manager._expireUser(user_obj)
+
+
+    security.declarePrivate('setStartupPage')
+    def setStartupPage( self, target_obj ):
+        """ Set the member's default startup page """
+        url_tool = getToolByName( self, 'portal_url' )
+        startup_page = url_tool.getRelativeContentURL( target_obj )
+        user_obj = self.getUser()
+        user_dn = user_obj.getUserDN()
+        acl_manager = self.acl_users
+
+        acl_manager.manage_setUserProperty( user_dn = user_dn
+                                          , prop_name = 'startupPage'
+                                          , prop_value = startup_page
+                                          )
+        acl_manager._expireUser(user_obj)
+
+
+    security.declarePublic( 'getStartupPage' ) 
+    def getStartupPage( self ):
+        """ return the member's startup page """
+        try:
+            s_url = self.getProperty( 'startupPage' )
+        except: # No startup page in record
+            return None
+
+        try:
+            self.unrestrictedTraverse( s_url )
+        except:
+            s_url = None
+
+        return s_url
+
+
+InitializeClass( ZopeOrgMemberData )
+
+class ZopeOrgMemberDataTool( LDAPMemberDataTool ):
+    '''This tool wraps user objects, making them act as Member objects.
+    '''
+    security = ClassSecurityInfo()
+    meta_type = 'Zope.Org Member Data Tool'
+    title = 'Zope.Org Member Data Tool'
+    manage_showContents = DTMLFile('dtml/memberdataContents', globals())
+
+
+    def __init__( self, id='portal_memberdata' ):
+        self.id = id
+        LDAPMemberDataTool.__init__( self, id )
+        self._setProperty('listed', '', 'boolean')
+        self._setProperty('formtooltips', '', 'boolean')
+
+    def wrapUser( self, u ):
+        """
+        If possible, returns the Member object that corresponds
+        to the given User object.
+        """
+        id = u.getUserName()
+        members = self._members
+
+        if not members.has_key( id ):
+            # Get a temporary member that might be
+            # registered later via registerMemberData().
+            temps = self._v_temps
+
+            if temps is not None and temps.has_key( id ):
+                m = temps[id]
+            else:
+                base = aq_base( self )
+                m = ZopeOrgMemberData( base, id )
+
+                if temps is None:
+                    self._v_temps = { id : m }
+                else:
+                    temps[id] = m
+        else:
+            m = members[id]
+
+        # Return a wrapper with self as containment and
+        # the user as context.
+        return m.__of__( self ).__of__( u )
+
+
+InitializeClass( ZopeOrgMemberDataTool )
+
+
+
+
+def manage_addZopeOrgMemberDataTool( self, REQUEST=None ):
+    """ Need factory method for some special processing """
+    id = 'portal_memberdata'
+ 
+    memdata_tool = ZopeOrgMemberDataTool( id )
+    self._setObject( id, memdata_tool )
+ 
+    if REQUEST is not None:
+        return self.manage_main(self, REQUEST)


=== Products/ZopeOrg-NV/ZopeOrgMembershipTool.py 1.5 => 1.6 ===
+#####################################################################
+#
+# LDAPMembershipTool       LDAP-enabled CMF Membership Tool
+#
+# This software is governed by a license. See
+# LICENSE.txt for the terms of this license.
+#
+#####################################################################
+__version__='$Revision$'[11:-2]
+
+import re, os.path
+from Products.CMFLDAP.LDAPMembershipTool import LDAPMembershipTool
+from Products.CMFCore.utils import _getAuthenticatedUser, _checkPermission, \
+     getToolByName
+from Products.CMFCore.CMFCorePermissions import ManagePortal, SetOwnProperties
+from Products.CMFCore.CMFCorePermissions import AccessContentsInformation
+from Products.CMFCore.CMFCorePermissions import AddPortalContent, View
+from ZopeOrgPermissions import AnointMaintainer, DemoteMaintainer
+from Products.CMFCore.ActionInformation import ActionInformation
+from Products.CMFCore.Expression import Expression
+from Products.CMFCore.PortalFolder import manage_addPortalFolder
+from Products.CMFDefault.SkinnedFolder import addSkinnedFolder
+from Products.CMFDefault import Document
+from Globals import InitializeClass, DTMLFile
+from Acquisition import aq_inner, aq_parent
+from AccessControl import ClassSecurityInfo
+from DateTime import DateTime
+
+
+class ZopeOrgMembershipTool( LDAPMembershipTool ):
+    """ LDAP-enabled CMF Membership Tool """
+    security = ClassSecurityInfo()
+    meta_type = 'Zope.Org Membership Tool'
+    title = 'Zope.Org Membership Tool'
+    manage_mapRoles = DTMLFile('dtml/membershipRolemapping', globals())
+
+
+    def __init__( self, id='portal_membership' ):
+        self.id = id
+
+
+    security.declarePublic( 'getSearchableAttributes' )
+    def getUserSearchableAttributes( self ):
+        """ get user attributes that are allowed for searching """
+        excluded = ( 'lastLogin', 'prevLogin', 'public'
+                   , 'startupPage', 'portalSkin', 'cn' )
+
+        attrs = list( self.acl_users.getLDAPSchema() )
+        deletables = []
+
+        for attr in attrs:
+            if attr[0] in excluded:
+                deletables.append( attr )
+
+        for deletable in deletables:
+            del attrs[attrs.index( deletable )]
+
+        attrs.sort( self._schemaSort )
+
+        return tuple( attrs )
+
+
+    security.declarePrivate( '_schemaSort' )
+    def _schemaSort( self, a, b ):
+        """ sorting for nice looks on personalize page """
+        return cmp( a[1], b[1] )
+
+
+    def getRoster( self, search_param="cn", search_term='' ):
+        """ get the membership roster """
+        isManager = _checkPermission('Manage portal', self)
+        uf = self.acl_users
+        results = uf.findUser( search_param=search_param
+                             , search_term=search_term
+                             )
+        
+        if not isManager:
+            results = filter( lambda x: int( x.get( 'public', 0 ) ) != 0
+                            , results 
+                            )
+
+        return results
+
+
+    def searchMembers( self, search_param, search_term ):
+        """ Search the membership """
+        uf = self.acl_users
+        results = uf.findUser( search_param=search_param
+                             , search_term=search_term
+                             )
+        return results
+
+
+    def getCandidateLocalRoles( self, obj ):
+        """ What local roles can I assign? """
+        member = self.getAuthenticatedMember()
+
+        if 'Manager' in member.getRoles():
+            return self.getPortalRoles()
+        else:
+            member_roles = list( member.getRolesInContext( obj ) )
+            for forbidden in ( 'Anonymous'
+                             , 'Maintainer'
+                             , 'Pending Maintainer'
+                             , 'Member'
+                             ):
+                if forbidden in member_roles:
+                    del member_roles[member_roles.index( forbidden )]
+
+            return member_roles
+
+
+    def createMemberarea( self, id ):
+        """ Create this member's home area """
+        mem_folder = getattr( aq_parent( aq_inner( self ) ), 'Members', None )
+        if mem_folder is not None:
+            user = self.acl_users.getUser( id )
+            # Create Member's home folder
+            # check to avoid collision with automatic member area creation
+            if user is not None and id not in mem_folder.objectIds():
+                f_title = "%s's Home" % id
+                addSkinnedFolder( mem_folder, id, f_title )
+                f = getattr( mem_folder, id ) 
+                f._setPortalTypeName( 'Member Folder' )
+
+                # Grant executable ownership to Member
+                try:
+                    f.changeOwnership( user.__of__( self.acl_users ) )
+                except AttributeError:
+                    pass  # Zope 2.1.x compatibility
+
+                # Set owner local role for member
+                f.manage_setLocalRoles(id, ['Owner'])
+
+
+    security.declareProtected(SetOwnProperties, 'getLastLogin')
+    def getLastLogin( self, member ):
+        """ Retrieve the last login time and return as DateTime object """
+        try:
+            ll = member.getProperty('lastLogin') or '20000101000000Z'
+        except:
+            ll = '20000101000000Z'
+        yr = ll[0:4]
+        mo = ll[4:6]
+        dy = ll[6:8]
+        hr = ll[8:10]
+        mn = ll[10:12]
+        sc = ll[12:14]
+
+        return DateTime('%s/%s/%s %s:%s:%s' % (yr, mo, dy, hr, mn, sc))
+
+
+    security.declareProtected(SetOwnProperties, 'setLastLogin')
+    def setLastLogin( self ):
+        """ Update the last login time """ 
+        member = self.getAuthenticatedMember()
+
+        if member is not None:
+            member.setLastLogin()
+
+
+    security.declareProtected(SetOwnProperties, 'setupMemberArea')
+    def setupMemberArea( self ):
+        """ Set up my member area """
+        member = self.getAuthenticatedMember()
+
+        if member is not None:
+            member_id = member.getUserName()
+            mem_folder = getattr( aq_parent( aq_inner( self ) ), 'Members' )
+            if not member_id in mem_folder.objectIds():
+                self.createMemberarea( member_id )
+
+
+    security.declareProtected(SetOwnProperties, 'setStartupPage')
+    def setStartupPage( self, target_obj ):
+        """ Set this member's preferred startup page """
+        member = self.getAuthenticatedMember()
+
+        if member is not None:
+            member.setStartupPage( target_obj )
+
+
+    def listActions( self, info=None ):
+        """ Lists actions available to the user. """
+        actions_list = None
+        base_list = LDAPMembershipTool.listActions( self, info ) or []
+
+        ##actions_list = [ ActionInformation(
+        ##                    id='Set Start Page',
+        ##                    action=Expression(
+        ##                        text='string: ${object_url}/setStartPage'),
+        ##                    condition=Expression('member'),
+        ##                    permissions=[],
+        ##                    category='user'), ] + base_list
+
+        return base_list
+
+
+InitializeClass( ZopeOrgMembershipTool )
+
+
+def manage_addZopeOrgMembershipTool( self, REQUEST=None ):
+    """ Need factory method for some special processing """
+    id = 'portal_membership'
+
+    mem_tool = ZopeOrgMembershipTool( id )
+    self._setObject( id, mem_tool )
+
+    if REQUEST is not None:
+        return self.manage_main(self, REQUEST)


=== Products/ZopeOrg-NV/__init__.py 1.31 => 1.32 ===
 from Products.CMFCore.utils import registerIcon, ToolInit, ContentInit
 from Products.CMFCore.CMFCorePermissions import AddPortalContent
 from Products.CMFCore import PortalFolder
+import ZopeOrgMembershipTool
+import ZopeOrgMemberDataTool
 import ZopeOrgWorkflow
 import ContentList
 import Acquisition
@@ -115,3 +117,11 @@
                             ),
        fti = ftis ,
        ).initialize(context)
+
+    ToolInit(
+        'Zope.Org Tools',
+        tools = ( ZopeOrgMemberDataTool.ZopeOrgMemberDataTool
+                , ZopeOrgMembershipTool.ZopeOrgMembershipTool
+                ),
+        product_name='ZopeOrg',
+        icon='tool.gif' ).initialize( context )