Python User.get方法代码示例

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
def rb_merge_users(new_id, old_id):
    """Updates RB data after an Avatar merge

    :param new_id: Target user
    :param old_id: Source user (being deleted in the merge)
    """
    from indico.modules.rb import settings as rb_settings
    from indico.modules.rb.models.blocking_principals import BlockingPrincipal
    from indico.modules.rb.models.blockings import Blocking
    from indico.modules.rb.models.reservations import Reservation
    from indico.modules.rb.models.rooms import Room

    old_user = User.get(int(old_id))
    new_user = User.get(int(new_id))
    for bp in BlockingPrincipal.find():
        if bp.principal == old_user:
            bp.principal = new_user
    Blocking.find(created_by_id=old_id).update({'created_by_id': new_id})
    Reservation.find(created_by_id=old_id).update({'created_by_id': new_id})
    Reservation.find(booked_for_id=old_id).update({'booked_for_id': new_id})
    Room.find(owner_id=old_id).update({'owner_id': new_id})
    for key in ('authorized_principals', 'admin_principals'):
        principals = rb_settings.get(key)
        principals = principals_merge_users(principals, new_id, old_id)
        rb_settings.set(key, principals)

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
    def migrate_groups(self):
        print cformat('%{white!}migrating groups')

        for old_group in committing_iterator(self.zodb_root['groups'].itervalues()):
            if old_group.__class__.__name__ != 'Group':
                continue
            group = LocalGroup(id=int(old_group.id), name=convert_to_unicode(old_group.name).strip())
            print cformat('%{green}+++%{reset} %{white!}{:6d}%{reset} %{cyan}{}%{reset}').format(group.id, group.name)
            members = set()
            for old_member in old_group.members:
                if old_member.__class__.__name__ != 'Avatar':
                    print cformat('%{yellow!}!!!        Unsupported group member type: {}').format(
                        old_member.__class__.__name__)
                    continue
                user = User.get(int(old_member.id))
                if user is None:
                    print cformat('%{yellow!}!!!        User not found: {}').format(old_member.id)
                    continue
                while user.merged_into_user:
                    user = user.merged_into_user
                if user.is_deleted:
                    print cformat('%{yellow!}!!!        User deleted: {}').format(user.id)
                    continue
                members.add(user)
            for member in sorted(members, key=attrgetter('full_name')):
                print cformat('%{blue!}<->%{reset}        %{white!}{:6d} %{yellow}{} ({})').format(
                    member.id, member.full_name, member.email)
            group.members = members
            db.session.add(group)

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
 def _getNavigationDrawer(self):
     if "user_id" in request.view_args:
         user = User.get(request.view_args["user_id"])
         profile_breadcrumb = _("Profile of {name}").format(name=user.full_name)
     else:
         profile_breadcrumb = _("My Profile")
     return WSimpleNavigationDrawer(profile_breadcrumb)

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
    def _create_user(self, form, handler):
        data = form.data
        existing_user_id = session.get('register_pending_user')
        if existing_user_id:
            # Get pending user and set it as non-pending
            user = User.get(existing_user_id)
            user.is_pending = False
        else:
            user = User(first_name=data['first_name'], last_name=data['last_name'], email=data['email'],
                        address=data.get('address', ''), phone=data.get('phone', ''), affiliation=data['affiliation'])

        identity = handler.create_identity(data)
        user.identities.add(identity)
        user.secondary_emails = handler.extra_emails - {user.email}
        user.favorite_users.add(user)
        db.session.add(user)
        minfo = HelperMaKaCInfo.getMaKaCInfoInstance()
        timezone = session.timezone
        if timezone == 'LOCAL':
            timezone = minfo.getTimezone()
        user.settings.set('timezone', timezone)
        user.settings.set('lang', session.lang or minfo.getLang())
        handler.update_user(user, form)
        db.session.flush()
        login_user(user, identity)
        msg = _('You have sucessfully registered your Indico profile. '
                'Check <a href="{url}">your profile</a> for further details and settings.')
        flash(Markup(msg).format(url=url_for('users.user_profile')), 'success')
        return handler.redirect_success()

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
 def _checkParams(self):
     AdminService._checkParams(self)
     pm = ParameterManager(self._params)
     user_id = pm.extract("userId", pType=int, allowEmpty=False)
     self._user = User.get(user_id)
     if self._user is None:
         raise NoReportError(_("The user that you are trying to login as does not exist anymore in the database"))

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
 def _get_breadcrumbs(self):
     if 'user_id' in request.view_args:
         user = User.get(request.view_args['user_id'])
         profile_breadcrumb = _('Profile of {name}').format(name=user.full_name)
     else:
         profile_breadcrumb = _('My Profile')
     return render_breadcrumbs(profile_breadcrumb)

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
 def _getAnswer(self):
     for fossil in self._userList:
         user = User.get(int(fossil['id']))
         if user is not None:
             user.is_admin = True
     admins = User.find(is_admin=True, is_deleted=False).order_by(User.first_name, User.last_name).all()
     return fossilize([u.as_avatar for u in admins])

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
def retrieve_principal(principal):
    from indico.modules.users import User
    type_, id_ = principal
    if type_ in {'Avatar', 'User'}:
        return User.get(int(id_))
    else:
        raise ValueError('Unexpected type: {}'.format(type_))

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
def retrieve_principal(principal, allow_groups=True, legacy=True):
    """Retrieves principal object from a `(type, id)` tuple.

    Valid principal types are 'Avatar', 'User' and 'Group'.

    :param principal: The principal (a tuple/list)
    :param allow_groups: If group principals are allowed
    :param legacy: If legacy wrappers or new objects should be returned.
    """
    from indico.modules.groups import GroupProxy
    from indico.modules.groups.legacy import LocalGroupWrapper, LDAPGroupWrapper
    from indico.modules.users import User

    type_, id_ = principal
    if type_ in {'Avatar', 'User'}:
        user = User.get(int(id_))
        if not user:
            return None
        return user.as_avatar if legacy else user
    elif type_ == 'Group' and allow_groups:
        if isinstance(id_, (int, basestring)):  # legacy group
            group = LocalGroupWrapper(id_) if unicode(id_).isdigit() else LDAPGroupWrapper(id_)
            return group if legacy else group.group
        else:  # new group
            provider, name_or_id = id_
            group = GroupProxy(name_or_id, provider)
            return group.as_legacy_group if legacy else group
    else:
        raise ValueError('Unexpected type: {}'.format(type_))

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
 def _original_user(self):
     # A proper user, with an id that can be mapped directly to sqlalchemy
     if isinstance(self.id, int) or self.id.isdigit():
         return User.get(int(self.id))
     # A user who had no real indico account but an ldap identifier/email.
     # In this case we try to find his real user and replace the ID of this object
     # with that user's ID.
     data = self.id.split(':')
     # TODO: Once everything is in SQLAlchemy this whole thing needs to go away!
     user = None
     if data[0] == 'LDAP':
         identifier = data[1]
         email = data[2]
         # You better have only one ldap provider or at least different identifiers ;)
         identity = Identity.find_first(Identity.provider != 'indico', Identity.identifier == identifier)
         if identity:
             user = identity.user
     elif data[0] == 'Nice':
         email = data[1]
     else:
         return None
     if not user:
         user = User.find_first(User.all_emails.contains(email))
     if user:
         self._old_id = self.id
         self.id = str(user.id)
         logger.info("Updated legacy user id (%s => %s)", self._old_id, self.id)
     return user

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
def principal_from_identifier(identifier, allow_groups=False, allow_external_users=False):
    # XXX: this is currently only used in PrincipalList
    # if we ever need to support more than just users and groups,
    # make sure to add it in here as well
    from indico.modules.groups import GroupProxy
    from indico.modules.users import User

    try:
        type_, data = identifier.split(':', 1)
    except ValueError:
        raise ValueError('Invalid data')
    if type_ == 'User':
        try:
            user_id = int(data)
        except ValueError:
            raise ValueError('Invalid data')
        user = User.get(user_id, is_deleted=False)
        if user is None:
            raise ValueError('Invalid user: {}'.format(user_id))
        return user
    elif type_ == 'ExternalUser':
        if not allow_external_users:
            raise ValueError('External users are not allowed')
        cache = GenericCache('external-user')
        external_user_data = cache.get(data)
        if not external_user_data:
            raise ValueError('Invalid data')
        user = User.query.filter(User.all_emails == external_user_data['email'], ~User.is_deleted).first()
        if user:
            return user
        # create a pending user. this user isn't sent to the DB unless it gets added
        # to the sqlalchemy session somehow (e.g. by adding it to an ACL).
        # like this processing form data does not result in something being stored in
        # the database, which is good!
        return User(first_name=external_user_data['first_name'], last_name=external_user_data['last_name'],
                    email=external_user_data['email'], affiliation=external_user_data['affiliation'],
                    address=external_user_data['address'], phone=external_user_data['phone'], is_pending=True)
    elif type_ == 'Group':
        if not allow_groups:
            raise ValueError('Groups are not allowed')
        try:
            provider, name = data.split(':', 1)
        except ValueError:
            raise ValueError('Invalid data')
        if not provider:
            # local group
            try:
                group_id = int(name)
            except ValueError:
                raise ValueError('Invalid data')
            group = GroupProxy(group_id)
        else:
            # multipass group
            group = GroupProxy(name, provider)
        if group.group is None:
            raise ValueError('Invalid group: {}'.format(data))
        return group
    else:
        raise ValueError('Invalid data')

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
def principal_from_fossil(fossil, allow_pending=False, allow_groups=True, legacy=True, allow_missing_groups=False,
                          allow_emails=False, allow_networks=False):
    from indico.modules.networks.models.networks import IPNetworkGroup
    from indico.modules.groups import GroupProxy
    from indico.modules.users import User

    type_ = fossil['_type']
    id_ = fossil['id']
    if type_ == 'Avatar':
        if isinstance(id_, int) or id_.isdigit():
            # regular user
            user = User.get(int(id_))
        elif allow_pending:
            data = GenericCache('pending_identities').get(id_)
            if not data:
                raise ValueError("Cannot find user '{}' in cache".format(id_))

            data = {k: '' if v is None else v for (k, v) in data.items()}
            email = data['email'].lower()

            # check if there is not already a (pending) user with that e-mail
            # we need to check for non-pending users too since the search may
            # show a user from external results even though the email belongs
            # to an indico account in case some of the search criteria did not
            # match the indico account
            user = User.find_first(User.all_emails.contains(email), ~User.is_deleted)
            if not user:
                user = User(first_name=data.get('first_name') or '', last_name=data.get('last_name') or '',
                            email=email,
                            address=data.get('address', ''), phone=data.get('phone', ''),
                            affiliation=data.get('affiliation', ''), is_pending=True)
                db.session.add(user)
                db.session.flush()
        else:
            raise ValueError("Id '{}' is not a number and allow_pending=False".format(id_))
        if user is None:
            raise ValueError('User does not exist: {}'.format(id_))
        return user.as_avatar if legacy else user
    elif allow_emails and type_ == 'Email':
        return EmailPrincipal(id_)
    elif allow_networks and type_ == 'IPNetworkGroup':
        group = IPNetworkGroup.get(int(id_))
        if group is None:
            raise ValueError('IP network group does not exist: {}'.format(id_))
        return group
    elif allow_groups and type_ in {'LocalGroupWrapper', 'LocalGroup'}:
        group = GroupProxy(int(id_))
        if group.group is None:
            raise ValueError('Local group does not exist: {}'.format(id_))
        return group.as_legacy_group if legacy else group
    elif allow_groups and type_ in {'LDAPGroupWrapper', 'MultipassGroup'}:
        provider = fossil['provider']
        group = GroupProxy(id_, provider)
        if group.group is None and not allow_missing_groups:
            raise ValueError('Multipass group does not exist: {}:{}'.format(provider, id_))
        return group.as_legacy_group if legacy else group
    else:
        raise ValueError('Unexpected fossil type: {}'.format(type_))

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
    def _getAnswer(self):
        try:
            entry = session.pop('login_as_orig_user')
        except KeyError:
            raise NoReportError(_('No login-as history entry found'))

        session.user = User.get(entry['user_id'])
        session.update(entry['session_data'])
        return True

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
 def export_user(self, user):
     if not user:
         raise HTTPAPIError('You need to be logged in', 403)
     user = User.get(self._user_id, is_deleted=False)
     if not user:
         raise HTTPAPIError('Requested user not found', 404)
     if not user.can_be_modified(user):
         raise HTTPAPIError('You do not have access to that info', 403)
     return [user.as_avatar.fossilize()]

# 需要导入模块: from indico.modules.users import User [as 别名]
# 或者: from indico.modules.users.User import get [as 别名]
 def _process(self):
     user = User.get(int(request.view_args['fav_user_id']))
     self.user.favorite_users.discard(user)
     try:
         db.session.flush()
     except StaleDataError:
         # Deleted in another transaction
         db.session.rollback()
     return jsonify(success=True)