def _getAnswer(self):
     ah = AvatarHolder()
     for user in self._userList:
         spk = conference.SubContribParticipation()
         spk.setDataFromAvatar(ah.getById(user["id"]))
         self._subContrib.newSpeaker(spk)
     return fossilize(self._subContrib.getSpeakerList(), ISubContribParticipationFullFossil)

 def _getAnswer(self):
     ah = AvatarHolder()
     for user in self._userList:
         convener = SessionChair()
         convener.setDataFromAvatar(ah.getById(user["id"]))
         self._session.addConvener(convener)
     return self._getConvenerList()

    def autoLogin(self, rh):
        """
        Login using Shibbolet.
        """
        req = rh._req
        req.add_common_vars()
        if req.subprocess_env.has_key("REMOTE_USER"):
            email = req.subprocess_env["REMOTE_USER"]
            from MaKaC.user import AvatarHolder

            ah = AvatarHolder()
            av = ah.match({"email": email}, exact=1)
            if av:
                av = av[0]
                if av.getStatus() == "NotCreated":
                    # checking if comming from Nice
                    if av.getId()[: len(self.id)] == self.id:
                        av.setId("")
                        ah.add(av)
                        av.activateAccount()
                        return av
                elif not av.isActivated():
                    av.activateAccount()
                    return av
                else:
                    return av
        return None

def create_dummy_user():
    """
    Creates a dummy user for testing purposes
    """
    avatar = Avatar()

    avatar.setName("fake")
    avatar.setSurName("fake")
    avatar.setOrganisation("fake")
    avatar.setLang("en_GB")
    avatar.setEmail("[email protected]")

    # registering user
    ah = AvatarHolder()
    ah.add(avatar)

    # setting up the login info
    li = LoginInfo("dummyuser", "dummyuser")
    ih = AuthenticatorMgr()
    userid = ih.createIdentity(li, avatar, "Local")
    ih.add(userid)

    # activate the account
    avatar.activateAccount()

    # since the DB is empty, we have to add dummy user as admin
    minfo = HelperMaKaCInfo.getMaKaCInfoInstance()

    al = minfo.getAdminList()
    al.grant(avatar)

    dc = DefaultConference()
    HelperMaKaCInfo.getMaKaCInfoInstance().setDefaultConference(dc)
    return avatar

 def testGroupHolder(self):
     gh = GroupHolder()
     ah = AvatarHolder()
     self.assert_(gh.getById("fake-group-1").containsUser(ah.getById("fake-1")))
     self.assertEqual(gh.match({"groupname": "fake-group-1"}, searchInAuthenticators=False)[0].getEmail(),
                      "[email protected]")
     self.assertEqual(len(gh.matchFirstLetter("f", searchInAuthenticators=False)), 2)

    def setUp(self):
        super(TestAuthentication, self).setUp()

        with self._context("database"):
            # Create few users and groups
            gh = GroupHolder()
            ah = AvatarHolder()
            self._authMgr = AuthenticatorMgr()

            for i in xrange(1, 3):
                group = Group()
                group.setName("fake-group-%d" % i)
                group.setDescription("fake")
                group.setEmail("fake-group-%[email protected]" % i)
                group.setId("fake-group-%d" % i)
                avatar = Avatar()
                avatar.setName("fake-%d" % i)
                avatar.setSurName("fake")
                avatar.setOrganisation("fake")
                avatar.setLang("en_GB")
                avatar.setEmail("fake%[email protected]" % i)
                avatar.setId("fake-%d" % i)
                avatar.activateAccount()
                group.addMember(avatar)
                ah.add(avatar)
                gh.add(group)
                identity = self._authMgr.createIdentity(LoginInfo("fake-%d" % i, "fake-%d" % i), avatar, "Local")
                self._authMgr.add(identity)

def searchUsers(surName="", name="", organisation="", email="", conferenceId=None, exactMatch=True, searchExt=False):

    if surName != "" or name != "" or organisation != "" or email != "":
        # build criteria
        criteria = {
            "surName": surName,
            "name": name,
            "organisation": organisation,
            "email": email
        }
        # search users
        people = AvatarHolder().match(criteria, exact=exactMatch, searchInAuthenticators=searchExt)

        # search authors
        if conferenceId is not None:
            conference = ConferenceHolder().getById(conferenceId)
            authorIndex = conference.getAuthorIndex()
            authors = authorIndex.match(criteria, exact=exactMatch)
            # merge with users
            users = people
            people = []
            emails = []
            for user in users:
                people.append(user)
                emails.extend(user.getEmails())
            for author in authors:
                if author.getEmail() not in emails:
                    people.append(author)
        return people
    else:
        return []

def create_dummy_users(dummyuser_has_password=False):
    """
    Creates a dummy user for testing purposes.

    If dummyuser_has_password is set, "dummyuser" and "fake-1" can be used for logging in.
    """
    minfo = HelperMaKaCInfo.getMaKaCInfoInstance()
    ah = AvatarHolder()
    authManager = AuthenticatorMgr()
    avatars = []
    al = minfo.getAdminList()

    avatar = create_user("fake", "dummyuser", authManager, dummyuser_has_password)
    ah.add(avatar)
    avatars.append(avatar)
    al.grant(avatar)

    for i in xrange(1, 5):
        avatar = create_user("fake-%d" % i, "fake-%d" % i, authManager, dummyuser_has_password and i == 1)
        avatar.setId("fake-%d" % i)
        ah.add(avatar)
        avatars.append(avatar)

    HelperMaKaCInfo.getMaKaCInfoInstance().setDefaultConference(DefaultConference())
    return avatars

def create_dummy_users():
    """
    Creates a dummy user for testing purposes
    """
    minfo = HelperMaKaCInfo.getMaKaCInfoInstance()
    ah = AvatarHolder()
    authManager = AuthenticatorMgr()
    avatars = []
    al = minfo.getAdminList()

    avatar = create_user("fake", "dummyuser", authManager)
    ah.add(avatar)
    avatars.append(avatar)
    al.grant(avatar)

    for i in xrange(1, 5):
        avatar = create_user("fake-%d" % i, "fake-%d" % i, authManager)
        avatar.setId("fake-%d" % i)
        ah.add(avatar)
        avatars.append(avatar)

    # since the DB is empty, we have to add dummy user as admin
    minfo = HelperMaKaCInfo.getMaKaCInfoInstance()

    dc = DefaultConference()
    HelperMaKaCInfo.getMaKaCInfoInstance().setDefaultConference(dc)
    return avatars

 def _checkParams(self):
     AdminService._checkParams(self)
     pm = ParameterManager(self._params)
     av = AvatarHolder()
     userId = pm.extract("userId", pType=str, allowEmpty=False)
     self._user = av.getById(userId)
     if self._user == None:
         raise ServiceError("ER-U0", _("Cannot find user with id %s") % userId)

def migrateAvatars(catalog):
    print "Migrating avatars...",
    ah=AvatarHolder()
    count=0
    for av in catalog.dump():
        ah._getIdx()[av.getId()]=av
        count+=1
    print "[Done:%s]"%count

 def _checkParams(self):
     ConferenceModifBase._checkParams(self)
     pm = ParameterManager(self._params)
     ah = AvatarHolder()
     userId = pm.extract("userId", pType=str, allowEmpty=False)
     self._user = ah.getById(userId)
     if self._user == None:
         raise ServiceError("ERR-U0", _("User '%s' does not exist.") % userId)

 def testAvatarHolder(self):
     """
     Test Avatar Holder
     """
     ah = AvatarHolder()
     self.assertEqual(ah.getById("fake-1").getName(), "fake-1")
     self.assertEqual(ah.match({"name": "fake-1"}, searchInAuthenticators=False)[0].getEmail(), "[email protected]")
     self.assertEqual(len(ah.matchFirstLetter("name", "f", searchInAuthenticators=False)), 2)

 def _getAnswer(self):
     ah = AvatarHolder()
     for user in self._userList:
         if user["id"] != None:
             self._conf.getAbstractMgr().addAuthorizedSubmitter(ah.getById(user["id"]))
         else:
             raise ServiceError("ERR-U0", _("User does not exist."))
     return fossilize(self._conf.getAbstractMgr().getAuthorizedSubmitterList())

 def _checkParams(self):
     self._pm = ParameterManager(self._params)
     userId = self._pm.extract("userId", None)
     if userId is not None:
         ah = AvatarHolder()
         self._target = ah.getById(userId)
     else:
         raise ServiceError("ERR-U5", _("User id not specified"))

 def _checkParams(self):
     AdminService._checkParams(self)
     self._pm = ParameterManager(self._params)
     userId = self._pm.extract("userId", pType=str, allowEmpty=True)
     if userId is not None:
         ah = AvatarHolder()
         self._avatar = ah.getById(userId)
     else:
         self._avatar = self._aw.getUser()

 def _getAvatarByEmail(self, email):
     from MaKaC.user import AvatarHolder
     ah = AvatarHolder()
     avatars = ah.match({"email": email}, exact=1, forceWithoutExtAuth=True)
     if not avatars:
         avatars = ah.match({"email": email}, exact=1)
     for av in avatars:
         if av.hasEmail(email):
             return av
     return None

 def export_user(self, aw):
     requested_user = AvatarHolder().getById(self._user_id)
     user = aw.getUser()
     if not requested_user:
         raise HTTPAPIError('Requested user not found', 404)
     if user:
         if requested_user.canUserModify(user):
             return [requested_user.fossilize()]
         raise HTTPAPIError('You do not have access to that info', 403)
     raise HTTPAPIError('You need to be logged in', 403)

 def _run(self, args):
     avatar = AvatarHolder().getById(args.id)
     self.printUserInfo(avatar, args.id)
     if not avatar.isAdmin():
         print "User seems to has no administrator privileges"
     if console.yesno("Are you sure to revoke administrator privileges from this user?"):
         adminList = info.HelperMaKaCInfo.getMaKaCInfoInstance().getAdminList()
         adminList.revoke(avatar)
         print "Administrator privileges revoked successfully"
     return 0

 def validate_principals(self, field):
     for item in field.data:
         try:
             type_ = item['_type']
             id_ = item['id']
         except Exception as e:
             raise ValidationError('Invalid principal data: {}'.format(e))
         if type_ not in ('Avatar', 'Group', 'LDAPGroup'):
             raise ValidationError('Invalid principal data: type={}'.format(type_))
         holder = AvatarHolder() if type_ == 'Avatar' else GroupHolder()
         if not holder.getById(id_):
             raise ValidationError('Invalid principal: {}:{}'.format(type_, id_))