Get the members that you do not have permission to view.

        Returns: List of members hidden based on their permission preferences
506133
def get_hidden_members(self, user=None):
        
        hidden_members = []
        for member in self.members.all():
            show = False
            if member.can_view_eighth:
                show = member.can_view_eighth

            if not show and user and user.is_eighth_admin:
                show = True
            if not show and user and user.is_teacher:
                show = True
            if not show and member == user:
                show = True

            if not show:
                hidden_members.append(member)

        return hidden_members
764113
def listMembers(self, id, headers=None, query_params=None, content_type="application/json"):
        
        uri = self.client.base_url + "/network/"+id+"/member"
        return self.client.get(uri, None, headers, query_params, content_type)
511718
def get_viewable_members_serializer(self, request):
        
        ids = []
        user = request.user
        for member in self.members.all():
            show = False
            if member.can_view_eighth:
                show = member.can_view_eighth

            if not show and user and user.is_eighth_admin:
                show = True
            if not show and user and user.is_teacher:
                show = True
            if not show and member == user:
                show = True

            if show:
                ids.append(member.id)

        return User.objects.filter(id__in=ids)
24337
def members(name, members_list, root=None):
    '''
    
    '''
    cmd = 'chgrpmem -m = {0} {1}'.format(members_list, name)
    retcode = __salt__['cmd.retcode'](cmd, python_shell=False)

    return not retcode
1099841
def get_group_hidden(self):
        
        # Loop through all the elements in the group.
        for element in self.group_list:
            # Handle element that is not hidden or has a form.
            if element.form.view_type != 'none':
                return False
            # Loop through the children to make sure elements aren't hidden.
            for child_element in element.children:
                # Handle child element that is not hidden or has a form.
                if child_element.form.view_type != 'none':
                    return False
        return True
134762
def filter_new_members(cls)
      members = cls.all_local_members.find_all do |m|
        visible?(m) && (m[:new] || new_params?(m))
      end
      members = discard_accessors(members)
      members.sort! {|a, b| a[:name] <=> b[:name] }
    end
515813
def getmembers(self):
        
        return filter(
            lambda m: not m[0].startswith("__") and not inspect.isfunction(m[1]) and not inspect.ismethod(m[1]),
            inspect.getmembers(self.__class__)
        )
275462
private static List<String> getDeniedPermissions(PermissionChecker checker, Source source, String... permissions) {
        List<String> deniedList = new ArrayList<>(1);
        for (String permission : permissions) {
            if (!checker.hasPermission(source.getContext(), permission)) {
                deniedList.add(permission);
            }
        }
        return deniedList;
    }
174856
def get_user_push_restrictions(self):
        
        return github.PaginatedList.PaginatedList(
            github.NamedUser.NamedUser,
            self._requester,
            self.protection_url + "/restrictions/users",
            None
        )
1300449
def unwatch(self, username):

        

        if self.standard_grant_type is not "authorization_code":
            raise DeviantartError("Authentication through Authorization Code (Grant Type) is required in order to connect to this endpoint.")

        response = self._req('/user/friends/unwatch/{}'.format(username))

        return response['success']
537381
def list_users(root=None):
    '''
    
    '''
    if root is not None:
        getspall = functools.partial(_getspall, root=root)
    else:
        getspall = functools.partial(spwd.getspall)

    return sorted([user.sp_namp if hasattr(user, 'sp_namp') else user.sp_nam
                   for user in getspall()])
1211564
def members(self):
        
        if self._members is None:
            self._members = MemberList(
                self._version,
                account_sid=self._solution['account_sid'],
                queue_sid=self._solution['sid'],
            )
        return self._members
26648
def accessibles(self, roles=None):
        
        return [org['slug']
                for org in self.get_accessibles(self.request, roles=roles)]
440501
def get_permissions(cls):
        
        perms = []
        for kls_name, kls in cls.registry.items():
            for method_name in cls.__dict__.keys():
                if method_name.endswith('_view'):
                    perms.append("%s.%s" % (kls_name, method_name))
        return perms
1330154
def revoke_member(context, request):
    """"""

    mapping = request.json['mapping']
    for entry in mapping:
        user = entry['user']
        roles = entry['roles']
        username = user.get('username', None)
        userid = user.get('userid', None)
        if userid:
            u = context.get_user_by_userid(userid)
        elif username:
            u = context.get_user_by_username(username)
        else:
            u = None
        if u is None:
            raise UnprocessableError(
                'User %s does not exists' % (userid or username))
        for rolename in roles:
            context.revoke_member_role(u.userid, rolename)
    return {'status': 'success'}
1284860
def _getmember(self, name, tarinfo=None, normalize=False):
        
        # Ensure that all members have been loaded.
        members = self.getmembers()

        # Limit the member search list up to tarinfo.
        if tarinfo is not None:
            members = members[:members.index(tarinfo)]

        if normalize:
            name = os.path.normpath(name)

        for member in reversed(members):
            if normalize:
                member_name = os.path.normpath(member.name)
            else:
                member_name = member.name

            if name == member_name:
                return member
1068402
def block_view(request):
    
    blocked_ip_list = get_blocked_ips()
    blocked_username_list = get_blocked_usernames()

    context = {'blocked_ip_list': blocked_ip_list,
               'blocked_username_list': blocked_username_list}
    return render(request, 'defender/admin/blocks.html', context)