Returns the active members of the given space.

@param spaceId
The id of the space
@return The active members of the space
761121
public List<SpaceMember> getActiveMembers(int spaceId) {
		return getResourceFactory().getApiResource(
				"/space/" + spaceId + "/member/").get(
				new GenericType<List<SpaceMember>>() {
				});
	}
34701
def get_all_page_ids_from_space(confluence, space_key):
    
    limit = 500
    flag = True
    step = 0
    page_ids = []

    while flag:
        values = confluence.get_all_pages_from_space(space=space_key, start=limit * step, limit=limit)
        step += 1
        if len(values) == 0:
            flag = False
            print("Did not find any pages, please, check permissions")
        else:
            for value in values:
                print("Retrieve page with title: " + value['title'])
                page_ids.append((value['id']))
    print("Found in space {} pages {}".format(space_key, len(page_ids)))
    return page_ids
607396
public OrganizationMember getMemberByMail(int orgId, String mail) {
		return getResourceFactory().getApiResource(
				"/org/" + orgId + "/member/mail/" + mail).get(
				OrganizationMember.class);
	}
897785
public static String getSpaces( int SpacesCount ) {
		//
		if ( SpacesCount < 0 ) return "?";
		//
		String Info = "";
		//
		for ( int K = 1; K <= SpacesCount; K ++ ) {
			Info += " ";
		}
		//
		//
		return Info;
	}
767114
function getPeerByRTCId(id)
    {
        for(var num = 0; num < scope._servConn.roomUsers.length; num++)
        {
            if(scope._servConn.roomUsers[num].rtcId == id)
            {
                return scope._servConn.roomUsers[num];
            }
        }
        return null;
    }
754969
protected void addSnapshotIdToSpaceProps(String spaceId, String snapshotId) {
        Map<String, String> spaceProps =
            snapshotProvider.getSpaceProperties(spaceId);
        spaceProps.put(Constants.SNAPSHOT_ID_PROP, snapshotId);
        unwrappedSnapshotProvider.setNewSpaceProperties(spaceId, spaceProps);
    }
1181858
public MemberListResult getCrossGroupMembers(long gid)
            throws APIConnectionException, APIRequestException {
        Preconditions.checkArgument(0 != gid, "gid must not be empty");
        ResponseWrapper response = _httpClient.sendGet(_baseUrl + crossGroupPath + "/" + gid + "/members/");
        return MemberListResult.fromResponse(response);
    }
479867
protected final int getNextNamespaceNode2(int baseID) {
        int type;
        while ((type = _type2(++baseID)) == DTM.ATTRIBUTE_NODE);

        if (type == DTM.NAMESPACE_NODE)
            return baseID;
        else
            return NULL;
    }
1338371
public List<String> getMembers() {
    List<String> allList = new ArrayList<String>();
    allList.addAll(members);

    return Collections.unmodifiableList(allList);
  }
586394
@HEAD
    public Response getContentProperties(@PathParam("spaceID") String spaceID,
                                         @PathParam("contentID") String contentID,
                                         @QueryParam("storeID") String storeID) {
        StringBuilder msg = new StringBuilder("getting content properties(");
        msg.append(spaceID);
        msg.append(", ");
        msg.append(contentID);
        msg.append(", ");
        msg.append(storeID);
        msg.append(")");

        try {
            Map<String, String> properties =
                contentResource.getContentProperties(spaceID, contentID, storeID);

            log.debug(msg.toString());
            return addContentPropertiesToResponse(Response.ok(), properties);

        } catch (ResourceNotFoundException e) {
            return responseNotFound(msg.toString(), e, NOT_FOUND);

        } catch (ResourceException e) {
            return responseBad(msg.toString(), e, INTERNAL_SERVER_ERROR);

        } catch (Exception e) {
            return responseBad(msg.toString(), e, INTERNAL_SERVER_ERROR);
        }
    }
768941
@Override
    public void createSpace(String spaceId) {
        target.createSpace(spaceId);

        String action = AuditTask.ActionType.CREATE_SPACE.name();
        submitWriteTask(action, spaceId, AuditTask.NA, AuditTask.NA,
                        AuditTask.NA, AuditTask.NA, null, null, AuditTask.NA,
                        AuditTask.NA);
    }
450679
public String[] getUserIDs(String globusID) {
        if (globusID == null) {
            throw new IllegalArgumentException(i18n
                                               .getMessage("globusIdNull"));
        }

        if (this.map == null) {
            return null;
        }

        GridMapEntry entry = (GridMapEntry)this.map.get(normalizeDN(globusID));
        return (entry == null) ? null : entry.getUserIDs();
    }
298345
protected String getSpaceId(String bucketName) {
        String spaceId = bucketName;
        if (isSpace(bucketName)) {
            spaceId = spaceId.substring(accessKeyId.length() + 1);
        }
        return spaceId;
    }
825738
private boolean spaceExists(final StorageProvider store,
                                final String spaceId)
        throws TaskExecutionFailedException {
        try {
            return new Retrier().execute(new Retriable() {
                @Override
                public Boolean retry() throws Exception {
                    // The actual method being executed
                    store.getSpaceProperties(spaceId);
                    return true;
                }
            });
        } catch (NotFoundException nfe) {
            return false;
        } catch (Exception e) {
            String msg = "Error attempting to check if space exists: " +
                         e.getMessage();
            throw new DuplicationTaskExecutionFailedException(
                buildFailureMessage(msg), e);
        }
    }
601397
public Integer delete(String spaceId) {
    assertNotNull(spaceId, "spaceId");
    return service.delete(spaceId).blockingFirst().code();
  }
1049854
public InetAddress activeNodeForId(final String id) {
        BucketConfig config = bucketConfig.get();

        if (config instanceof CouchbaseBucketConfig) {
            return nodeForIdOnCouchbaseBucket(id, (CouchbaseBucketConfig) config);
        } else if (config instanceof MemcachedBucketConfig) {
            return nodeForIdOnMemcachedBucket(id, (MemcachedBucketConfig) config);
        } else {
            throw new UnsupportedOperationException("Bucket type not supported: " + config.getClass().getName());
        }
    }
881617
@Provides
    @Named(JanusConfig.DEFAULT_SPACE_ID_NAME)
    public static UUID getSpaceID() {
        final String v = JanusConfig.getSystemProperty(JanusConfig.DEFAULT_SPACE_ID_NAME, JanusConfig.DEFAULT_SPACE_ID_VALUE);
        return UUID.fromString(v);
    }