Invokes the /system/findProjectMembers API method.

    For more info, see: https://wiki.dnanexus.com/API-Specification-v1.0.0/Search#API-method:-/system/findProjectMembers
772609
def system_find_project_members(input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/system/findProjectMembers', input_params, always_retry=always_retry, **kwargs)
416399
function getUserSharedProjects(user) {
		return userProject.findOne({'username': user}, 'sharedProjects')
		.then(function(doc) {
			if (!doc) {
				return undefined;
			}
			var projects = doc.sharedProjects;
			projects = projects.map(function(project) {
				var name = path.win32.basename(project);
				return {'Name': name, 'Location': project};
			});
			return projects;
		});
	}
838531
private Collection<Membership> findMembershipsByUserAndGroup(Session session, Node refUserNode, Node groupNode) throws Exception
   {
      List<Membership> memberships = new ArrayList<Membership>();

      NodeIterator refTypes = refUserNode.getNodes();
      while (refTypes.hasNext())
      {
         Node refTypeNode = refTypes.nextNode();

         String id = utils.composeMembershipId(groupNode, refUserNode, refTypeNode);
         String groupId = utils.getGroupIds(groupNode).groupId;

         MembershipImpl membership = new MembershipImpl();
         membership.setUserName(refUserNode.getName());
         membership.setMembershipType((refTypeNode.getName().equals(JCROrganizationServiceImpl.JOS_MEMBERSHIP_TYPE_ANY)
            ? MembershipTypeHandler.ANY_MEMBERSHIP_TYPE : refTypeNode.getName()));
         membership.setGroupId(groupId);
         membership.setId(id);

         memberships.add(membership);
      }

      return memberships;
   }
147681
public static String getMemberName() throws XDocletException
    {
        if (getCurrentField() != null) {
            return getCurrentField().getName();
        }
        else if (getCurrentMethod() != null) {
            return MethodTagsHandler.getPropertyNameFor(getCurrentMethod());
        }
        else {
            return null;
        }
    }
849149
private Membership findMembershipByUserGroupAndType(Session session, String userName, String groupId, String type)
      throws Exception
   {
      MembershipImpl membership = getFromCache(userName, groupId, type);
      if (membership != null)
      {
         return membership;
      }

      try
      {
         Node groupNode = utils.getGroupNode(session, groupId);

         Node refUserNode = groupNode.getNode(JCROrganizationServiceImpl.JOS_MEMBERSHIP).getNode(userName);
         Node refTypeNode =
            refUserNode.getNode(type.equals(MembershipTypeHandler.ANY_MEMBERSHIP_TYPE)
               ? JCROrganizationServiceImpl.JOS_MEMBERSHIP_TYPE_ANY : type);

         String id = utils.composeMembershipId(groupNode, refUserNode, refTypeNode);

         membership = new MembershipImpl();
         membership.setGroupId(groupId);
         membership.setUserName(userName);
         membership.setMembershipType(type);
         membership.setId(id);

         putInCache(membership);

         return membership;
      }
      catch (PathNotFoundException e)
      {
         return null;
      }
   }
230117
def getmember(self, name):
        '''
        
        '''
        members = self.getmembers()
        for m in members[::-1]:
            if m.name == name:
                return m

        raise KeyError("member %s could not be found" % name)
29702
Neighbour[] getMembers()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(tc, "getMembers");
      SibTr.exit(tc, "getMembers");
    }

    return iNeighbours;
  }
238311
def _get_users_from_project(self, project_id, roles, project_users):
        

        # For keystone.user_list project_id is not passed as argument because
        # it is ignored when using admin credentials
        # Get all users (to be able to find user name)
        users = api.keystone.user_list(self.request)
        users = {user.id: user for user in users}

        # Get project_users_roles ({user_id: [role_id_1, role_id_2]})
        project_users_roles = api.keystone.get_project_users_roles(
            self.request,
            project=project_id)

        for user_id in project_users_roles:

            if user_id not in project_users:
                # Add user to the project_users
                project_users[user_id] = users[user_id]
                project_users[user_id].roles = []
                project_users[user_id].roles_from_groups = []

            # Update the project_user role in order to get:
            # project_users[user_id].roles = [role_name1, role_name2]
            self._update_user_roles_names_from_roles_id(
                user=project_users[user_id],
                users_roles=project_users_roles[user_id],
                roles_list=roles
            )
591888
protected Member findMemberIn (List<Member> memberList, Class<?>[] parameterTypes)
        throws NoSuchMethodException
    {
        List<Member> matchingMembers = new ArrayList<Member>();

        for (Iterator<Member> it = memberList.iterator(); it.hasNext();) {
            Member member = it.next();
            Class<?>[] methodParamTypes = _paramMap.get(member);

            // check for exactly equal method signature
            if (Arrays.equals(methodParamTypes, parameterTypes)) {
                return member;
            }

            if (ClassUtil.compatibleClasses(methodParamTypes, parameterTypes)) {
                matchingMembers.add(member);
            }
        }

        if (matchingMembers.isEmpty()) {
            throw new NoSuchMethodException(
                "No member in " + _clazz.getName() + " matching given args");
        }
        if (matchingMembers.size() == 1) {
            return matchingMembers.get(0);
        }

        return findMostSpecificMemberIn(matchingMembers);
    }
900213
@Override
    public Object getMember(String name) {
        switch (name) {
            case "toDF":
                return F_toDF;
            case "schema":
                return F_schema;
            case "printSchema":
                return F_printSchema;
            case "explain":
                return F_explain;
            case "dtypes":
                return F_dtypes;
            case "columns":
                return F_columns;
            case "isLocal":
                return F_isLocal;
            case "isStreaming":
                return F_isStreaming;
            case "show":
                return F_show;
            case "na":
                return F_na;
            case "stat":
                return F_stat;
            case "join":
                return F_join;
            case "joinWith":
                return F_joinWith;
            case "sortWithinPartitions":
                return F_sortWithinPartitions;
            case "sort":
                return F_sort;
            case "orderBy":
                return F_orderBy;
            case "apply":
                return F_apply;
            case "col":
                return F_col;
            case "as":
                return F_as;
            case "alias":
                return F_alias;
            case "select":
                return F_select;
            case "selectExpr":
                return F_selectExpr;
            case "filter":
            case "filterWithColumn":
                return F_filter;
            case "where":
                return F_where;
            case "groupBy":
                return F_groupBy;
            case "rollup":
                return F_rollup;
            case "cube":
                return F_cube;
            case "reduce":
                return F_reduce;
            case "groupByKey":
                return F_groupByKey;
            case "agg":
                return F_agg;
            case "limit":
                return F_limit;
            case "unionAll":
                return F_unionAll;
            case "union":
                return F_union;
            case "intersect":
                return F_intersect;
            case "except":
                return F_except;
            case "sample":
                return F_sample;
            case "randomSplit":
                return F_randomSplit;
//            case "explode":
//                return F_explode;
            case "withColumn":
                return F_withColumn;
            case "withColumnRenamed":
                return F_withColumnRenamed;
            case "drop":
                return F_drop;
            case "dropDuplicates":
                return F_dropDuplicates;
            case "describe":
                return F_describe;
            case "head":
                return F_head;
            case "first":
                return F_first;
//            case "transform":
//                return F_transform;
            case "map":
                return F_map;
            case "mapPartitions":
                return F_mapPartitions;
            case "flatMap":
                return F_flatMap;
            case "foreach":
                return F_foreach;
            case "foreachPartition":
                return F_foreachPartition;
            case "take":
                return F_take;
            case "collect":
                return F_collect;
//            case "toLocalIterator":
//                return F_toLocalIterator;
            case "count":
                return F_count;
            case "repartition":
                return F_repartition;
            case "coalesce":
                return F_coalesce;
            case "distinct":
                return F_distinct;
            case "cache":
                return F_cache;
            case "persist":
                return F_persist;
            case "unpersist":
                return F_unpersist;
            case "toRDD":
                return F_toRDD;
            case "rdd":
                return F_rdd;
            case "registerTempTable":
                return F_registerTempTable;
            case "createTempView":
                return F_createTempView;
            case "createOrReplaceTempView":
                return F_createOrReplaceTempView;
            case "write":
                return F_write;
            case "writeStream":
                return F_writeStream;
            case "toJSON":
                return F_toJSON;
            case "inputFiles":
                return F_inputFiles;
            case "queryExecution":
                return F_queryExecution;
            case "sqlContext":
                return F_sqlContext;
            case "sparkSession":
                return F_sparkSession;

        }
        return super.getMember(name);
    }
47758
private Collection<Membership> findMembershipsByGroup(Session session, Group group) throws Exception
   {
      Node groupNode;
      NodeIterator refUsers;
      try
      {
         groupNode = utils.getGroupNode(session, group);
         refUsers = groupNode.getNode(JCROrganizationServiceImpl.JOS_MEMBERSHIP).getNodes();
      }
      catch (PathNotFoundException e)
      {
         return new ArrayList<Membership>();
      }

      List<Membership> memberships = new ArrayList<Membership>();
      while (refUsers.hasNext())
      {
         Node refUserNode = refUsers.nextNode();
         memberships.addAll(findMembershipsByUserAndGroup(session, refUserNode, groupNode));
      }

      return memberships;
   }
1365608
def list_group_members(self, name):
        
        self.project_service.set_auth(self._token_project)
        return self.project_service.list_group_members(name)
1224963
public Set<Member> getMethodUsage(Method method) {
        return getMembersFromDescriptors(store.get(index(MemberUsageScanner.class), name(method)));
    }
1172298
def addprojectmember(self, project_id, user_id, access_level):
        
        # if isinstance(access_level, basestring):
        if access_level.lower() == 'master':
            access_level = 40
        elif access_level.lower() == 'developer':
            access_level = 30
        elif access_level.lower() == 'reporter':
            access_level = 20
        else:
            access_level = 10

        data = {'id': project_id, 'user_id': user_id, 'access_level': access_level}

        request = requests.post(
            '{0}/{1}/members'.format(self.projects_url, project_id),
            headers=self.headers, data=data, verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        if request.status_code == 201:
            return True
        else:
            return False
107800
def read_members(self, container_id, query_membership=None):
        
        route_values = {}
        if container_id is not None:
            route_values['containerId'] = self._serialize.url('container_id', container_id, 'str')
        query_parameters = {}
        if query_membership is not None:
            query_parameters['queryMembership'] = self._serialize.query('query_membership', query_membership, 'str')
        response = self._send(http_method='GET',
                              location_id='8ba35978-138e-41f8-8963-7b1ea2c5f775',
                              version='5.0-preview.1',
                              route_values=route_values,
                              query_parameters=query_parameters)
        return self._deserialize('[str]', self._unwrap_collection(response))
52680
private CompletableFuture<Collection<Permission>> findPermissions0(String projectName, String repoName,
                                                                       User user) {
        requireNonNull(projectName, "projectName");
        requireNonNull(repoName, "repoName");
        requireNonNull(user, "user");

        return getProject(projectName).thenApply(metadata -> {
            final RepositoryMetadata repositoryMetadata = metadata.repo(repoName);
            final Member member = metadata.memberOrDefault(user.id(), null);

            // If the member is guest.
            if (member == null) {
                return repositoryMetadata.perRolePermissions().guest();
            }
            final Collection<Permission> p = repositoryMetadata.perUserPermissions().get(member.id());
            if (p != null) {
                return p;
            }
            return findPerRolePermissions(repositoryMetadata, member.role());
        });
    }
668370
@Override
    public Object getMember(String name) {
        switch (name) {
            case "version":
                return F_version;
            case "sparkContext":
                return F_sparkContext;
            case "sqlContext":
                return F_sqlContext;
//            case "listenerManager":
//                return F_listenerManager;
//            case "experimental":
//                return F_experimental;
            case "udf":
                return F_udf;
            case "streams":
                return F_streams;
            case "newSession":
                return F_newSession;
//            case "emptyDataset":
//                return F_emptyDataset;
            case "createDataFrame":
                return F_createDataFrame;
            case "createDataFrameFromJson":
                return F_createDataFrameFromJson;
            case "baseRelationToDataFrame":
                return F_baseRelationToDataFrame;
            case "createDataset":
                return F_createDataset;
            case "createDatasetFromJson":
                return F_createDatasetFromJson;
            case "range":
                return F_range;
            case "table":
                return F_table;
            case "sql":
                return F_sql;
            case "read":
                return F_read;
            case "readStream":
                return F_readStream;
            case "stop":
                return F_stop;
        }
        return super.getMember(name);
    }