Java tutorial
/* * Copyright 2014-2016 CyberVision, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.kaaproject.kaa.server.common.nosql.cassandra.dao; import static com.datastax.driver.core.querybuilder.QueryBuilder.delete; import static com.datastax.driver.core.querybuilder.QueryBuilder.eq; import static com.datastax.driver.core.querybuilder.QueryBuilder.in; import static com.datastax.driver.core.querybuilder.QueryBuilder.select; import static com.datastax.driver.core.querybuilder.QueryBuilder.set; import static org.kaaproject.kaa.server.common.dao.impl.DaoUtil.getDto; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.CassandraDaoUtil.convertKeyHashToString; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.CassandraDaoUtil.convertStringToKeyHash; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.CassandraDaoUtil.getByteBuffer; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.CassandraDaoUtil.getBytes; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_APP_ID_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_BY_APP_ID_APPLICATION_ID_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_BY_APP_ID_COLUMN_FAMILY_NAME; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_BY_APP_ID_ENDPOINT_KEY_HASH_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_BY_ENDPOINT_GROUP_ID_COLUMN_FAMILY_NAME; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_BY_ENDPOINT_GROUP_ID_ENDPOINT_GROUP_ID_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_BY_ENDPOINT_GROUP_ID_ENDPOINT_KEY_HASH_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_BY_SDK_TOKEN_COLUMN_FAMILY_NAME; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_BY_SDK_TOKEN_SDK_TOKEN_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_COLUMN_FAMILY_NAME; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_ENDPOINT_ID_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_EP_KEY_HASH_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_PROFILE_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_PROFILE_VERSION_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_SERVER_PROFILE_PROPERTY; import static org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraModelConstants.EP_SERVER_PROFILE_VERSION_PROPERTY; import com.google.common.base.Predicates; import com.google.common.collect.Sets; import com.datastax.driver.core.ConsistencyLevel; import com.datastax.driver.core.ResultSet; import com.datastax.driver.core.Row; import com.datastax.driver.core.Statement; import com.datastax.driver.core.querybuilder.QueryBuilder; import org.apache.commons.codec.binary.Base64; import org.kaaproject.kaa.common.dto.EndpointProfileBodyDto; import org.kaaproject.kaa.common.dto.EndpointProfileDto; import org.kaaproject.kaa.common.dto.EndpointProfilesBodyDto; import org.kaaproject.kaa.common.dto.EndpointProfilesPageDto; import org.kaaproject.kaa.common.dto.PageLinkDto; import org.kaaproject.kaa.server.common.dao.DaoConstants; import org.kaaproject.kaa.server.common.dao.exception.DatabaseProcessingException; import org.kaaproject.kaa.server.common.dao.exception.KaaOptimisticLockingFailureException; import org.kaaproject.kaa.server.common.dao.impl.EndpointProfileDao; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.filter.CassandraEpByAccessTokenDao; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.filter.CassandraEpByAppIdDao; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.filter.CassandraEpByEndpointGroupIdDao; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.filter.CassandraEpBySdkTokenDao; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraEndpointProfile; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraEndpointUser; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraEpByAccessToken; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraEpByAppId; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraEpByEndpointGroupId; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.CassandraEpBySdkToken; import org.kaaproject.kaa.server.common.nosql.cassandra.dao.model.type.CassandraEndpointGroupState; import org.kaaproject.kaa.server.common.utils.Utils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Repository; import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Set; @Repository(value = "endpointProfileDao") public class EndpointProfileCassandraDao extends AbstractVersionableCassandraDao<CassandraEndpointProfile, ByteBuffer> implements EndpointProfileDao<CassandraEndpointProfile> { private static final Logger LOG = LoggerFactory.getLogger(EndpointProfileCassandraDao.class); @Autowired private CassandraEpByAppIdDao cassandraEpByAppIdDao; @Autowired private CassandraEpByAccessTokenDao cassandraEpByAccessTokenDao; @Autowired private CassandraEpBySdkTokenDao cassandraEpBySdkTokenDao; @Autowired private CassandraEpByEndpointGroupIdDao cassandraEpByEndpointGroupIdDao; private EndpointUserCassandraDao endpointUserDao; @Override protected Class<CassandraEndpointProfile> getColumnFamilyClass() { return CassandraEndpointProfile.class; } @Override protected String getColumnFamilyName() { return EP_COLUMN_FAMILY_NAME; } @Override public CassandraEndpointProfile save(EndpointProfileDto dto) { CassandraEndpointProfile endpointProfile = new CassandraEndpointProfile(dto); return save(endpointProfile); } @Override public CassandraEndpointProfile save(CassandraEndpointProfile object) { if (object.getVersion() == null) { return saveProfile(object); } else { return updateProfile(object); } } private CassandraEndpointProfile saveProfile(CassandraEndpointProfile profile) { profile.setId(convertKeyHashToString(profile.getEndpointKeyHash())); LOG.debug("Saving endpoint profile with id {}", profile.getId()); profile = super.save(profile); ByteBuffer epKeyHash = profile.getEndpointKeyHash(); List<Statement> statementList = new ArrayList<>(); statementList.add( cassandraEpByAppIdDao.getSaveQuery(new CassandraEpByAppId(profile.getApplicationId(), epKeyHash))); String accessToken = profile.getAccessToken(); if (accessToken != null) { statementList.add( cassandraEpByAccessTokenDao.getSaveQuery(new CassandraEpByAccessToken(accessToken, epKeyHash))); } statementList.add(getSaveQuery(profile)); Statement saveBySdkTokenId = cassandraEpBySdkTokenDao .getSaveQuery(new CassandraEpBySdkToken(profile.getSdkToken(), epKeyHash)); statementList.add(saveBySdkTokenId); Set<String> groupIdSet = getEndpointProfilesGroupIdSet(profile); for (String groupId : groupIdSet) { statementList.add(cassandraEpByEndpointGroupIdDao .getSaveQuery(new CassandraEpByEndpointGroupId(groupId, epKeyHash))); } executeBatch(statementList.toArray(new Statement[statementList.size()])); LOG.debug("[{}] Endpoint profile saved", profile.getId()); return profile; } private CassandraEndpointProfile updateProfile(CassandraEndpointProfile profile) { LOG.debug("Updating endpoint profile with id {}", profile.getId()); ByteBuffer epKeyHash = profile.getEndpointKeyHash(); byte[] keyHash = getBytes(epKeyHash); CassandraEndpointProfile storedProfile = findByKeyHash(keyHash); if (storedProfile != null) { profile = super.save(profile); List<Statement> statementList = new ArrayList<>(); Set<String> oldEndpointGroupIds = getEndpointProfilesGroupIdSet(storedProfile); Set<String> newEndpointGroupIds = getEndpointProfilesGroupIdSet(profile); Set<String> removeEndpointGroupIds = Sets.filter(oldEndpointGroupIds, Predicates.not(Predicates.in(newEndpointGroupIds))); Set<String> addEndpointGroupIds = Sets.filter(newEndpointGroupIds, Predicates.not(Predicates.in(oldEndpointGroupIds))); if (addEndpointGroupIds != null) { for (String id : addEndpointGroupIds) { statementList.add(cassandraEpByEndpointGroupIdDao .getSaveQuery(new CassandraEpByEndpointGroupId(id, epKeyHash))); } if (removeEndpointGroupIds != null) { for (String id : removeEndpointGroupIds) { statementList.add(delete().from(EP_BY_ENDPOINT_GROUP_ID_COLUMN_FAMILY_NAME) .where(eq(EP_BY_ENDPOINT_GROUP_ID_ENDPOINT_GROUP_ID_PROPERTY, id)) .and(eq(EP_BY_ENDPOINT_GROUP_ID_ENDPOINT_KEY_HASH_PROPERTY, epKeyHash))); } } executeBatch(statementList.toArray(new Statement[statementList.size()])); } else { LOG.error("[{}] Can't update endpoint profile with version {}. " + "Endpoint profile already changed!", profile.getId(), profile.getVersion()); throw new KaaOptimisticLockingFailureException( "Can't update endpoint profile with" + " version . Endpoint profile already changed!"); } String accessToken = profile.getAccessToken(); if (storedProfile.getAccessToken() != null && !storedProfile.getAccessToken().equals(accessToken)) { cassandraEpByAccessTokenDao.removeById(storedProfile.getAccessToken()); } if (accessToken != null) { statementList.add(cassandraEpByAccessTokenDao .getSaveQuery(new CassandraEpByAccessToken(accessToken, epKeyHash))); } executeBatch(statementList.toArray(new Statement[statementList.size()])); LOG.debug("[{}] Endpoint profile updated", profile.getId()); } else { LOG.error("[{}] Stored profile is null. Can't update endpoint profile.", profile.getId()); throw new DatabaseProcessingException("Stored profile is null. " + "Can't update endpoint profile."); } return profile; } @Override public CassandraEndpointProfile findByKeyHash(byte[] endpointKeyHash) { LOG.debug("Try to find endpoint profile by key hash [{}]", Utils.encodeHexString(endpointKeyHash)); CassandraEndpointProfile endpointProfile = getMapper().get(getByteBuffer(endpointKeyHash)); LOG.debug("[{}] Found endpoint profile {}", Utils.encodeHexString(endpointKeyHash), endpointProfile); return endpointProfile; } @Override public EndpointProfileBodyDto findBodyByKeyHash(byte[] endpointKeyHash) { LOG.debug("Try to find endpoint profile body by key hash [{}]", Utils.encodeHexString(endpointKeyHash)); String profile = null; String serverSideProfile = null; String appId = null; int clientSideProfileVersion = 0; int serverSideProfileVersion = 0; ResultSet resultSet = execute(select(EP_PROFILE_PROPERTY, EP_SERVER_PROFILE_PROPERTY, EP_APP_ID_PROPERTY, EP_PROFILE_VERSION_PROPERTY, EP_SERVER_PROFILE_VERSION_PROPERTY).from(getColumnFamilyName()) .where(eq(EP_EP_KEY_HASH_PROPERTY, getByteBuffer(endpointKeyHash)))); Row row = resultSet.one(); if (row != null) { profile = row.getString(EP_PROFILE_PROPERTY); appId = row.getString(EP_APP_ID_PROPERTY); serverSideProfile = row.getString(EP_SERVER_PROFILE_PROPERTY); clientSideProfileVersion = row.getInt(EP_PROFILE_VERSION_PROPERTY); serverSideProfileVersion = row.getInt(EP_SERVER_PROFILE_VERSION_PROPERTY); } LOG.debug( "[{}] Found client-side endpoint profile body {} " + "with client-side endpoint profile version {} " + "and server-side endpoint profile body {} " + "with server-side endpoint profile version {} and application id {}", Utils.encodeHexString(endpointKeyHash), profile, clientSideProfileVersion, serverSideProfile, serverSideProfileVersion, appId); return new EndpointProfileBodyDto(endpointKeyHash, profile, serverSideProfile, clientSideProfileVersion, serverSideProfileVersion, appId); } @Override public CassandraEndpointProfile findEndpointIdByKeyHash(byte[] endpointKeyHash) { LOG.debug("Try to check if endpoint profile exists with key hash [{}]", Utils.encodeHexString(endpointKeyHash)); CassandraEndpointProfile profile = null; ResultSet resultSet = execute(select(EP_ENDPOINT_ID_PROPERTY).from(getColumnFamilyName()) .where(eq(EP_EP_KEY_HASH_PROPERTY, getByteBuffer(endpointKeyHash)))); Row row = resultSet.one(); if (row != null) { profile = new CassandraEndpointProfile(); profile.setId(row.getString(EP_ENDPOINT_ID_PROPERTY)); } LOG.debug("{} endpoint profile exists with key hash [{}]", Utils.encodeHexString(endpointKeyHash), profile); return profile; } private void removeByKeyHashFromEpByEndpointGroupId(byte[] endpointKeyHash) { CassandraEndpointProfile storedProfile = findByKeyHash(endpointKeyHash); List<CassandraEndpointGroupState> cfGroupState = new ArrayList<>(); List<String> endpointGroupIds = new ArrayList<>(); List<Statement> statementList = new ArrayList<>(); if (storedProfile.getGroupStates() != null) { cfGroupState.addAll(storedProfile.getGroupStates()); } if (cfGroupState != null) { for (CassandraEndpointGroupState cf : cfGroupState) { endpointGroupIds.add(cf.getEndpointGroupId()); } } if (endpointGroupIds != null) { for (String id : endpointGroupIds) { statementList.add(delete().from(EP_BY_ENDPOINT_GROUP_ID_COLUMN_FAMILY_NAME) .where(eq(EP_BY_ENDPOINT_GROUP_ID_ENDPOINT_GROUP_ID_PROPERTY, id)) .and(eq(EP_BY_ENDPOINT_GROUP_ID_ENDPOINT_KEY_HASH_PROPERTY, getByteBuffer(endpointKeyHash)))); } } Statement[] st = new Statement[statementList.size()]; statementList.toArray(st); executeBatch(st); } @Override public void removeByKeyHash(byte[] endpointKeyHash) { LOG.debug("Remove endpoint profile by key hash [{}]", Utils.encodeHexString(endpointKeyHash)); CassandraEndpointProfile storedProfile = findByKeyHash(endpointKeyHash); removeByKeyHashFromEpByEndpointGroupId(endpointKeyHash); String appId = storedProfile.getApplicationId(); if (!appId.isEmpty()) { Statement deleteEp = delete().from(EP_BY_APP_ID_COLUMN_FAMILY_NAME) .where(eq(EP_BY_APP_ID_APPLICATION_ID_PROPERTY, appId)) .and(eq(EP_BY_APP_ID_ENDPOINT_KEY_HASH_PROPERTY, getByteBuffer(endpointKeyHash))); executeBatch(deleteEp); } getMapper().delete(getByteBuffer(endpointKeyHash)); } @Override public void removeByAppId(String appId) { LOG.debug("Remove endpoint profile by application id [{}]", appId); Statement deleteEps = delete().from(getColumnFamilyName()) .where(in(EP_EP_KEY_HASH_PROPERTY, cassandraEpByAppIdDao.getEpIdsListByAppId(appId))); ByteBuffer[] epKeyHashList = cassandraEpByAppIdDao.getEpIdsListByAppId(appId); if (epKeyHashList != null) { for (ByteBuffer epKeyHash : epKeyHashList) { removeByKeyHashFromEpByEndpointGroupId(getBytes(epKeyHash)); } } Statement deleteEpsByAppId = delete().from(EP_BY_APP_ID_COLUMN_FAMILY_NAME) .where(eq(EP_BY_APP_ID_APPLICATION_ID_PROPERTY, appId)); executeBatch(deleteEps, deleteEpsByAppId); LOG.trace("Execute statements {}, {} like batch", deleteEps, deleteEpsByAppId); } @Override public CassandraEndpointProfile findByAccessToken(String endpointAccessToken) { LOG.debug("Try to find endpoint profile by access token id [{}]", endpointAccessToken); CassandraEndpointProfile endpointProfile = null; ByteBuffer epKeyHash = cassandraEpByAccessTokenDao.findEpIdByAccessToken(endpointAccessToken); if (epKeyHash != null) { endpointProfile = (CassandraEndpointProfile) getMapper().get(epKeyHash); } LOG.trace("Found endpoint profile {} by access token [{}]", endpointProfile, endpointAccessToken); return endpointProfile; } private List<EndpointProfileDto> findEndpointProfilesList(ByteBuffer[] keyHashList, String endpointGroupId) { List<EndpointProfileDto> cassandraEndpointProfileList = new ArrayList<>(); LOG.debug("Found {} endpoint profiles by group id {}", keyHashList != null ? keyHashList.length : 0, endpointGroupId); for (ByteBuffer keyHash : keyHashList) { CassandraEndpointProfile profile = findByKeyHash(getBytes(keyHash)); if (profile != null) { cassandraEndpointProfileList.add(getDto(profile)); } else { LOG.debug("Can't find endpoint profile by id {}", Utils.encodeHexString(keyHash)); } } return cassandraEndpointProfileList; } private List<EndpointProfileBodyDto> findEndpointProfilesBodyList(ByteBuffer[] keyHashList, String endpointGroupId) { final List<EndpointProfileBodyDto> endpointProfilesBodyDto = new ArrayList<>(); LOG.debug("Found {} endpoint profiles body by group id {}", keyHashList != null ? keyHashList.length : 0, endpointGroupId); for (ByteBuffer keyHash : keyHashList) { EndpointProfileBodyDto endpointProfileBodyDto = findBodyByKeyHash(getBytes(keyHash)); if (endpointProfileBodyDto != null) { endpointProfilesBodyDto.add(endpointProfileBodyDto); } else { LOG.debug("Can't find endpoint profile by id {}", Utils.encodeHexString(keyHash)); } } return endpointProfilesBodyDto; } @Override public EndpointProfilesPageDto findByEndpointGroupId(PageLinkDto pageLink) { LOG.debug("Try to find endpoint profile by endpoint group id [{}]", pageLink.getEndpointGroupId()); EndpointProfilesPageDto endpointProfilesPageDto; List<EndpointProfileDto> cassandraEndpointProfileList; ByteBuffer[] keyHashList; if (pageLink.getApplicationId() != null) { keyHashList = cassandraEpByAppIdDao.findEpByAppId(pageLink, pageLink.getApplicationId()); } else { keyHashList = cassandraEpByEndpointGroupIdDao.findEpByEndpointGroupId(pageLink); } cassandraEndpointProfileList = findEndpointProfilesList(keyHashList, pageLink.getEndpointGroupId()); endpointProfilesPageDto = createNextPage(cassandraEndpointProfileList, pageLink.getEndpointGroupId(), pageLink.getLimit()); return endpointProfilesPageDto; } @Override public EndpointProfilesBodyDto findBodyByEndpointGroupId(PageLinkDto pageLink) { LOG.debug("Try to find endpoint profile body by endpoint group id [{}]", pageLink.getEndpointGroupId()); List<EndpointProfileBodyDto> profilesBodyDto; ByteBuffer[] keyHashList; if (pageLink.getApplicationId() != null) { keyHashList = cassandraEpByAppIdDao.findEpByAppId(pageLink, pageLink.getApplicationId()); } else { keyHashList = cassandraEpByEndpointGroupIdDao.findEpByEndpointGroupId(pageLink); } profilesBodyDto = findEndpointProfilesBodyList(keyHashList, pageLink.getEndpointGroupId()); if (profilesBodyDto == null) { profilesBodyDto = Collections.emptyList(); } EndpointProfilesBodyDto endpointProfilesBodyDto = createNextBodyPage(profilesBodyDto, pageLink.getEndpointGroupId(), pageLink.getLimit()); return endpointProfilesBodyDto; } @Override public List<CassandraEndpointProfile> findByEndpointUserId(String endpointUserId) { LOG.debug("Try to find endpoint profiles by endpoint user id [{}]", endpointUserId); List<CassandraEndpointProfile> profileList = Collections.emptyList(); CassandraEndpointUser endpointUser = endpointUserDao.findById(endpointUserId); if (endpointUser != null) { List<String> ids = endpointUser.getEndpointIds(); if (ids != null && !ids.isEmpty()) { Statement select = select().from(getColumnFamilyName()) .where(in(EP_EP_KEY_HASH_PROPERTY, convertStringIds(ids))); LOG.trace("Execute statements {}", select); profileList = findListByStatement(select); } } if (LOG.isTraceEnabled()) { LOG.trace("Found endpoint profiles {}", Arrays.toString(profileList.toArray())); } return profileList; } @Override public CassandraEndpointProfile findById(ByteBuffer key) { LOG.debug("Try to find endpoint profiles by key [{}]", Utils.encodeHexString(key)); CassandraEndpointProfile profile = null; if (key != null) { profile = findByKeyHash(key.array()); } LOG.trace("Found endpoint profiles {}", profile); return profile; } @Override public void removeById(ByteBuffer key) { LOG.debug("Remove endpoint profiles by key [{}]", Utils.encodeHexString(key)); if (key != null) { removeByKeyHash(key.array()); } } @Override public boolean checkSdkToken(String sdkToken) { LOG.debug("Checking for endpoint profiles with SDK token {}", sdkToken); Statement query = select().from(EP_BY_SDK_TOKEN_COLUMN_FAMILY_NAME) .where(eq(EP_BY_SDK_TOKEN_SDK_TOKEN_PROPERTY, sdkToken)); return execute(query).one() != null; } @Override public CassandraEndpointProfile updateServerProfile(byte[] keyHash, int version, String serverProfile) { LOG.debug("Updating server profile for endpoint profile with key hash [{}] " + "with schema version [{}]", Utils.encodeHexString(keyHash), version); ByteBuffer key = ByteBuffer.wrap(keyHash); Statement update = QueryBuilder.update(EP_COLUMN_FAMILY_NAME) .with(set(EP_SERVER_PROFILE_PROPERTY, serverProfile)) .and(set(EP_SERVER_PROFILE_VERSION_PROPERTY, version)).where(eq(EP_EP_KEY_HASH_PROPERTY, key)); execute(update, ConsistencyLevel.ALL); return findById(key); } private Set<String> getEndpointProfilesGroupIdSet(CassandraEndpointProfile profile) { Set<String> groupIdSet = new HashSet<>(); List<CassandraEndpointGroupState> groupStateSet = new LinkedList<>(); if (profile != null) { List<CassandraEndpointGroupState> cfGroupState = profile.getGroupStates(); if (cfGroupState != null && !cfGroupState.isEmpty()) { groupStateSet.addAll(cfGroupState); } for (CassandraEndpointGroupState cf : groupStateSet) { groupIdSet.add(cf.getEndpointGroupId()); } } return groupIdSet; } private ByteBuffer[] convertStringIds(List<String> ids) { ByteBuffer[] keyHashArray = new ByteBuffer[ids.size()]; for (int i = 0; i < ids.size(); i++) { keyHashArray[i] = convertStringToKeyHash(ids.get(i)); } return keyHashArray; } private EndpointProfilesPageDto createNextPage(List<EndpointProfileDto> cassandraEndpointProfileList, String endpointGroupId, String limit) { EndpointProfilesPageDto endpointProfilesPageDto = new EndpointProfilesPageDto(); PageLinkDto pageLinkDto = new PageLinkDto(); String next; int lim = Integer.valueOf(limit); if (cassandraEndpointProfileList.size() == (lim + 1)) { pageLinkDto.setEndpointGroupId(endpointGroupId); pageLinkDto.setLimit(limit); pageLinkDto.setOffset( Base64.encodeBase64URLSafeString(cassandraEndpointProfileList.get(lim).getEndpointKeyHash())); cassandraEndpointProfileList.remove(lim); next = null; } else { next = DaoConstants.LAST_PAGE_MESSAGE; } pageLinkDto.setNext(next); endpointProfilesPageDto.setPageLinkDto(pageLinkDto); endpointProfilesPageDto.setEndpointProfiles(cassandraEndpointProfileList); return endpointProfilesPageDto; } private EndpointProfilesBodyDto createNextBodyPage(List<EndpointProfileBodyDto> profilesBodyDto, String endpointGroupId, String limit) { EndpointProfilesBodyDto endpointProfilesBodyDto = new EndpointProfilesBodyDto(); PageLinkDto pageLinkDto = new PageLinkDto(); String next; int lim = Integer.valueOf(limit); if (profilesBodyDto.size() == (lim + 1)) { pageLinkDto.setEndpointGroupId(endpointGroupId); pageLinkDto.setLimit(limit); pageLinkDto.setOffset(Base64.encodeBase64URLSafeString(profilesBodyDto.get(lim).getEndpointKeyHash())); profilesBodyDto.remove(lim); next = null; } else { next = DaoConstants.LAST_PAGE_MESSAGE; } pageLinkDto.setNext(next); endpointProfilesBodyDto.setPageLinkDto(pageLinkDto); endpointProfilesBodyDto.setEndpointProfilesBody(profilesBodyDto); return endpointProfilesBodyDto; } public EndpointUserCassandraDao getEndpointUserDao() { return endpointUserDao; } public void setEndpointUserDao(EndpointUserCassandraDao endpointUserDao) { this.endpointUserDao = endpointUserDao; } }