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.admin; import static java.util.Arrays.asList; import static org.springframework.http.MediaType.APPLICATION_JSON; import static org.springframework.http.MediaType.valueOf; import org.apache.commons.codec.binary.Base64; import org.apache.commons.io.IOUtils; import org.apache.commons.lang.StringUtils; import org.kaaproject.kaa.common.dto.ApplicationDto; import org.kaaproject.kaa.common.dto.ConfigurationDto; import org.kaaproject.kaa.common.dto.ConfigurationRecordDto; import org.kaaproject.kaa.common.dto.ConfigurationSchemaDto; import org.kaaproject.kaa.common.dto.EndpointGroupDto; import org.kaaproject.kaa.common.dto.EndpointNotificationDto; import org.kaaproject.kaa.common.dto.EndpointProfileBodyDto; import org.kaaproject.kaa.common.dto.EndpointProfileDto; import org.kaaproject.kaa.common.dto.EndpointProfileSchemaDto; import org.kaaproject.kaa.common.dto.EndpointProfilesBodyDto; import org.kaaproject.kaa.common.dto.EndpointProfilesPageDto; import org.kaaproject.kaa.common.dto.EndpointSpecificConfigurationDto; import org.kaaproject.kaa.common.dto.EndpointUserConfigurationDto; import org.kaaproject.kaa.common.dto.NotificationDto; import org.kaaproject.kaa.common.dto.NotificationSchemaDto; import org.kaaproject.kaa.common.dto.PageLinkDto; import org.kaaproject.kaa.common.dto.ProfileFilterDto; import org.kaaproject.kaa.common.dto.ProfileFilterRecordDto; import org.kaaproject.kaa.common.dto.ProfileVersionPairDto; import org.kaaproject.kaa.common.dto.ServerProfileSchemaDto; import org.kaaproject.kaa.common.dto.TenantDto; import org.kaaproject.kaa.common.dto.TopicDto; import org.kaaproject.kaa.common.dto.VersionDto; import org.kaaproject.kaa.common.dto.admin.AuthResultDto; import org.kaaproject.kaa.common.dto.admin.RecordKey; import org.kaaproject.kaa.common.dto.admin.ResultCode; import org.kaaproject.kaa.common.dto.admin.SchemaVersions; import org.kaaproject.kaa.common.dto.admin.SdkPlatform; import org.kaaproject.kaa.common.dto.admin.SdkProfileDto; import org.kaaproject.kaa.common.dto.admin.UserDto; import org.kaaproject.kaa.common.dto.admin.UserProfileUpdateDto; import org.kaaproject.kaa.common.dto.credentials.CredentialsDto; import org.kaaproject.kaa.common.dto.credentials.CredentialsStatus; import org.kaaproject.kaa.common.dto.ctl.CTLSchemaDto; import org.kaaproject.kaa.common.dto.ctl.CTLSchemaExportMethod; import org.kaaproject.kaa.common.dto.ctl.CtlSchemaMetaInfoDto; import org.kaaproject.kaa.common.dto.event.AefMapInfoDto; import org.kaaproject.kaa.common.dto.event.ApplicationEventFamilyMapDto; import org.kaaproject.kaa.common.dto.event.EcfInfoDto; import org.kaaproject.kaa.common.dto.event.EventClassDto; import org.kaaproject.kaa.common.dto.event.EventClassFamilyDto; import org.kaaproject.kaa.common.dto.event.EventClassFamilyVersionDto; import org.kaaproject.kaa.common.dto.event.EventClassType; import org.kaaproject.kaa.common.dto.file.FileData; import org.kaaproject.kaa.common.dto.logs.LogAppenderDto; import org.kaaproject.kaa.common.dto.logs.LogSchemaDto; import org.kaaproject.kaa.common.dto.user.UserVerifierDto; import org.kaaproject.kaa.server.common.utils.FileUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.io.ByteArrayResource; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.http.client.ClientHttpRequest; import org.springframework.http.client.ClientHttpResponse; import org.springframework.http.converter.HttpMessageConverter; import org.springframework.util.Base64Utils; import org.springframework.util.LinkedMultiValueMap; import org.springframework.util.MultiValueMap; import org.springframework.web.client.RequestCallback; import org.springframework.web.client.ResponseExtractor; import java.io.BufferedOutputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.ArrayList; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; public class AdminClient { private static final Logger LOG = LoggerFactory.getLogger(AdminClient.class); private static final Pattern fileNamePattern = Pattern.compile("^(.+?)filename=\"(.+?)\""); private KaaRestTemplate restTemplate; public AdminClient(String host, int port) { restTemplate = new KaaRestTemplate(host, port); } public AdminClient(String hostPortList) { restTemplate = new KaaRestTemplate(hostPortList); } private static String toUrlSafe(String endpointProfileKeyHash) { return Base64.encodeBase64URLSafeString(Base64.decodeBase64(endpointProfileKeyHash)); } /** * Read file from disk and return it binary format represented as ByteArrayResource. * * @param resource the name of file resource * @throws IOException the io exception */ public static ByteArrayResource getFileResource(final String resource) throws IOException { byte[] data = FileUtils.readResourceBytes(resource); ByteArrayResource bar = new ByteArrayResource(data) { @Override public String getFilename() { return resource; } }; return bar; } /** * Represented string resource as ByteArrayResource. The resource body encoded in UTF-8. * * @throws IOException the io exception */ public static ByteArrayResource getStringResource(final String resourceName, final String resourceBody) throws IOException { byte[] data = resourceBody.getBytes("UTF-8"); ByteArrayResource bar = new ByteArrayResource(data) { @Override public String getFilename() { return resourceName; } }; return bar; } /** * Gets the endpoint profile by endpoint group id. * * @param pageLink contains information about groupId, offset and limit */ public EndpointProfilesPageDto getEndpointProfileByEndpointGroupId(PageLinkDto pageLink) throws Exception { String endpointGroupId = pageLink.getEndpointGroupId(); String limit = pageLink.getLimit(); String offset = pageLink.getOffset(); ParameterizedTypeReference<EndpointProfilesPageDto> typeRef = new ParameterizedTypeReference<EndpointProfilesPageDto>() { }; ResponseEntity<EndpointProfilesPageDto> entity = restTemplate .exchange(restTemplate.getUrl() + "endpointProfileByGroupId?endpointGroupId=" + endpointGroupId + "&limit=" + limit + "&offset=" + offset, HttpMethod.GET, null, typeRef); return entity.getBody(); } /** * Gets the endpoint profile body by endpoint group id. * * @param pageLink contains information about groupId, offset and limit */ public EndpointProfilesBodyDto getEndpointProfileBodyByEndpointGroupId(PageLinkDto pageLink) throws Exception { String endpointGroupId = pageLink.getEndpointGroupId(); String limit = pageLink.getLimit(); String offset = pageLink.getOffset(); ResponseEntity<EndpointProfilesBodyDto> entity = restTemplate.exchange( restTemplate.getUrl() + "endpointProfileBodyByGroupId?endpointGroupId=" + endpointGroupId + "&limit=" + limit + "&offset=" + offset, HttpMethod.GET, null, new ParameterizedTypeReference<EndpointProfilesBodyDto>() { }); return entity.getBody(); } /** * Gets the endpoint profile by endpoint key hash. * * @param endpointProfileKeyHash the endpoint profile key hash */ public EndpointProfileDto getEndpointProfileByKeyHash(String endpointProfileKeyHash) throws Exception { ResponseEntity<EndpointProfileDto> entity = restTemplate.exchange( restTemplate.getUrl() + "endpointProfile/" + toUrlSafe(endpointProfileKeyHash), HttpMethod.GET, null, new ParameterizedTypeReference<EndpointProfileDto>() { }); return entity.getBody(); } /** * Gets the endpoint profile body by endpoint key hash. * * @param endpointProfileKeyHash the endpoint profile key hash * @return the endpoint profile body dto */ public EndpointProfileBodyDto getEndpointProfileBodyByKeyHash(String endpointProfileKeyHash) throws Exception { ResponseEntity<EndpointProfileBodyDto> entity = restTemplate.exchange( restTemplate.getUrl() + "endpointProfileBody/" + toUrlSafe(endpointProfileKeyHash), HttpMethod.GET, null, new ParameterizedTypeReference<EndpointProfileBodyDto>() { }); return entity.getBody(); } /** * Update server profile of endpoint. * * @param endpointProfileKey the endpoint profile key * @param version the version * @param serverProfileBody the server profile body */ public EndpointProfileDto updateServerProfile(String endpointProfileKey, int version, String serverProfileBody) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("endpointProfileKey", endpointProfileKey); params.add("version", version); params.add("serverProfileBody", serverProfileBody); return restTemplate.postForObject(restTemplate.getUrl() + "updateServerProfile", params, EndpointProfileDto.class); } public AuthResultDto checkAuth() throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "auth/checkAuth", AuthResultDto.class); } /** * Creates the kaa admin with specific name and password. * * @param username admin's name * @param password admin's password */ public void createKaaAdmin(String username, String password) throws Exception { MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>(); params.add("username", username); params.add("password", password); restTemplate.postForObject(restTemplate.getUrl() + "auth/createKaaAdmin", params, Void.class); } public void login(String username, String password) { restTemplate.login(username, password); } /** * Clear credentials of current user. */ public void clearCredentials() { HttpComponentsRequestFactoryBasicAuth requestFactory = (HttpComponentsRequestFactoryBasicAuth) restTemplate .getRequestFactory(); requestFactory.getCredentialsProvider().clear(); } /** * Change password of user. * * @param username the user name * @param oldPassword the old password * @param newPassword the new password * @return the result code * @throws Exception the exception */ public ResultCode changePassword(String username, String oldPassword, String newPassword) throws Exception { MultiValueMap<String, String> params = new LinkedMultiValueMap<String, String>(); params.add("username", username); params.add("oldPassword", oldPassword); params.add("newPassword", newPassword); return restTemplate.postForObject(restTemplate.getUrl() + "auth/changePassword", params, ResultCode.class); } public TenantDto editTenant(TenantDto tenant) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "tenant", tenant, TenantDto.class); } /** * Gets all tenants. * * @return the list of tenants */ public List<TenantDto> getTenants() throws Exception { ResponseEntity<List<TenantDto>> entity = restTemplate.exchange(restTemplate.getUrl() + "tenants", HttpMethod.GET, null, new ParameterizedTypeReference<List<TenantDto>>() { }); return entity.getBody(); } /** * Gets all tenant admins that belongs to one tenant. * * @param tenantId the tenant id * @return the all tenant admins by tenant id */ public List<UserDto> getAllTenantAdminsByTenantId(String tenantId) { ResponseEntity<List<UserDto>> entity = restTemplate.exchange(restTemplate.getUrl() + "admins/" + tenantId, HttpMethod.GET, null, new ParameterizedTypeReference<List<UserDto>>() { }); return entity.getBody(); } public TenantDto getTenant(String userId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "tenant/" + userId, TenantDto.class); } public ApplicationDto editApplication(ApplicationDto application) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "application", application, ApplicationDto.class); } /** * Gets all applications. * * @return the list of applications */ public List<ApplicationDto> getApplications() throws Exception { ResponseEntity<List<ApplicationDto>> entity = restTemplate.exchange(restTemplate.getUrl() + "applications", HttpMethod.GET, null, new ParameterizedTypeReference<List<ApplicationDto>>() { }); return entity.getBody(); } public ApplicationDto getApplicationByApplicationToken(String token) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "application/" + token, ApplicationDto.class); } public ConfigurationSchemaDto saveConfigurationSchema(ConfigurationSchemaDto configurationSchema) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "saveConfigurationSchema", configurationSchema, ConfigurationSchemaDto.class); } public EndpointProfileSchemaDto saveProfileSchema(EndpointProfileSchemaDto profileSchema) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "saveProfileSchema", profileSchema, EndpointProfileSchemaDto.class); } public ServerProfileSchemaDto saveServerProfileSchema(ServerProfileSchemaDto serverProfileSchema) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "saveServerProfileSchema", serverProfileSchema, ServerProfileSchemaDto.class); } public NotificationSchemaDto createNotificationSchema(NotificationSchemaDto notificationSchema) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "createNotificationSchema", notificationSchema, NotificationSchemaDto.class); } public NotificationSchemaDto saveNotificationSchema(NotificationSchemaDto notificationSchema) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "saveNotificationSchema", notificationSchema, NotificationSchemaDto.class); } public LogSchemaDto createLogSchema(LogSchemaDto logSchema) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "createLogSchema", logSchema, LogSchemaDto.class); } public LogSchemaDto saveLogSchema(LogSchemaDto logSchema) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "saveLogSchema", logSchema, LogSchemaDto.class); } /** * Get existing flat schema. * * @param id the id of the CTL schema */ public String getFlatSchemaByCtlSchemaId(String id) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "CTL/getFlatSchemaByCtlSchemaId?id={id}", String.class, id); } public TopicDto createTopic(TopicDto topic) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "topic", topic, TopicDto.class); } public TopicDto getTopic(String topicId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "topic/" + topicId, TopicDto.class); } /** * Gets all topics by application token. * * @param applicationToken the application token */ public List<TopicDto> getTopicsByApplicationToken(String applicationToken) throws Exception { ResponseEntity<List<TopicDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "topics/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<TopicDto>>() { }); return entity.getBody(); } /** * Gets all topics by endpoint group id. * * @param endpointGroupId the endpoint group id */ public List<TopicDto> getTopicsByEndpointGroupId(String endpointGroupId) throws Exception { ResponseEntity<List<TopicDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "topics?endpointGroupId={endpointGroupId}", HttpMethod.GET, null, new ParameterizedTypeReference<List<TopicDto>>() { }, endpointGroupId); return entity.getBody(); } /** * Gets all vacant topics by endpoint group id. * * @param endpointGroupId the endpoint group id */ public List<TopicDto> getVacantTopicsByEndpointGroupId(String endpointGroupId) throws Exception { ResponseEntity<List<TopicDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "vacantTopics/" + endpointGroupId, HttpMethod.GET, null, new ParameterizedTypeReference<List<TopicDto>>() { }); return entity.getBody(); } public void addTopicToEndpointGroup(EndpointGroupDto endpointGroup, TopicDto topic) throws Exception { addTopicToEndpointGroup(endpointGroup.getId(), topic.getId()); } /** * Adds the topic with specific id to endpoint group with specific id. * * @param endpointGroupId the endpoint group id * @param topicId the topic id */ public void addTopicToEndpointGroup(String endpointGroupId, String topicId) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("endpointGroupId", endpointGroupId); params.add("topicId", topicId); restTemplate.postForObject(restTemplate.getUrl() + "addTopicToEpGroup", params, Void.class); } /** * Removes the topic with specific id to endpoint group with specific id. * * @param endpointGroupId the endpoint group id * @param topicId the topic id */ public void removeTopicFromEndpointGroup(String endpointGroupId, String topicId) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("endpointGroupId", endpointGroupId); params.add("topicId", topicId); restTemplate.postForObject(restTemplate.getUrl() + "removeTopicFromEpGroup", params, Void.class); } /** * Remove the endpoint with specific profile key. * * @param endpointProfileKeyHash the endpoint profile key hash */ public void removeEndpointProfileByKeyHash(String endpointProfileKeyHash) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("endpointProfileKeyHash", endpointProfileKeyHash); restTemplate.postForObject(restTemplate.getUrl() + "removeEndpointProfileByKeyHash", params, Void.class); } public NotificationDto sendNotification(NotificationDto notification, String notificationResource) throws Exception { return sendNotification(notification, getFileResource(notificationResource)); } public NotificationDto sendNotification(NotificationDto notification, String notificationResourceName, String notificationResourceBody) throws Exception { return sendNotification(notification, getStringResource(notificationResourceName, notificationResourceBody)); } private NotificationDto sendNotification(NotificationDto notification, ByteArrayResource resource) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("notification", notification); params.add("file", resource); return restTemplate.postForObject(restTemplate.getUrl() + "sendNotification", params, NotificationDto.class); } public EndpointNotificationDto sendUnicastNotification(NotificationDto notification, String clientKeyHash, String notificationResource) throws Exception { return sendUnicastNotification(notification, clientKeyHash, getFileResource(notificationResource)); } public EndpointNotificationDto sendUnicastNotification(NotificationDto notification, String clientKeyHash, String notificationResourceName, String notificationResourceBody) throws Exception { return sendUnicastNotification(notification, clientKeyHash, getStringResource(notificationResourceName, notificationResourceBody)); } private EndpointNotificationDto sendUnicastNotification(NotificationDto notification, String clientKeyHash, ByteArrayResource resource) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("notification", notification); params.add("endpointKeyHash", clientKeyHash); params.add("file", resource); return restTemplate.postForObject(restTemplate.getUrl() + "sendUnicastNotification", params, EndpointNotificationDto.class); } /** * Send unicast notification to the client identified by endpointKeyHash. * * @param notification the notification * @param clientKeyHash the client key hash * @param notificationMessage the body of notification * @return the endpoint notification dto */ public EndpointNotificationDto sendUnicastNotificationSimplified(NotificationDto notification, String clientKeyHash, String notificationMessage) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("notification", notification); params.add("endpointKeyHash", clientKeyHash); params.add("file", getStringResource("notification", notificationMessage)); return restTemplate.postForObject(restTemplate.getUrl() + "sendUnicastNotification", params, EndpointNotificationDto.class); } public ConfigurationSchemaDto getConfigurationSchema(String configurationSchemaId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "configurationSchema/" + configurationSchemaId, ConfigurationSchemaDto.class); } public EndpointProfileSchemaDto getProfileSchema(String profileSchemaId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "profileSchema/" + profileSchemaId, EndpointProfileSchemaDto.class); } public ServerProfileSchemaDto getServerProfileSchema(String serverProfileSchemaId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "serverProfileSchema/" + serverProfileSchemaId, ServerProfileSchemaDto.class); } public NotificationSchemaDto getNotificationSchema(String notificationSchemaId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "notificationSchema/" + notificationSchemaId, NotificationSchemaDto.class); } public LogSchemaDto getLogSchema(String logSchemaId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "logSchema/" + logSchemaId, LogSchemaDto.class); } public SchemaVersions getSchemaVersionsByApplicationToken(String applicationToken) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "schemaVersions/" + applicationToken, SchemaVersions.class); } /** * Gets the configuration schemas by application token. * * @param applicationToken the application token */ public List<ConfigurationSchemaDto> getConfigurationSchemasByAppToken(String applicationToken) throws Exception { ResponseEntity<List<ConfigurationSchemaDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "configurationSchemas/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<ConfigurationSchemaDto>>() { }); return entity.getBody(); } /** * Gets the client profile schemas by application token. * * @param applicationToken the application token */ public List<EndpointProfileSchemaDto> getProfileSchemas(String applicationToken) throws Exception { ResponseEntity<List<EndpointProfileSchemaDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "profileSchemas/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<EndpointProfileSchemaDto>>() { }); return entity.getBody(); } /** * Gets the server profile schemas by application token. * * @param applicationToken the application token */ public List<ServerProfileSchemaDto> getServerProfileSchemasByAppToken(String applicationToken) throws Exception { ResponseEntity<List<ServerProfileSchemaDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "serverProfileSchemas/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<ServerProfileSchemaDto>>() { }); return entity.getBody(); } /** * Gets the notification schemas by application token. * * @param applicationToken the application token */ public List<NotificationSchemaDto> getNotificationSchemasByAppToken(String applicationToken) throws Exception { ResponseEntity<List<NotificationSchemaDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "notificationSchemas/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<NotificationSchemaDto>>() { }); return entity.getBody(); } /** * Gets the user notification schemas by application token. * * @param applicationToken the application token */ public List<VersionDto> getUserNotificationSchemasByAppToken(String applicationToken) throws Exception { ResponseEntity<List<VersionDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "userNotificationSchemas/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<VersionDto>>() { }); return entity.getBody(); } /** * Gets all log schemas by application token. * * @param applicationToken the application Token * @return the list of log schema dto */ public List<LogSchemaDto> getLogSchemasByAppToken(String applicationToken) throws Exception { ResponseEntity<List<LogSchemaDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "logSchemas/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<LogSchemaDto>>() { }); return entity.getBody(); } /** * Gets all topics by application token. * * @param applicationId the application token */ public List<TopicDto> getTopics(String applicationId) throws Exception { ResponseEntity<List<TopicDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "topics/" + applicationId, HttpMethod.GET, null, new ParameterizedTypeReference<List<TopicDto>>() { }); return entity.getBody(); } public TopicDto editTopic(TopicDto topic) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "topic", topic, TopicDto.class); } public void deleteTopic(TopicDto topic) throws Exception { deleteTopic(topic.getId()); } /** * Delete topic by its id. * * @param topicId the topic id */ public void deleteTopic(String topicId) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("topicId", topicId); restTemplate.postForLocation(restTemplate.getUrl() + "delTopic", params); } public EndpointGroupDto editEndpointGroup(EndpointGroupDto endpointGroup) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "endpointGroup", endpointGroup, EndpointGroupDto.class); } public EndpointGroupDto getEndpointGroup(String endpointGroupId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "endpointGroup/" + endpointGroupId, EndpointGroupDto.class); } /** * Delete endpoint group by its id. * * @param endpointGroupId the endpoint group id */ public void deleteEndpointGroup(String endpointGroupId) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("endpointGroupId", endpointGroupId); restTemplate.postForLocation(restTemplate.getUrl() + "delEndpointGroup", params); } /** * Gets all endpoint groups by application token. * * @param applicationToken the application token */ public List<EndpointGroupDto> getEndpointGroupsByAppToken(String applicationToken) throws Exception { ResponseEntity<List<EndpointGroupDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "endpointGroups/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<EndpointGroupDto>>() { }); return entity.getBody(); } /** * Gets the vacant configuration schemas by endpoint group id. * * @param endpointGroupId the endpoint group id * @return the list schema dto */ public List<VersionDto> getVacantConfigurationSchemasByEndpointGroupId(String endpointGroupId) throws Exception { ResponseEntity<List<VersionDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "vacantConfigurationSchemas/" + endpointGroupId, HttpMethod.GET, null, new ParameterizedTypeReference<List<VersionDto>>() { }); return entity.getBody(); } /** * Delete configuration record by schema id and endpoint group id. * * @param schemaId the schema id * @param endpointGroupId the endpoint group id */ public void deleteConfigurationRecord(String schemaId, String endpointGroupId) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("schemaId", schemaId); params.add("endpointGroupId", endpointGroupId); restTemplate.postForObject(restTemplate.getUrl() + "delConfigurationRecord", params, Void.class); } /** * Gets the configuration records by endpoint group id. * * @param endpointGroupId the endpoint group id * @param includeDeprecated specify if result will contain deprecated records */ public List<ConfigurationRecordDto> getConfigurationRecords(String endpointGroupId, boolean includeDeprecated) throws Exception { ResponseEntity<List<ConfigurationRecordDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "configurationRecords?endpointGroupId={endpointGroupId}" + "&includeDeprecated={includeDeprecated}", HttpMethod.GET, null, new ParameterizedTypeReference<List<ConfigurationRecordDto>>() { }, endpointGroupId, includeDeprecated); return entity.getBody(); } public ConfigurationDto editConfiguration(ConfigurationDto configuration) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "configuration", configuration, ConfigurationDto.class); } /** * Gets the configuration record by schema id and endpoint group id. * * @param schemaId the schema id * @param endpointGroupId the endpoint group id */ public ConfigurationRecordDto getConfigurationRecord(String schemaId, String endpointGroupId) throws Exception { return restTemplate.getForObject( restTemplate.getUrl() + "configurationRecord?schemaId={schemaId}&endpointGroupId={endpointGroupId}", ConfigurationRecordDto.class, schemaId, endpointGroupId); } /** * Get configuration record body. * * @param schemaId the schema id * @param endpointGroupId the endpoint group id */ public String getConfigurationRecordBody(String schemaId, String endpointGroupId) throws Exception { return restTemplate.getForObject( restTemplate.getUrl() + "configurationRecordBody?schemaId={schemaId}&endpointGroupId={endpointGroupId}", String.class, schemaId, endpointGroupId); } public ConfigurationDto activateConfiguration(String configurationId) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "activateConfiguration", configurationId, ConfigurationDto.class); } public ConfigurationDto deactivateConfiguration(String configurationId) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "deactivateConfiguration", configurationId, ConfigurationDto.class); } public void editUserConfiguration(EndpointUserConfigurationDto endpointUserConfiguration) throws Exception { restTemplate.postForLocation(restTemplate.getUrl() + "userConfiguration", endpointUserConfiguration); } public EndpointSpecificConfigurationDto editEndpointSpecificConfiguration( EndpointSpecificConfigurationDto configuration) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "endpointSpecificConfiguration", configuration, EndpointSpecificConfigurationDto.class); } public void deleteActiveEndpointSpecificConfiguration(String endpointKeyHash) throws Exception { restTemplate.delete(restTemplate.getUrl() + "endpointSpecificConfiguration/{endpointKeyHash}", toUrlSafe(endpointKeyHash)); } public EndpointSpecificConfigurationDto findActiveEndpointSpecificConfiguration(String endpointKeyHash) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "endpointSpecificConfiguration/{endpointKeyHash}", EndpointSpecificConfigurationDto.class, toUrlSafe(endpointKeyHash)); } /** * Delete endpoint specific configuration. * * @param endpointKeyHash endpoint key hash * @param configurationSchemaVersion configuration schema version */ public void deleteEndpointSpecificConfigurationByEndpointKeyHashAndConfigurationSchemaVersion( String endpointKeyHash, int configurationSchemaVersion) throws Exception { restTemplate.delete(restTemplate.getUrl() + "endpointSpecificConfiguration/{endpointKeyHash}?configurationSchemaVersion={configurationSchemaVersion}", toUrlSafe(endpointKeyHash), configurationSchemaVersion); } /** * Find endpoint specific configuration. * * @param endpointKeyHash endpoint key hash * @param configurationSchemaVersion configuration schema version */ public EndpointSpecificConfigurationDto findEndpointSpecificConfigurationByEndpointKeyHashAndConfigurationSchemaVersion( String endpointKeyHash, int configurationSchemaVersion) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "endpointSpecificConfiguration/{endpointKeyHash}?configurationSchemaVersion={configurationSchemaVersion}", EndpointSpecificConfigurationDto.class, toUrlSafe(endpointKeyHash), configurationSchemaVersion); } public ProfileFilterDto editProfileFilter(ProfileFilterDto profileFilter) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "profileFilter", profileFilter, ProfileFilterDto.class); } /** * Gets the profile filter record by EP server and client profile schema id and endpoint group id. * * @param endpointProfileSchemaId the endpoint profile schema id * @param serverProfileSchemaId the server profile schema id * @param endpointGroupId the endpoint group id */ public ProfileFilterRecordDto getProfileFilterRecord(String endpointProfileSchemaId, String serverProfileSchemaId, String endpointGroupId) throws Exception { StringBuilder sb = new StringBuilder(); sb.append(restTemplate.getUrl()).append("profileFilterRecord?endpointGroupId={endpointGroupId}"); List<Object> urlVariables = new ArrayList<>(); urlVariables.add(endpointGroupId); if (endpointProfileSchemaId != null) { sb.append("&endpointProfileSchemaId={endpointProfileSchemaId}"); urlVariables.add(endpointProfileSchemaId); } if (serverProfileSchemaId != null) { sb.append("&serverProfileSchemaId={serverProfileSchemaId}"); urlVariables.add(serverProfileSchemaId); } return restTemplate.getForObject(sb.toString(), ProfileFilterRecordDto.class, urlVariables.toArray()); } /** * Gets the vacant profile schemas by endpoint group id. * * @param endpointGroupId the endpoint group id */ public List<ProfileVersionPairDto> getVacantProfileSchemasByEndpointGroupId(String endpointGroupId) throws Exception { ResponseEntity<List<ProfileVersionPairDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "vacantProfileSchemas/" + endpointGroupId, HttpMethod.GET, null, new ParameterizedTypeReference<List<ProfileVersionPairDto>>() { }); return entity.getBody(); } /** * Delete profile filter record by schema ids and endpoin group id. * * @param endpointProfileSchemaId the endpoint profile schema id * @param serverProfileSchemaId the server profile schema id * @param endpointGroupId the endpoint group id */ public void deleteProfileFilterRecord(String endpointProfileSchemaId, String serverProfileSchemaId, String endpointGroupId) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("endpointProfileSchemaId", endpointProfileSchemaId); params.add("serverProfileSchemaId", serverProfileSchemaId); params.add("endpointGroupId", endpointGroupId); restTemplate.postForObject(restTemplate.getUrl() + "delProfileFilterRecord", params, Void.class); } /** * Gets the profile filter records by endpoint group id. * * @param endpointGroupId the endpoint group id * @param includeDeprecated the include deprecated */ public List<ProfileFilterRecordDto> getProfileFilterRecords(String endpointGroupId, boolean includeDeprecated) throws Exception { ResponseEntity<List<ProfileFilterRecordDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "profileFilterRecords?endpointGroupId={endpointGroupId}" + "&includeDeprecated={includeDeprecated}", HttpMethod.GET, null, new ParameterizedTypeReference<List<ProfileFilterRecordDto>>() { }, endpointGroupId, includeDeprecated); return entity.getBody(); } public ProfileFilterDto activateProfileFilter(String profileFilterId) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "activateProfileFilter", profileFilterId, ProfileFilterDto.class); } public ProfileFilterDto deactivateProfileFilter(String profileFilterId) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "deactivateProfileFilter", profileFilterId, ProfileFilterDto.class); } public UserDto editUser(UserDto user) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "user", user, UserDto.class); } public UserDto getUser(String userId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "user/" + userId, UserDto.class); } /** * Delete user by user id. * * @param userId the user id */ public void deleteUser(String userId) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("userId", userId); restTemplate.postForLocation(restTemplate.getUrl() + "delUser", params); } /** * Gets all users. * */ public List<UserDto> getUsers() throws Exception { ResponseEntity<List<UserDto>> entity = restTemplate.exchange(restTemplate.getUrl() + "users", HttpMethod.GET, null, new ParameterizedTypeReference<List<UserDto>>() { }); return entity.getBody(); } /** * Gets the log schema by application token and schema version. * * @param applicationToken the application token * @param schemaVersion the schema version */ public LogSchemaDto getLogSchemaByApplicationTokenAndSchemaVersion(String applicationToken, int schemaVersion) throws Exception { ResponseEntity<LogSchemaDto> entity = restTemplate.exchange( restTemplate.getUrl() + "logSchema/" + applicationToken + "/" + schemaVersion, HttpMethod.GET, null, new ParameterizedTypeReference<LogSchemaDto>() { }); return entity.getBody(); } public EventClassFamilyDto editEventClassFamily(EventClassFamilyDto eventClassFamily) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "eventClassFamily", eventClassFamily, EventClassFamilyDto.class); } public EventClassFamilyDto getEventClassFamilyById(String ecfId) { return restTemplate.getForObject(restTemplate.getUrl() + "eventClassFamily/" + ecfId, EventClassFamilyDto.class); } /** * Gets the event class family versions by its id. * * @param ecfId the event class family id * @return the list of event class family version dto */ public List<EventClassFamilyVersionDto> getEventClassFamilyVersionsById(String ecfId) { ResponseEntity<List<EventClassFamilyVersionDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "eventClassFamilyVersions/" + ecfId, HttpMethod.GET, null, new ParameterizedTypeReference<List<EventClassFamilyVersionDto>>() { }); return entity.getBody(); } /** * Gets all event class family by family name. */ public EventClassFamilyDto getEventClassFamily(String familyName) { ResponseEntity<List<EventClassFamilyDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "eventClassFamilies", HttpMethod.GET, null, new ParameterizedTypeReference<List<EventClassFamilyDto>>() { }); List<EventClassFamilyDto> familyList = entity.getBody(); for (EventClassFamilyDto family : familyList) { if (family.getClassName().equals(familyName)) { return family; } } throw new RuntimeException("Family with name " + familyName + " not found!"); } /** * Gets all event class families. * * @return the list event class family dto */ public List<EventClassFamilyDto> getEventClassFamilies() { ResponseEntity<List<EventClassFamilyDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "eventClassFamilies", HttpMethod.GET, null, new ParameterizedTypeReference<List<EventClassFamilyDto>>() { }); return entity.getBody(); } /** * Adds the event class family version to existing event class family with * specific id. Current user will be marked as creator of schema. * * @param eventClassFamilyId the event class family id * @param eventClassFamilyVersion the version of event class family */ public void addEventClassFamilyVersion(String eventClassFamilyId, EventClassFamilyVersionDto eventClassFamilyVersion) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("eventClassFamilyId", eventClassFamilyId); params.add("eventClassFamilyVersion", eventClassFamilyVersion); restTemplate.postForLocation(restTemplate.getUrl() + "addEventClassFamilyVersion", params); } /** * Gets the event classes by family its id, version and type. * * @param eventClassFamilyId the event class family id * @param version the version * @param type the type */ public List<EventClassDto> getEventClassesByFamilyIdVersionAndType(String eventClassFamilyId, int version, EventClassType type) throws Exception { ResponseEntity<List<EventClassDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "eventClasses?eventClassFamilyId={eventClassFamilyId}&" + "version={version}" + "&type={type}", HttpMethod.GET, null, new ParameterizedTypeReference<List<EventClassDto>>() { }, eventClassFamilyId, version, type); return entity.getBody(); } public ApplicationEventFamilyMapDto editApplicationEventFamilyMap( ApplicationEventFamilyMapDto applicationEventFamilyMap) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "applicationEventMap", applicationEventFamilyMap, ApplicationEventFamilyMapDto.class); } public ApplicationEventFamilyMapDto getApplicationEventFamilyMap(String aefMapId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "applicationEventMap/" + aefMapId, ApplicationEventFamilyMapDto.class); } /** * Gets all application event family maps by application token. * * @param applicationToken the application token * @return list the application event family map dto */ public List<ApplicationEventFamilyMapDto> getApplicationEventFamilyMapsByApplicationToken( String applicationToken) throws Exception { ResponseEntity<List<ApplicationEventFamilyMapDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "applicationEventMaps/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<ApplicationEventFamilyMapDto>>() { }); return entity.getBody(); } /** * Gets all vacant event class families by application token. * * @param applicationToken the application token * @return the list ecf info dto */ public List<EcfInfoDto> getVacantEventClassFamiliesByApplicationToken(String applicationToken) throws Exception { ResponseEntity<List<EcfInfoDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "vacantEventClassFamilies/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<EcfInfoDto>>() { }); return entity.getBody(); } /** * Gets all event class families by application token. * * @param applicationToken the application token */ public List<AefMapInfoDto> getEventClassFamiliesByApplicationToken(String applicationToken) throws Exception { ResponseEntity<List<AefMapInfoDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "eventClassFamilies/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<AefMapInfoDto>>() { }); return entity.getBody(); } public LogAppenderDto editLogAppenderDto(LogAppenderDto logAppenderDto) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "logAppender", logAppenderDto, LogAppenderDto.class); } public LogAppenderDto getLogAppender(String logAppenderId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "logAppender/" + logAppenderId, LogAppenderDto.class); } /** * Gets all log appenders by application token. * * @param applicationToken the application token */ public List<LogAppenderDto> getLogAppendersByAppToken(String applicationToken) throws Exception { ResponseEntity<List<LogAppenderDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "logAppenders/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<LogAppenderDto>>() { }); return entity.getBody(); } /** * Delete log appender by its id. * * @param logAppenderId the log appender id */ public void deleteLogAppender(String logAppenderId) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("logAppenderId", logAppenderId); restTemplate.postForLocation(restTemplate.getUrl() + "delLogAppender", params); } public UserVerifierDto getUserVerifier(String userVerifierId) throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "userVerifier/" + userVerifierId, UserVerifierDto.class); } /** * Gets all user verifiers by application token. * * @param applicationToken the application token * @return the list user verifier dto */ public List<UserVerifierDto> getUserVerifiersByApplicationToken(String applicationToken) { ResponseEntity<List<UserVerifierDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "userVerifiers/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<UserVerifierDto>>() { }); return entity.getBody(); } public UserVerifierDto editUserVerifierDto(UserVerifierDto userVerifierDto) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "userVerifier", userVerifierDto, UserVerifierDto.class); } /** * Delete user verifier by its id. * * @param userVerifierId the user verifier id */ public void deleteUserVerifier(String userVerifierId) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("userVerifierId", userVerifierId); restTemplate.postForLocation(restTemplate.getUrl() + "delUserVerifier", params); } public SdkProfileDto createSdkProfile(SdkProfileDto sdkProfile) throws Exception { return restTemplate.postForObject(restTemplate.getUrl() + "createSdkProfile", sdkProfile, SdkProfileDto.class); } /** * Deletes an SDK profile by its identifier. * * @param sdkProfile the sdk profile */ public void deleteSdkProfile(SdkProfileDto sdkProfile) throws Exception { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("topicId", sdkProfile.getId()); restTemplate.postForLocation(restTemplate.getUrl() + "deleteSdkProfile", params); } /** * Returns an SDK profile by its identifier. * * @param sdkProfileId the sdk profile id */ public SdkProfileDto getSdkProfile(String sdkProfileId) throws Exception { ResponseEntity<SdkProfileDto> entity = restTemplate.exchange( restTemplate.getUrl() + "sdkProfile/" + sdkProfileId, HttpMethod.GET, null, new ParameterizedTypeReference<SdkProfileDto>() { }); return entity.getBody(); } /** * Returns a list of SDK profiles for the given application. * * @param applicationToken the application token */ public List<SdkProfileDto> getSdkProfilesByApplicationToken(String applicationToken) throws Exception { ResponseEntity<List<SdkProfileDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "sdkProfiles/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<SdkProfileDto>>() { }); return entity.getBody(); } /** * Generates an SDK for the specified target platform from the SDK profile . * * @param sdkProfileId the sdk profile id * @param targetPlatform the target platform */ public void downloadSdk(String sdkProfileId, SdkPlatform targetPlatform, String destination) { FileResponseExtractor extractor = new FileResponseExtractor(new File(destination)); MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>(); parameters.add("sdkProfileId", sdkProfileId); parameters.add("targetPlatform", targetPlatform.toString()); RequestCallback request = new DataRequestCallback<>(parameters); restTemplate.execute(restTemplate.getUrl() + "sdk", HttpMethod.POST, request, extractor); } /** * Generates an SDK for the specified target platform from specified SDK profile. * * @param sdkProfileId the sdk profile id * @param targetPlatform the target platform */ public FileData downloadSdk(String sdkProfileId, SdkPlatform targetPlatform) { FileDataResponseExtractor extractor = new FileDataResponseExtractor(); MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>(); parameters.add("sdkProfileId", sdkProfileId); parameters.add("targetPlatform", targetPlatform.toString()); RequestCallback request = new DataRequestCallback<>(parameters); return restTemplate.execute(restTemplate.getUrl() + "sdk", HttpMethod.POST, request, extractor); } /** * Generates a new SDK from specified SDK profile. */ public void downloadSdk(SdkProfileDto key, String destination) throws Exception { FileResponseExtractor extractor = new FileResponseExtractor(new File(destination)); RequestCallback request = new DataRequestCallback<>(key); restTemplate.execute(restTemplate.getUrl() + "sdk", HttpMethod.POST, request, extractor); LOG.info("Downloaded sdk to file '{}'", extractor.getDestFile()); } /** * Generates a new SDK from specified SDK profile. */ public FileData downloadSdk(SdkProfileDto key) throws Exception { FileDataResponseExtractor extractor = new FileDataResponseExtractor(); RequestCallback request = new DataRequestCallback<>(key); FileData data = restTemplate.execute(restTemplate.getUrl() + "sdk", HttpMethod.POST, request, extractor); return data; } /** * Generate log library by record key. * * @param key the record key */ public FileData downloadLogRecordLibrary(RecordKey key) throws Exception { FileDataResponseExtractor extractor = new FileDataResponseExtractor(); RequestCallback request = new DataRequestCallback<>(key); FileData data = restTemplate.execute(restTemplate.getUrl() + "logLibrary", HttpMethod.POST, request, extractor); return data; } /** * Get log record schema with header and log schema inside by record key. * * @param key the record key */ public FileData downloadLogRecordSchema(RecordKey key) throws Exception { FileDataResponseExtractor extractor = new FileDataResponseExtractor(); RequestCallback request = new DataRequestCallback<>(key); FileData data = restTemplate.execute(restTemplate.getUrl() + "logRecordSchema", HttpMethod.POST, request, extractor); return data; } /** * Exports a CTL schema and all of its dependencies depending on the export method specified. */ public FileData downloadCtlSchemaByAppToken(CTLSchemaDto ctlSchemaDto, CTLSchemaExportMethod method, String appToken) { final FileDataResponseExtractor extractor = new FileDataResponseExtractor(); MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>(); parameters.add("fqn", ctlSchemaDto.getMetaInfo().getFqn()); parameters.add("version", Integer.toString(ctlSchemaDto.getVersion())); if (ctlSchemaDto.getMetaInfo().getApplicationId() != null) { parameters.add("applicationToken", appToken); } parameters.add("method", method.name()); RequestCallback request = new DataRequestCallback<>(parameters); return restTemplate.execute(restTemplate.getUrl() + "CTL/exportSchema", HttpMethod.POST, request, extractor); } /** * Flushes all cached Sdks within tenant. * */ public void flushSdkCache() throws Exception { restTemplate.postForLocation(restTemplate.getUrl() + "flushSdkCache", null); } //CHECKSTYLE:OFF public CTLSchemaDto saveCTLSchemaWithAppToken(String body, String tenantId, String applicationToken) { //CHECKSTYLE:ON MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("body", body); if (tenantId != null) { params.add("tenantId", tenantId); } if (applicationToken != null) { params.add("applicationToken", applicationToken); } return restTemplate.postForObject(restTemplate.getUrl() + "CTL/saveSchema", params, CTLSchemaDto.class); } //CHECKSTYLE:OFF public void deleteCTLSchemaByFqnVersionTenantIdAndApplicationToken(String fqn, Integer version, String tenantId, String applicationToken) { //CHECKSTYLE:ON MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("fqn", fqn); params.add("version", version); if (tenantId != null) { params.add("tenantId", tenantId); } if (applicationToken != null) { params.add("applicationToken", applicationToken); } restTemplate.postForLocation(restTemplate.getUrl() + "CTL/deleteSchema", params); } //CHECKSTYLE:OFF public CTLSchemaDto getCTLSchemaByFqnVersionTenantIdAndApplicationToken(String fqn, Integer version, String tenantId, String applicationToken) { //CHECKSTYLE:ON if (tenantId != null && applicationToken != null) { return restTemplate.getForObject( restTemplate.getUrl() + "CTL/getSchema?fqn={fqn}&version={version}&tenantId={tenantId}" + "&applicationToken={applicationToken}", CTLSchemaDto.class, fqn, version, tenantId, applicationToken); } else if (tenantId != null) { return restTemplate.getForObject( restTemplate.getUrl() + "CTL/getSchema?fqn={fqn}&version={version}&tenantId={tenantId}", CTLSchemaDto.class, fqn, version, tenantId); } else { return restTemplate.getForObject(restTemplate.getUrl() + "CTL/getSchema?fqn={fqn}&version={version}", CTLSchemaDto.class, fqn, version); } } //CHECKSTYLE:OFF public CTLSchemaDto getCTLSchemaById(String id) { //CHECKSTYLE:ON return restTemplate.getForObject(restTemplate.getUrl() + "CTL/getSchemaById?id={id}", CTLSchemaDto.class, id); } /** * Checks if CTL schema with same fqn is already exists in the sibling applications. * * @param fqn the full qualified name * @param tenantId id of the tenant * @param applicationToken the application token * @return true if CTL schema with same fqn is already exists in other scope */ public boolean checkFqnExistsWithAppToken(String fqn, String tenantId, String applicationToken) { if (tenantId != null && applicationToken != null) { return restTemplate.getForObject( restTemplate.getUrl() + "CTL/checkFqn?fqn={fqn}&tenantId={tenantId}" + "&applicationToken={applicationToken}", Boolean.class, fqn, tenantId, applicationToken); } else if (tenantId != null) { return restTemplate.getForObject(restTemplate.getUrl() + "CTL/checkFqn?fqn={fqn}&tenantId={tenantId}", Boolean.class, fqn, tenantId); } else { return restTemplate.getForObject(restTemplate.getUrl() + "CTL/checkFqn?fqn={fqn}", Boolean.class, fqn); } } /** * Promote existing CTL schema meta info from application to tenant scope * * @param applicationId the id of application where schema was created * @param fqn the fqn of promoting CTL schema * @return CtlSchemaMetaInfoDto the promoted CTL schema meta info object. */ public CtlSchemaMetaInfoDto promoteScopeToTenant(String applicationId, String fqn) { MultiValueMap<String, Object> params = new LinkedMultiValueMap<>(); params.add("applicationId", applicationId); params.add("fqn", fqn); return restTemplate.postForObject(restTemplate.getUrl() + "CTL/promoteScopeToTenant", params, CtlSchemaMetaInfoDto.class); } //CHECKSTYLE:OFF public List<CtlSchemaMetaInfoDto> getSystemLevelCTLSchemas() { //CHECKSTYLE:ON ResponseEntity<List<CtlSchemaMetaInfoDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "CTL/getSystemSchemas", HttpMethod.GET, null, new ParameterizedTypeReference<List<CtlSchemaMetaInfoDto>>() { }); return entity.getBody(); } //CHECKSTYLE:OFF public List<CtlSchemaMetaInfoDto> getTenantLevelCTLSchemas() { //CHECKSTYLE:ON ResponseEntity<List<CtlSchemaMetaInfoDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "CTL/getTenantSchemas", HttpMethod.GET, null, new ParameterizedTypeReference<List<CtlSchemaMetaInfoDto>>() { }); return entity.getBody(); } //CHECKSTYLE:OFF public List<CtlSchemaMetaInfoDto> getApplicationLevelCTLSchemasByAppToken(String applicationToken) { //CHECKSTYLE:ON ResponseEntity<List<CtlSchemaMetaInfoDto>> entity = restTemplate.exchange( restTemplate.getUrl() + "CTL/getApplicationSchemas/" + applicationToken, HttpMethod.GET, null, new ParameterizedTypeReference<List<CtlSchemaMetaInfoDto>>() { }); return entity.getBody(); } /** * Gets the user profile of current user. * * @return the user dto */ public UserDto getUserProfile() throws Exception { return restTemplate.getForObject(restTemplate.getUrl() + "userProfile", UserDto.class); } /** * Edits user profile to all user profiles. * * @param userProfileUpdateDto the user profile dto */ public void editUserProfile(UserProfileUpdateDto userProfileUpdateDto) { restTemplate.postForObject(restTemplate.getUrl() + "userProfile", userProfileUpdateDto, Void.class); } /** * Returns a list of endpoint profiles attached to the endpoint user with * the given external id. * * @param endpointUserExternalId the endpoint user external id * @return a list of endpoint profiles for the user with the given external id */ public List<EndpointProfileDto> getEndpointProfilesByUserExternalId(String endpointUserExternalId) { String address = restTemplate.getUrl() + "endpointProfiles?userExternalId=" + endpointUserExternalId; ResponseEntity<List<EndpointProfileDto>> response = this.restTemplate.exchange(address, HttpMethod.GET, null, new ParameterizedTypeReference<List<EndpointProfileDto>>() { }); return response.getBody(); } /** * Provides security credentials, allowing an endpoint that uses them to * interact with the specified application. * * @param applicationToken the application token to allow interaction with * @param credentialsBody the security credentials to save */ public CredentialsDto provisionCredentials(String applicationToken, byte[] credentialsBody) { MultiValueMap<String, Object> parameters = new LinkedMultiValueMap<>(); parameters.add("applicationToken", applicationToken); parameters.add("credentialsBody", Base64Utils.encodeToString(credentialsBody)); return this.restTemplate.postForObject(restTemplate.getUrl() + "provisionCredentials", parameters, CredentialsDto.class); } /** * Binds credentials to the specified server-side endpoint profile. * * @param applicationToken the application token * @param credentialsId the id of the credentials to bind * @param serverProfileVersion the server-side endpoint profile version * @param serverProfileBody the server-side endpoint profile body */ public void provisionRegistration(String applicationToken, String credentialsId, Integer serverProfileVersion, String serverProfileBody) { MultiValueMap<String, Object> parameters = new LinkedMultiValueMap<>(); parameters.add("applicationToken", applicationToken); parameters.add("credentialsId", credentialsId); parameters.add("serverProfileVersion", serverProfileVersion); parameters.add("serverProfileBody", serverProfileBody); this.restTemplate.postForLocation(restTemplate.getUrl() + "provisionRegistration", parameters); } /** * Provides the status for given credentials. * * @param applicationToken the application token * @param credentialsId the id of the credentials * @return credentials status */ public CredentialsStatus getCredentialsStatus(String applicationToken, String credentialsId) { return this.restTemplate.getForObject( restTemplate.getUrl() + "credentialsStatus?applicationToken={applicationToken}" + "&credentialsId={credentialsId}", CredentialsStatus.class, applicationToken, credentialsId); } /** * Revokes security credentials from the corresponding credentials storage. * Also launches an asynchronous process to terminate all active sessions of * the endpoint that uses these credentials. * * @param applicationToken the application token * @param credentialsId the id of the credentials */ public void revokeCredentials(String applicationToken, String credentialsId) { MultiValueMap<String, Object> parameters = new LinkedMultiValueMap<>(); parameters.add("applicationToken", applicationToken); parameters.add("credentialsId", credentialsId); this.restTemplate.postForLocation(restTemplate.getUrl() + "revokeCredentials", parameters); } /** * Used if credentials stored in external storage and Kaa server can't directly revoke them but * can be notified about security credentials revocation by external system. * * <p>If an endpoint is already registered with the specified credentials, this API * call launches an asynchronous process to terminate all active sessions of * the corresponding endpoint.</p> * * @param applicationToken the application token * @param credentialsId the id of the credentials */ public void onCredentialsRevoked(String applicationToken, String credentialsId) { MultiValueMap<String, Object> parameters = new LinkedMultiValueMap<>(); parameters.add("applicationToken", applicationToken); parameters.add("credentialsId", credentialsId); this.restTemplate.postForLocation(restTemplate.getUrl() + "notifyRevoked", parameters); } /** * Get user configuration of by externalUID, schema version and application token. * * @param appToken the application token * @param schemaVersion the schema version * @param externalUId the external user id */ public EndpointUserConfigurationDto findUserConfigurationByUserId(String externalUId, String appToken, Integer schemaVersion) { return restTemplate.getForObject( restTemplate.getUrl() + "configuration/{externalUId}/{appToken}/{schemaVersion}", EndpointUserConfigurationDto.class, externalUId, appToken, schemaVersion); } /** * Get configuration of specific endpoint by endpointKeyHash. * * @param endpointKeyHash the endpoint key hash */ public String findEndpointConfigurationByEndpointKeyHash(String endpointKeyHash) { return restTemplate.getForObject(restTemplate.getUrl() + "configuration/{endpointKeyHash}/", String.class, endpointKeyHash); } private static class FileResponseExtractor implements ResponseExtractor<Object> { private final File destDir; private File destFile; private FileResponseExtractor(File destDir) { this.destDir = destDir; } public File getDestFile() { return destFile; } @Override public Object extractData(ClientHttpResponse response) throws IOException { String fileName = ""; String contentDisposition = response.getHeaders().getFirst("Content-Disposition"); if (StringUtils.isNotBlank(contentDisposition)) { Matcher matcher = fileNamePattern.matcher(contentDisposition); if (matcher.matches()) { fileName = matcher.group(2); } } if (StringUtils.isBlank(fileName)) { fileName = "downloaded-" + System.currentTimeMillis(); } destFile = new File(destDir, fileName); InputStream is = response.getBody(); OutputStream os = new BufferedOutputStream(new FileOutputStream(destFile)); IOUtils.copyLarge(is, os); IOUtils.closeQuietly(is); IOUtils.closeQuietly(os); return null; } } private static class FileDataResponseExtractor implements ResponseExtractor<FileData> { private FileDataResponseExtractor() { } @Override public FileData extractData(ClientHttpResponse response) throws IOException { String fileName = ""; String contentDisposition = response.getHeaders().getFirst("Content-Disposition"); final String contentType = response.getHeaders().getFirst("Content-Type"); if (StringUtils.isNotBlank(contentDisposition)) { Matcher matcher = fileNamePattern.matcher(contentDisposition); if (matcher.matches()) { fileName = matcher.group(2); } } if (StringUtils.isBlank(fileName)) { fileName = "downloaded-" + System.currentTimeMillis(); } InputStream is = response.getBody(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); OutputStream os = new BufferedOutputStream(baos); IOUtils.copyLarge(is, os); IOUtils.closeQuietly(is); IOUtils.closeQuietly(os); FileData data = new FileData(); data.setFileName(fileName); data.setFileData(baos.toByteArray()); if (contentType != null) { data.setContentType(contentType); } return data; } } private class DataRequestCallback<T> implements RequestCallback { private List<MediaType> mediaTypes = asList(APPLICATION_JSON, valueOf("application/*+json")); private HttpEntity<T> requestEntity; public DataRequestCallback(T entity) { requestEntity = new HttpEntity<>(entity); } @SuppressWarnings("unchecked") @Override public void doWithRequest(ClientHttpRequest httpRequest) throws IOException { httpRequest.getHeaders().setAccept(mediaTypes); T requestBody = requestEntity.getBody(); Class<?> requestType = requestBody.getClass(); HttpHeaders requestHeaders = requestEntity.getHeaders(); MediaType requestContentType = requestHeaders.getContentType(); for (HttpMessageConverter<?> messageConverter : restTemplate.getMessageConverters()) { if (messageConverter.canWrite(requestType, requestContentType)) { if (!requestHeaders.isEmpty()) { httpRequest.getHeaders().putAll(requestHeaders); } ((HttpMessageConverter<Object>) messageConverter).write(requestBody, requestContentType, httpRequest); return; } } } } }