# ------------------------------------------------------------------------------
from appy.gen.plone25.wrappers import AbstractWrapper

# ------------------------------------------------------------------------------
class UserWrapper(AbstractWrapper):

    def showLogin(self):
        '''When must we show the login field?'''
        if self.o.isTemporary(): return 'edit'
        return 'view'

    def validateLogin(self, login):
        '''Is this p_login valid?'''
        # The login can't be the id of the whole site or "admin"
        if (login == self.o.portal_url.getPortalObject().getId()) or \
           (login == 'admin'):
            return self.translate(u'This username is reserved. Please choose ' \
                                   'a different name.', domain='plone')
        # Check that the login does not already exist and check some
        # Plone-specific rules.
        pr = self.o.portal_registration
        if not pr.isMemberIdAllowed(login):
            return self.translate(u'The login name you selected is already ' \
               'in use or is not valid. Please choose another.', domain='plone')
        return True

    def validatePassword(self, password):
        '''Is this p_password valid?'''
        # Password must be at least 5 chars length
        if len(password) < 5:
            return self.translate(u'Passwords must contain at least 5 letters.',
                                  domain='plone')
        return True

    def showPassword(self):
        '''When must we show the 2 fields for entering a password ?'''
        if self.o.isTemporary(): return 'edit'
        return False

    def getGrantableRoles(self):
        '''Returns the list of roles that the admin can grant to a user.'''
        res = []
        for role in self.o.getProductConfig().grantableRoles:
            res.append( (role, self.translate('role_%s' % role)) )
        return res

    def validate(self, new, errors):
        '''Inter-field validation.'''
        page = self.request.get('page', 'main')
        if page == 'main':
            if hasattr(new, 'password1') and (new.password1 != new.password2):
                msg = self.translate(u'Passwords do not match.', domain='plone')
                errors.password1 = msg
                errors.password2 = msg
        return self._callCustom('validate', new, errors)

    def onEdit(self, created):
        self.title = self.firstName + ' ' + self.name
        aclUsers = self.o.acl_users
        login = self.login
        if created:
            # Create the corresponding Zope user
            aclUsers._doAddUser(login, self.password1, self.roles, ())
            # Remove our own password copies
            self.password1 = self.password2 = ''
        # Perform updates on the corresponding Plone user
        zopeUser = aclUsers.getUserById(login)
        # This object must be owned by its Plone user
        if 'Owner' not in self.o.get_local_roles_for_userid(login):
            self.o.manage_addLocalRoles(login, ('Owner',))
        # Change group membership according to self.roles. Indeed, instead of
        # granting roles directly to the user, we will add the user to a
        # Appy-created group having this role.
        userRoles = self.roles
        #userGroups = zopeUser.getGroups()
        # for role in self.o.getProductConfig().grantableRoles:
        #    # Retrieve the group corresponding to this role
        #    groupName = '%s_group' % role
        #    if role == 'Manager':    groupName = 'Administrators'
        #    elif role == 'Reviewer': groupName = 'Reviewers'
        #    group = self.o.portal_groups.getGroupById(groupName)
        #    # Add or remove the user from this group according to its role(s).
        #    if role in userRoles:
        #        # Add the user if not already present in the group
        #        if groupName not in userGroups:
        #            group.addMember(self.login)
        #    else:
        #        # Remove the user if it was in the corresponding group
        #        if groupName in userGroups:
        #            group.removeMember(self.login)
        return self._callCustom('onEdit', created)

    def onDelete(self):
        '''Before deleting myself, I must delete the corresponding Plone
           user.'''
        # Delete the corresponding Plone user
        self.o.acl_users._doDelUser(self.login)
        self.log('Plone user "%s" deleted.' % self.login)
        # Call a custom "onDelete" if any.
        return self._callCustom('onDelete')
# ------------------------------------------------------------------------------