:class:`~zhmcclient.UserManager`: Access to the :term:`Users <User>` in
        this Console.
544468
def users(self):
        
        # We do here some lazy loading.
        if not self._users:
            self._users = UserManager(self)
        return self._users
480099
def get_users_for_assigned_to():
    
    User = get_user_model()
    return User.objects.filter(is_active=True, is_staff=True)
564796
def users(self):
        
        return Users(url="%s/users" % self.root,
                     securityHandler=self._securityHandler,
                     proxy_url=self._proxy_url,
                     proxy_port=self._proxy_port)
998831
def assignee(self):
        
        if self.api and self.assignee_id:
            return self.api._get_user(self.assignee_id)
1302240
def user(self, user):
        
        if user is None:
            raise ValueError("Invalid value for `user`, must not be `None`")
        if user is not None and len(user) > 1024:
            raise ValueError("Invalid value for `user`, length must be less than or equal to `1024`")

        self._user = user
1006296
def view_user(self, user):
        
        log.debug('Viewing user %s', user.username)
        self.cur_user = None
        self.pages_tabw.setCurrentIndex(9)
        self.user_username_le.setText(user.username)
        self.user_first_le.setText(user.first_name)
        self.user_last_le.setText(user.last_name)
        self.user_email_le.setText(user.email)

        prjrootdata = treemodel.ListItemData(['Name', 'Short', 'Path', 'Created', 'Semester', 'Status', 'Resolution', 'FPS', 'Scale'])
        prjrootitem = treemodel.TreeItem(prjrootdata)
        prjs = djadapter.projects.filter(users=user)
        for prj in prjs:
            prjdata = djitemdata.ProjectItemData(prj)
            treemodel.TreeItem(prjdata, prjrootitem)
        self.user_prj_model = treemodel.TreeModel(prjrootitem)
        self.user_prj_tablev.setModel(self.user_prj_model)

        taskrootdata = treemodel.ListItemData(['Name'])
        taskrootitem = treemodel.TreeItem(taskrootdata)
        self.user_task_model = treemodel.TreeModel(taskrootitem)
        self.user_task_treev.setModel(self.user_task_model)
        tasks = djadapter.tasks.filter(users=user)
        assets = {}
        shots = {}
        atypes = {}
        seqs = {}
        prjs = {}
        for t in tasks:
            tdata = djitemdata.TaskItemData(t)
            titem = treemodel.TreeItem(tdata)
            e = t.element
            if isinstance(e, djadapter.models.Asset):
                eitem = assets.get(e)
                if not eitem:
                    edata = djitemdata.AssetItemData(e)
                    eitem = treemodel.TreeItem(edata)
                    assets[e] = eitem
                egrp = e.atype
                egrpitem = atypes.get(egrp)
                if not egrpitem:
                    egrpdata = djitemdata.AtypeItemData(egrp)
                    egrpitem = treemodel.TreeItem(egrpdata)
                    atypes[egrp] = egrpitem
            else:
                eitem = shots.get(e)
                if not eitem:
                    edata = djitemdata.ShotItemData(e)
                    eitem = treemodel.TreeItem(edata)
                    shots[e] = eitem
                egrp = e.sequence
                egrpitem = seqs.get(egrp)
                if not egrpitem:
                    egrpdata = djitemdata.SequenceItemData(egrp)
                    egrpitem = treemodel.TreeItem(egrpdata)
                    seqs[egrp] = egrpitem
            if eitem not in egrpitem.childItems:
                eitem.set_parent(egrpitem)
            prj = egrp.project
            prjitem = prjs.get(prj)
            if not prjitem:
                prjdata = djitemdata.ProjectItemData(prj)
                prjitem = treemodel.TreeItem(prjdata, taskrootitem)
                prjs[prj] = prjitem
                assetdata = treemodel.ListItemData(["Asset"])
                assetitem = treemodel.TreeItem(assetdata, prjitem)
                shotdata = treemodel.ListItemData(["Shot"])
                shotitem = treemodel.TreeItem(shotdata, prjitem)
            else:
                assetitem = prjitem.child(0)
                shotitem = prjitem.child(1)
            if isinstance(egrp, djadapter.models.Atype) and egrpitem not in assetitem.childItems:
                egrpitem.set_parent(assetitem)
            elif isinstance(egrp, djadapter.models.Sequence) and egrpitem not in shotitem.childItems:
                egrpitem.set_parent(shotitem)
            titem.set_parent(eitem)

        self.cur_user = user
399450
def get_user(self, user_id=None):
        
        if user_id:
            return self.get('/users/{0}/'.format(user_id))
        return self.get('/users/me/')
672687
def users_me(self, include=None, **kwargs):
        ""
        api_path = "/api/v2/users/me.json"
        api_query = {}
        if "query" in kwargs.keys():
            api_query.update(kwargs["query"])
            del kwargs["query"]
        if include:
            api_query.update({
                "include": include,
            })
        return self.call(api_path, query=api_query, **kwargs)
28308
def get_user_info(self):
        
        response = self.get_proto(path='/user')
        message = yamcsManagement_pb2.UserInfo()
        message.ParseFromString(response.content)
        return UserInfo(message)
45628
def show_user(self, user):
        """"""

        url = '/users/show/%s.xml' % (user)
        d = defer.Deferred()

        self.__downloadPage(url, txml.Users(lambda u: d.callback(u))) \
            .addErrback(lambda e: d.errback(e))

        return d
538935
def get_user(self, user):
        
        return self.service.get_user(
            user, self.url_prefix, self.auth, self.session, self.session_send_opts)
926007
def set_user(self, user):
        
        self.session['user_id'] = user.key
        self.session['user_data'] = user.clean_value()
        role = self.get_role()
        # TODO: this should be remembered from previous login
        # self.session['role_data'] = default_role.clean_value()
        self.session['role_id'] = role.key
        self.current.role_id = role.key
        self.current.user_id = user.key
        # self.perm_cache = PermissionCache(role.key)
        self.session['permissions'] = role.get_permissions()
943187
def is_admin_user(self):
        
        user = api.user.get_current()
        roles = user.getRoles()
        return "LabManager" in roles or "Manager" in roles
742314
def user_fields(self, user):
        
        return self._query_zendesk(self.endpoint.user_fields, 'user_field', id=user)
244018
def User(self, Username=''):
        
        if not Username:
            Username = self.CurrentUserHandle
        o = User(self, Username)
        o.OnlineStatus # Test if such a user exists.
        return o
1279470
def list_users(self):
        
        lines = output_lines(self.exec_rabbitmqctl_list('users'))
        return [_parse_rabbitmq_user(line) for line in lines]
1198012
def get_user(self, username="~"):
        
        url = self._build_url("users/%s/" % username, _prepend_namespace=False)
        response = self._get(url)
        check_response(response)
        return response