/** * Copyright © 2016-2026 The Thingsboard Authors * * 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.thingsboard.rest.client; import com.auth0.jwt.JWT; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.node.ObjectNode; import com.google.common.base.Strings; import lombok.Getter; import lombok.SneakyThrows; import org.apache.commons.io.IOUtils; import org.apache.commons.lang3.concurrent.LazyInitializer; import org.apache.hc.core5.net.URIBuilder; import org.springframework.core.ParameterizedTypeReference; import org.springframework.core.io.ByteArrayResource; import org.springframework.core.io.Resource; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.HttpRequest; import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.http.client.support.HttpRequestWrapper; import org.springframework.util.CollectionUtils; import org.springframework.util.LinkedMultiValueMap; import org.springframework.util.MultiValueMap; import org.springframework.web.client.HttpClientErrorException; import org.springframework.web.client.RestTemplate; import org.springframework.web.util.UriComponentsBuilder; import org.thingsboard.common.util.JacksonUtil; import org.thingsboard.common.util.ThingsBoardExecutors; import org.thingsboard.rest.client.utils.RestJsonConverter; import org.thingsboard.server.common.data.AdminSettings; import org.thingsboard.server.common.data.AttributeScope; import org.thingsboard.server.common.data.ClaimRequest; import org.thingsboard.server.common.data.Customer; import org.thingsboard.server.common.data.Dashboard; import org.thingsboard.server.common.data.DashboardInfo; import org.thingsboard.server.common.data.Device; import org.thingsboard.server.common.data.DeviceInfo; import org.thingsboard.server.common.data.DeviceProfile; import org.thingsboard.server.common.data.DeviceProfileInfo; import org.thingsboard.server.common.data.DeviceTransportType; import org.thingsboard.server.common.data.EntityInfo; import org.thingsboard.server.common.data.EntitySubtype; import org.thingsboard.server.common.data.EntityType; import org.thingsboard.server.common.data.EntityView; import org.thingsboard.server.common.data.EntityViewInfo; import org.thingsboard.server.common.data.EventInfo; import org.thingsboard.server.common.data.OtaPackage; import org.thingsboard.server.common.data.OtaPackageInfo; import org.thingsboard.server.common.data.ResourceExportData; import org.thingsboard.server.common.data.ResourceSubType; import org.thingsboard.server.common.data.SaveDeviceWithCredentialsRequest; import org.thingsboard.server.common.data.StringUtils; import org.thingsboard.server.common.data.SystemInfo; import org.thingsboard.server.common.data.TbImageDeleteResult; import org.thingsboard.server.common.data.TbResource; import org.thingsboard.server.common.data.TbResourceInfo; import org.thingsboard.server.common.data.Tenant; import org.thingsboard.server.common.data.TenantInfo; import org.thingsboard.server.common.data.TenantProfile; import org.thingsboard.server.common.data.UpdateMessage; import org.thingsboard.server.common.data.UsageInfo; import org.thingsboard.server.common.data.User; import org.thingsboard.server.common.data.UserEmailInfo; import org.thingsboard.server.common.data.ai.AiModel; import org.thingsboard.server.common.data.alarm.Alarm; import org.thingsboard.server.common.data.alarm.AlarmComment; import org.thingsboard.server.common.data.alarm.AlarmCommentInfo; import org.thingsboard.server.common.data.alarm.AlarmInfo; import org.thingsboard.server.common.data.alarm.AlarmSearchStatus; import org.thingsboard.server.common.data.alarm.AlarmSeverity; import org.thingsboard.server.common.data.alarm.AlarmStatus; import org.thingsboard.server.common.data.asset.Asset; import org.thingsboard.server.common.data.asset.AssetInfo; import org.thingsboard.server.common.data.asset.AssetProfile; import org.thingsboard.server.common.data.asset.AssetProfileInfo; import org.thingsboard.server.common.data.asset.AssetSearchQuery; import org.thingsboard.server.common.data.audit.ActionType; import org.thingsboard.server.common.data.audit.AuditLog; import org.thingsboard.server.common.data.cf.CalculatedField; import org.thingsboard.server.common.data.cf.CalculatedFieldInfo; import org.thingsboard.server.common.data.cf.CalculatedFieldType; import org.thingsboard.server.common.data.device.DeviceSearchQuery; import org.thingsboard.server.common.data.domain.Domain; import org.thingsboard.server.common.data.domain.DomainInfo; import org.thingsboard.server.common.data.edge.Edge; import org.thingsboard.server.common.data.edge.EdgeEvent; import org.thingsboard.server.common.data.edge.EdgeInfo; import org.thingsboard.server.common.data.edge.EdgeInstructions; import org.thingsboard.server.common.data.edge.EdgeSearchQuery; import org.thingsboard.server.common.data.entityview.EntityViewSearchQuery; import org.thingsboard.server.common.data.id.AiModelId; import org.thingsboard.server.common.data.id.AlarmCommentId; import org.thingsboard.server.common.data.id.AlarmId; import org.thingsboard.server.common.data.id.ApiKeyId; import org.thingsboard.server.common.data.id.AssetId; import org.thingsboard.server.common.data.id.AssetProfileId; import org.thingsboard.server.common.data.id.CalculatedFieldId; import org.thingsboard.server.common.data.id.CustomerId; import org.thingsboard.server.common.data.id.DashboardId; import org.thingsboard.server.common.data.id.DeviceId; import org.thingsboard.server.common.data.id.DeviceProfileId; import org.thingsboard.server.common.data.id.DomainId; import org.thingsboard.server.common.data.id.EdgeId; import org.thingsboard.server.common.data.id.EntityId; import org.thingsboard.server.common.data.id.EntityViewId; import org.thingsboard.server.common.data.id.MobileAppBundleId; import org.thingsboard.server.common.data.id.MobileAppId; import org.thingsboard.server.common.data.id.NotificationId; import org.thingsboard.server.common.data.id.NotificationRequestId; import org.thingsboard.server.common.data.id.OAuth2ClientId; import org.thingsboard.server.common.data.id.OAuth2ClientRegistrationTemplateId; import org.thingsboard.server.common.data.id.OtaPackageId; import org.thingsboard.server.common.data.id.QueueId; import org.thingsboard.server.common.data.id.RuleChainId; import org.thingsboard.server.common.data.id.RuleNodeId; import org.thingsboard.server.common.data.id.TbResourceId; import org.thingsboard.server.common.data.id.TenantId; import org.thingsboard.server.common.data.id.TenantProfileId; import org.thingsboard.server.common.data.id.UserId; import org.thingsboard.server.common.data.id.WidgetTypeId; import org.thingsboard.server.common.data.id.WidgetsBundleId; import org.thingsboard.server.common.data.kv.Aggregation; import org.thingsboard.server.common.data.kv.AttributeKvEntry; import org.thingsboard.server.common.data.kv.IntervalType; import org.thingsboard.server.common.data.kv.TsKvEntry; import org.thingsboard.server.common.data.mobile.app.MobileApp; import org.thingsboard.server.common.data.mobile.bundle.MobileAppBundle; import org.thingsboard.server.common.data.mobile.bundle.MobileAppBundleInfo; import org.thingsboard.server.common.data.notification.Notification; import org.thingsboard.server.common.data.notification.NotificationDeliveryMethod; import org.thingsboard.server.common.data.notification.NotificationRequest; import org.thingsboard.server.common.data.notification.NotificationRequestInfo; import org.thingsboard.server.common.data.notification.NotificationRequestPreview; import org.thingsboard.server.common.data.notification.settings.NotificationSettings; import org.thingsboard.server.common.data.notification.settings.UserNotificationSettings; import org.thingsboard.server.common.data.notification.targets.NotificationTarget; import org.thingsboard.server.common.data.notification.template.NotificationTemplate; import org.thingsboard.server.common.data.oauth2.OAuth2Client; import org.thingsboard.server.common.data.oauth2.OAuth2ClientInfo; import org.thingsboard.server.common.data.oauth2.OAuth2ClientLoginInfo; import org.thingsboard.server.common.data.oauth2.OAuth2ClientRegistrationTemplate; import org.thingsboard.server.common.data.oauth2.PlatformType; import org.thingsboard.server.common.data.ota.ChecksumAlgorithm; import org.thingsboard.server.common.data.ota.OtaPackageType; import org.thingsboard.server.common.data.page.PageData; import org.thingsboard.server.common.data.page.PageLink; import org.thingsboard.server.common.data.page.SortOrder; import org.thingsboard.server.common.data.page.TimePageLink; import org.thingsboard.server.common.data.pat.ApiKey; import org.thingsboard.server.common.data.pat.ApiKeyInfo; import org.thingsboard.server.common.data.plugin.ComponentDescriptor; import org.thingsboard.server.common.data.plugin.ComponentType; import org.thingsboard.server.common.data.query.AlarmCountQuery; import org.thingsboard.server.common.data.query.AlarmData; import org.thingsboard.server.common.data.query.AlarmDataQuery; import org.thingsboard.server.common.data.query.AvailableEntityKeys; import org.thingsboard.server.common.data.query.AvailableEntityKeysV2; import org.thingsboard.server.common.data.query.EntityCountQuery; import org.thingsboard.server.common.data.query.EntityData; import org.thingsboard.server.common.data.query.EntityDataQuery; import org.thingsboard.server.common.data.queue.Queue; import org.thingsboard.server.common.data.relation.EntityRelation; import org.thingsboard.server.common.data.relation.EntityRelationInfo; import org.thingsboard.server.common.data.relation.EntityRelationsQuery; import org.thingsboard.server.common.data.relation.RelationTypeGroup; import org.thingsboard.server.common.data.rule.DefaultRuleChainCreateRequest; import org.thingsboard.server.common.data.rule.RuleChain; import org.thingsboard.server.common.data.rule.RuleChainData; import org.thingsboard.server.common.data.rule.RuleChainMetaData; import org.thingsboard.server.common.data.rule.RuleChainType; import org.thingsboard.server.common.data.security.DeviceCredentials; import org.thingsboard.server.common.data.security.DeviceCredentialsType; import org.thingsboard.server.common.data.security.model.JwtPair; import org.thingsboard.server.common.data.security.model.JwtSettings; import org.thingsboard.server.common.data.security.model.SecuritySettings; import org.thingsboard.server.common.data.security.model.UserPasswordPolicy; import org.thingsboard.server.common.data.sms.config.TestSmsRequest; import org.thingsboard.server.common.data.sync.ie.importing.csv.BulkImportRequest; import org.thingsboard.server.common.data.sync.ie.importing.csv.BulkImportResult; import org.thingsboard.server.common.data.sync.vc.AutoCommitSettings; import org.thingsboard.server.common.data.sync.vc.BranchInfo; import org.thingsboard.server.common.data.sync.vc.EntityDataDiff; import org.thingsboard.server.common.data.sync.vc.EntityDataInfo; import org.thingsboard.server.common.data.sync.vc.EntityVersion; import org.thingsboard.server.common.data.sync.vc.RepositorySettings; import org.thingsboard.server.common.data.sync.vc.VersionCreationResult; import org.thingsboard.server.common.data.sync.vc.VersionLoadResult; import org.thingsboard.server.common.data.sync.vc.VersionedEntityInfo; import org.thingsboard.server.common.data.sync.vc.request.create.VersionCreateRequest; import org.thingsboard.server.common.data.sync.vc.request.load.VersionLoadRequest; import org.thingsboard.server.common.data.widget.DeprecatedFilter; import org.thingsboard.server.common.data.widget.WidgetType; import org.thingsboard.server.common.data.widget.WidgetTypeDetails; import org.thingsboard.server.common.data.widget.WidgetTypeInfo; import org.thingsboard.server.common.data.widget.WidgetsBundle; import java.io.Closeable; import java.io.IOException; import java.net.URI; import java.net.URISyntaxException; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.Set; import java.util.UUID; import java.util.concurrent.ExecutorService; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; import static java.util.stream.Collectors.joining; import static org.thingsboard.server.common.data.StringUtils.isEmpty; public class RestClient implements Closeable { private static final String TOKEN_HEADER_PARAM = "X-Authorization"; private static final long AVG_REQUEST_TIMEOUT = TimeUnit.SECONDS.toMillis(30); protected static final String ACTIVATE_TOKEN_REGEX = "/api/noauth/activate?activateToken="; private final LazyInitializer executor = LazyInitializer.builder() .setInitializer(() -> ThingsBoardExecutors.newWorkStealingPool(10, getClass())) .get(); @Getter protected final RestTemplate restTemplate; protected final RestTemplate loginRestTemplate; protected final String baseURL; private String username; private String password; private String mainToken; @Getter private String refreshToken; private long mainTokenExpTs; private long refreshTokenExpTs; private long clientServerTimeDiff; public enum AuthType {JWT, API_KEY} public RestClient(String baseURL) { this(new RestTemplate(), baseURL); } public RestClient(RestTemplate restTemplate, String baseURL) { this(restTemplate, baseURL, AuthType.JWT, null); } public RestClient(RestTemplate restTemplate, String baseURL, String accessToken) { this(restTemplate, baseURL, AuthType.JWT, accessToken); } public RestClient(RestTemplate restTemplate, String baseURL, AuthType authType, String token) { this.restTemplate = restTemplate; this.loginRestTemplate = new RestTemplate(restTemplate.getRequestFactory()); this.baseURL = baseURL; this.restTemplate.getInterceptors().add((request, bytes, execution) -> { HttpRequest wrapper = new HttpRequestWrapper(request); switch (authType) { case JWT -> { if (token == null) { long calculatedTs = System.currentTimeMillis() + clientServerTimeDiff + AVG_REQUEST_TIMEOUT; if (calculatedTs > mainTokenExpTs) { synchronized (RestClient.this) { if (calculatedTs > mainTokenExpTs) { if (calculatedTs < refreshTokenExpTs) { refreshToken(); } else { doLogin(); } } } } } else { mainToken = token; } wrapper.getHeaders().set(TOKEN_HEADER_PARAM, "Bearer " + mainToken); } case API_KEY -> { wrapper.getHeaders().set(TOKEN_HEADER_PARAM, "ApiKey " + token); } } return execution.execute(wrapper, bytes); }); } public static RestClient withApiKey(String baseURL, String token) { return withApiKey(new RestTemplate(), baseURL, token); } public static RestClient withApiKey(RestTemplate rt, String baseURL, String token) { return new RestClient(rt, baseURL, AuthType.API_KEY, token); } public String getToken() { return mainToken; } public void refreshToken() { Map refreshTokenRequest = new HashMap<>(); refreshTokenRequest.put("refreshToken", refreshToken); long ts = System.currentTimeMillis(); ResponseEntity tokenInfo = loginRestTemplate.postForEntity(baseURL + "/api/auth/token", refreshTokenRequest, JsonNode.class); setTokenInfo(ts, tokenInfo.getBody()); } public void login(String username, String password) { this.username = username; this.password = password; doLogin(); } private void doLogin() { long ts = System.currentTimeMillis(); Map loginRequest = new HashMap<>(); loginRequest.put("username", username); loginRequest.put("password", password); ResponseEntity tokenInfo = loginRestTemplate.postForEntity(baseURL + "/api/auth/login", loginRequest, JsonNode.class); setTokenInfo(ts, tokenInfo.getBody()); } private synchronized void setTokenInfo(long ts, JsonNode tokenInfo) { this.mainToken = tokenInfo.get("token").asText(); this.refreshToken = tokenInfo.get("refreshToken").asText(); this.mainTokenExpTs = JWT.decode(this.mainToken).getExpiresAtAsInstant().toEpochMilli(); this.refreshTokenExpTs = JWT.decode(refreshToken).getExpiresAtAsInstant().toEpochMilli(); this.clientServerTimeDiff = JWT.decode(this.mainToken).getIssuedAtAsInstant().toEpochMilli() - ts; } public Optional getAdminSettings(String key) { try { ResponseEntity adminSettings = restTemplate.getForEntity(baseURL + "/api/admin/settings/{key}", AdminSettings.class, key); return Optional.ofNullable(adminSettings.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public AdminSettings saveAdminSettings(AdminSettings adminSettings) { return restTemplate.postForEntity(baseURL + "/api/admin/settings", adminSettings, AdminSettings.class).getBody(); } public void sendTestMail(AdminSettings adminSettings) { restTemplate.postForLocation(baseURL + "/api/admin/settings/testMail", adminSettings); } public void sendTestSms(TestSmsRequest testSmsRequest) { restTemplate.postForLocation(baseURL + "/api/admin/settings/testSms", testSmsRequest); } public Optional getSecuritySettings() { try { ResponseEntity securitySettings = restTemplate.getForEntity(baseURL + "/api/admin/securitySettings", SecuritySettings.class); return Optional.ofNullable(securitySettings.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public SecuritySettings saveSecuritySettings(SecuritySettings securitySettings) { return restTemplate.postForEntity(baseURL + "/api/admin/securitySettings", securitySettings, SecuritySettings.class).getBody(); } public Optional getJwtSettings() { try { ResponseEntity jwtSettings = restTemplate.getForEntity(baseURL + "/api/admin/jwtSettings", JwtSettings.class); return Optional.ofNullable(jwtSettings.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public JwtPair saveJwtSettings(JwtSettings jwtSettings) { return restTemplate.postForEntity(baseURL + "/api/admin/jwtSettings", jwtSettings, JwtPair.class).getBody(); } public Optional getRepositorySettings() { try { ResponseEntity repositorySettings = restTemplate.getForEntity(baseURL + "/api/admin/repositorySettings", RepositorySettings.class); return Optional.ofNullable(repositorySettings.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Boolean repositorySettingsExists() { return restTemplate.getForEntity(baseURL + "/api/admin/repositorySettings/exists", Boolean.class).getBody(); } public RepositorySettings saveRepositorySettings(RepositorySettings repositorySettings) { return restTemplate.postForEntity(baseURL + "/api/admin/repositorySettings", repositorySettings, RepositorySettings.class).getBody(); } public void deleteRepositorySettings() { restTemplate.delete(baseURL + "/api/admin/repositorySettings"); } public void checkRepositoryAccess(RepositorySettings repositorySettings) { restTemplate.postForLocation(baseURL + "/api/admin/repositorySettings/checkAccess", repositorySettings); } public Optional getAutoCommitSettings() { try { ResponseEntity autoCommitSettings = restTemplate.getForEntity(baseURL + "/api/admin/autoCommitSettings", AutoCommitSettings.class); return Optional.ofNullable(autoCommitSettings.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Boolean autoCommitSettingsExists() { return restTemplate.getForEntity(baseURL + "/api/admin/autoCommitSettings/exists", Boolean.class).getBody(); } public AutoCommitSettings saveAutoCommitSettings(AutoCommitSettings autoCommitSettings) { return restTemplate.postForEntity(baseURL + "/api/admin/autoCommitSettings", autoCommitSettings, AutoCommitSettings.class).getBody(); } public void deleteAutoCommitSettings() { restTemplate.delete(baseURL + "/api/admin/autoCommitSettings"); } public Optional checkUpdates() { try { ResponseEntity updateMsg = restTemplate.getForEntity(baseURL + "/api/admin/updates", UpdateMessage.class); return Optional.ofNullable(updateMsg.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public SystemInfo getSystemInfo() { return restTemplate.getForEntity(baseURL + "/api/admin/systemInfo", SystemInfo.class).getBody(); } public Optional getAlarmById(AlarmId alarmId) { try { ResponseEntity alarm = restTemplate.getForEntity(baseURL + "/api/alarm/{alarmId}", Alarm.class, alarmId.getId()); return Optional.ofNullable(alarm.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getAlarmInfoById(AlarmId alarmId) { try { ResponseEntity alarmInfo = restTemplate.getForEntity(baseURL + "/api/alarm/info/{alarmId}", AlarmInfo.class, alarmId.getId()); return Optional.ofNullable(alarmInfo.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Alarm saveAlarm(Alarm alarm) { return restTemplate.postForEntity(baseURL + "/api/alarm", alarm, Alarm.class).getBody(); } public void deleteAlarm(AlarmId alarmId) { restTemplate.delete(baseURL + "/api/alarm/{alarmId}", alarmId.getId()); } public void ackAlarm(AlarmId alarmId) { restTemplate.postForLocation(baseURL + "/api/alarm/{alarmId}/ack", null, alarmId.getId()); } public void clearAlarm(AlarmId alarmId) { restTemplate.postForLocation(baseURL + "/api/alarm/{alarmId}/clear", null, alarmId.getId()); } public void assignAlarm(AlarmId alarmId, UserId userId) { restTemplate.postForLocation(baseURL + "/api/alarm/{alarmId}/assign/{userId}", null, alarmId.getId(), userId.getId()); } public void unassignAlarm(AlarmId alarmId) { restTemplate.delete(baseURL + "/api/alarm/{alarmId}/assign", alarmId.getId()); } public PageData getAlarms(EntityId entityId, AlarmSearchStatus searchStatus, AlarmStatus status, TimePageLink pageLink, Boolean fetchOriginator) { String urlSecondPart = "/api/alarm/{entityType}/{entityId}?fetchOriginator={fetchOriginator}"; Map params = new HashMap<>(); params.put("entityType", entityId.getEntityType().name()); params.put("entityId", entityId.getId().toString()); params.put("fetchOriginator", String.valueOf(fetchOriginator)); if (searchStatus != null) { params.put("searchStatus", searchStatus.name()); urlSecondPart += "&searchStatus={searchStatus}"; } if (status != null) { params.put("status", status.name()); urlSecondPart += "&status={status}"; } addTimePageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + urlSecondPart + "&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getAllAlarms(AlarmSearchStatus searchStatus, AlarmStatus status, TimePageLink pageLink, Boolean fetchOriginator) { String urlSecondPart = "/api/alarms?"; Map params = new HashMap<>(); if (fetchOriginator != null) { params.put("fetchOriginator", String.valueOf(fetchOriginator)); urlSecondPart += "&fetchOriginator={fetchOriginator}"; } if (searchStatus != null) { params.put("searchStatus", searchStatus.name()); urlSecondPart += "&searchStatus={searchStatus}"; } if (status != null) { params.put("status", status.name()); urlSecondPart += "&status={status}"; } addTimePageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + urlSecondPart + "&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getAlarmsV2(EntityId entityId, List statusList, List severityList, List typeList, String assignedId, TimePageLink pageLink) { String urlSecondPart = "/api/v2/alarm/{entityType}/{entityId}?"; Map params = new HashMap<>(); params.put("entityType", entityId.getEntityType().name()); params.put("entityId", entityId.getId().toString()); if (!CollectionUtils.isEmpty(statusList)) { params.put("statusList", listEnumToString(statusList)); urlSecondPart += "&statusList={statusList}"; } if (!CollectionUtils.isEmpty(severityList)) { params.put("severityList", listEnumToString(severityList)); urlSecondPart += "&severityList={severityList}"; } if (!CollectionUtils.isEmpty(typeList)) { params.put("typeList", String.join(",", typeList)); urlSecondPart += "&typeList={typeList}"; } if (assignedId != null) { params.put("assignedId", assignedId); urlSecondPart += "&assignedId={assignedId}"; } addTimePageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + urlSecondPart + "&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getAllAlarmsV2(List statusList, List severityList, List typeList, String assignedId, TimePageLink pageLink) { String urlSecondPart = "/api/v2/alarms?"; Map params = new HashMap<>(); if (!CollectionUtils.isEmpty(statusList)) { params.put("statusList", listEnumToString(statusList)); urlSecondPart += "&statusList={statusList}"; } if (!CollectionUtils.isEmpty(severityList)) { params.put("severityList", listEnumToString(severityList)); urlSecondPart += "&severityList={severityList}"; } if (!CollectionUtils.isEmpty(typeList)) { params.put("typeList", String.join(",", typeList)); urlSecondPart += "&typeList={typeList}"; } if (assignedId != null) { params.put("assignedId", assignedId); urlSecondPart += "&assignedId={assignedId}"; } addTimePageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + urlSecondPart + "&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional getHighestAlarmSeverity(EntityId entityId, AlarmSearchStatus searchStatus, AlarmStatus status) { Map params = new HashMap<>(); params.put("entityType", entityId.getEntityType().name()); params.put("entityId", entityId.getId().toString()); params.put("searchStatus", searchStatus.name()); params.put("status", status.name()); try { ResponseEntity alarmSeverity = restTemplate.getForEntity(baseURL + "/api/alarm/highestSeverity/{entityType}/{entityId}?searchStatus={searchStatus}&status={status}", AlarmSeverity.class, params); return Optional.ofNullable(alarmSeverity.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } @Deprecated public Alarm createAlarm(Alarm alarm) { return restTemplate.postForEntity(baseURL + "/api/alarm", alarm, Alarm.class).getBody(); } public PageData getAlarmTypes(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/alarm/types?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public AlarmComment saveAlarmComment(AlarmId alarmId, AlarmComment alarmComment) { return restTemplate.postForEntity(baseURL + "/api/alarm/{alarmId}/comment", alarmComment, AlarmComment.class, alarmId.getId()).getBody(); } public void deleteAlarmComment(AlarmId alarmId, AlarmCommentId alarmCommentId) { restTemplate.delete(baseURL + "/api/alarm/{alarmId}/comment/{alarmCommentId}", alarmId.getId(), alarmCommentId.getId()); } public PageData getAlarmComments(AlarmId alarmId, PageLink pageLink) { Map params = new HashMap<>(); params.put("alarmId", alarmId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/alarm/{alarmId}/comment?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional getAssetById(AssetId assetId) { try { ResponseEntity asset = restTemplate.getForEntity(baseURL + "/api/asset/{assetId}", Asset.class, assetId.getId()); return Optional.ofNullable(asset.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getAssetInfoById(AssetId assetId) { try { ResponseEntity asset = restTemplate.getForEntity(baseURL + "/api/asset/info/{assetId}", AssetInfo.class, assetId.getId()); return Optional.ofNullable(asset.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Asset saveAsset(Asset asset) { return restTemplate.postForEntity(baseURL + "/api/asset", asset, Asset.class).getBody(); } public void deleteAsset(AssetId assetId) { restTemplate.delete(baseURL + "/api/asset/{assetId}", assetId.getId()); } public Optional assignAssetToCustomer(CustomerId customerId, AssetId assetId) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); params.put("assetId", assetId.getId().toString()); try { ResponseEntity asset = restTemplate.postForEntity(baseURL + "/api/customer/{customerId}/asset/{assetId}", null, Asset.class, params); return Optional.ofNullable(asset.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignAssetFromCustomer(AssetId assetId) { try { ResponseEntity asset = restTemplate.exchange(baseURL + "/api/customer/asset/{assetId}", HttpMethod.DELETE, HttpEntity.EMPTY, Asset.class, assetId.getId()); return Optional.ofNullable(asset.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional assignAssetToPublicCustomer(AssetId assetId) { try { ResponseEntity asset = restTemplate.postForEntity(baseURL + "/api/customer/public/asset/{assetId}", null, Asset.class, assetId.getId()); return Optional.ofNullable(asset.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getTenantAssets(PageLink pageLink, String assetType) { Map params = new HashMap<>(); params.put("type", assetType); addPageLinkToParam(params, pageLink); ResponseEntity> assets = restTemplate.exchange( baseURL + "/api/tenant/assets?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params); return assets.getBody(); } public PageData getTenantAssetInfos(String type, AssetProfileId assetProfileId, PageLink pageLink) { Map params = new HashMap<>(); params.put("type", type); params.put("assetProfileId", assetProfileId != null ? assetProfileId.toString() : null); addPageLinkToParam(params, pageLink); ResponseEntity> assets = restTemplate.exchange( baseURL + "/api/tenant/assetInfos?type={type}&assetProfileId={assetProfileId}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params); return assets.getBody(); } public Optional getTenantAsset(String assetName) { try { ResponseEntity asset = restTemplate.getForEntity(baseURL + "/api/tenant/assets?assetName={assetName}", Asset.class, assetName); return Optional.ofNullable(asset.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getCustomerAssets(CustomerId customerId, PageLink pageLink, String assetType) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); params.put("type", assetType); addPageLinkToParam(params, pageLink); ResponseEntity> assets = restTemplate.exchange( baseURL + "/api/customer/{customerId}/assets?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params); return assets.getBody(); } public PageData getCustomerAssetInfos(CustomerId customerId, String assetType, AssetProfileId assetProfileId, PageLink pageLink) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); params.put("type", assetType); params.put("assetProfileId", assetProfileId != null ? assetProfileId.toString() : null); addPageLinkToParam(params, pageLink); ResponseEntity> assets = restTemplate.exchange( baseURL + "/api/customer/{customerId}/assetInfos?type={type}&assetProfileId={assetProfileId}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params); return assets.getBody(); } public List getAssetsByIds(List assetIds) { return restTemplate.exchange( baseURL + "/api/assets?assetIds={assetIds}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, listIdsToString(assetIds)) .getBody(); } public List findByQuery(AssetSearchQuery query) { return restTemplate.exchange( URI.create(baseURL + "/api/assets"), HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference>() { }).getBody(); } @Deprecated(since = "3.6.2") public List getAssetTypes() { return restTemplate.exchange(URI.create( baseURL + "/api/asset/types"), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public List getAssetProfileNames(boolean activeOnly) { return restTemplate.exchange( baseURL + "/api/assetProfile/names?activeOnly={activeOnly}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, activeOnly).getBody(); } public BulkImportResult processAssetsBulkImport(BulkImportRequest request) { return restTemplate.exchange( baseURL + "/api/asset/bulk_import", HttpMethod.POST, new HttpEntity<>(request), new ParameterizedTypeReference>() { }).getBody(); } @Deprecated public Optional findAsset(String name) { Map params = new HashMap(); params.put("assetName", name); try { ResponseEntity assetEntity = restTemplate.getForEntity(baseURL + "/api/tenant/assets?assetName={assetName}", Asset.class, params); return Optional.of(assetEntity.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } @Deprecated public Asset createAsset(Asset asset) { return restTemplate.postForEntity(baseURL + "/api/asset", asset, Asset.class).getBody(); } @Deprecated public Asset createAsset(String name, String type) { Asset asset = new Asset(); asset.setName(name); asset.setType(type); return restTemplate.postForEntity(baseURL + "/api/asset", asset, Asset.class).getBody(); } @Deprecated public Asset assignAsset(CustomerId customerId, AssetId assetId) { return restTemplate.postForEntity(baseURL + "/api/customer/{customerId}/asset/{assetId}", HttpEntity.EMPTY, Asset.class, customerId.toString(), assetId.toString()).getBody(); } public PageData getAuditLogsByCustomerId(CustomerId customerId, TimePageLink pageLink, List actionTypes) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); params.put("actionTypes", listEnumToString(actionTypes)); addTimePageLinkToParam(params, pageLink); ResponseEntity> auditLog = restTemplate.exchange( baseURL + "/api/audit/logs/customer/{customerId}?actionTypes={actionTypes}&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params); return auditLog.getBody(); } public PageData getAuditLogsByUserId(UserId userId, TimePageLink pageLink, List actionTypes) { Map params = new HashMap<>(); params.put("userId", userId.getId().toString()); params.put("actionTypes", listEnumToString(actionTypes)); addTimePageLinkToParam(params, pageLink); ResponseEntity> auditLog = restTemplate.exchange( baseURL + "/api/audit/logs/user/{userId}?actionTypes={actionTypes}&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params); return auditLog.getBody(); } public PageData getAuditLogsByEntityId(EntityId entityId, List actionTypes, TimePageLink pageLink) { Map params = new HashMap<>(); params.put("entityType", entityId.getEntityType().name()); params.put("entityId", entityId.getId().toString()); params.put("actionTypes", listEnumToString(actionTypes)); addTimePageLinkToParam(params, pageLink); ResponseEntity> auditLog = restTemplate.exchange( baseURL + "/api/audit/logs/entity/{entityType}/{entityId}?actionTypes={actionTypes}&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params); return auditLog.getBody(); } public PageData getAuditLogs(TimePageLink pageLink, List actionTypes) { Map params = new HashMap<>(); params.put("actionTypes", listEnumToString(actionTypes)); addTimePageLinkToParam(params, pageLink); ResponseEntity> auditLog = restTemplate.exchange( baseURL + "/api/audit/logs?actionTypes={actionTypes}&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params); return auditLog.getBody(); } public String getActivateToken(UserId userId) { String activationLink = getActivationLink(userId); return activationLink.substring(activationLink.lastIndexOf(ACTIVATE_TOKEN_REGEX) + ACTIVATE_TOKEN_REGEX.length()); } public Optional getUser() { ResponseEntity user = restTemplate.getForEntity(baseURL + "/api/auth/user", User.class); return Optional.ofNullable(user.getBody()); } public void logout() { restTemplate.postForLocation(baseURL + "/api/auth/logout", null); } public void changePassword(String currentPassword, String newPassword) { ObjectNode changePasswordRequest = JacksonUtil.newObjectNode(); changePasswordRequest.put("currentPassword", currentPassword); changePasswordRequest.put("newPassword", newPassword); restTemplate.postForLocation(baseURL + "/api/auth/changePassword", changePasswordRequest); } public Optional getUserPasswordPolicy() { try { ResponseEntity userPasswordPolicy = restTemplate.getForEntity(baseURL + "/api/noauth/userPasswordPolicy", UserPasswordPolicy.class); return Optional.ofNullable(userPasswordPolicy.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public ResponseEntity checkActivateToken(UserId userId) { String activateToken = getActivateToken(userId); return restTemplate.getForEntity(baseURL + "/api/noauth/activate?activateToken={activateToken}", String.class, activateToken); } public void requestResetPasswordByEmail(String email) { ObjectNode resetPasswordByEmailRequest = JacksonUtil.newObjectNode(); resetPasswordByEmailRequest.put("email", email); restTemplate.postForLocation(baseURL + "/api/noauth/resetPasswordByEmail", resetPasswordByEmailRequest); } public Optional activateUser(UserId userId, String password) { return activateUser(userId, password, true); } public Optional activateUser(UserId userId, String password, boolean sendActivationMail) { ObjectNode activateRequest = JacksonUtil.newObjectNode(); activateRequest.put("activateToken", getActivateToken(userId)); activateRequest.put("password", password); try { ResponseEntity jsonNode = restTemplate.postForEntity(baseURL + "/api/noauth/activate?sendActivationMail={sendActivationMail}", activateRequest, JsonNode.class, sendActivationMail); return Optional.ofNullable(jsonNode.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getComponentDescriptorByClazz(String componentDescriptorClazz) { try { ResponseEntity componentDescriptor = restTemplate.getForEntity(baseURL + "/api/component/{componentDescriptorClazz}", ComponentDescriptor.class, componentDescriptorClazz); return Optional.ofNullable(componentDescriptor.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public List getComponentDescriptorsByType(ComponentType componentType) { return getComponentDescriptorsByType(componentType, RuleChainType.CORE); } public List getComponentDescriptorsByType(ComponentType componentType, RuleChainType ruleChainType) { return restTemplate.exchange( baseURL + "/api/components/" + componentType.name() + "/?ruleChainType={ruleChainType}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, ruleChainType).getBody(); } public List getComponentDescriptorsByTypes(List componentTypes) { return getComponentDescriptorsByTypes(componentTypes, RuleChainType.CORE); } public List getComponentDescriptorsByTypes(List componentTypes, RuleChainType ruleChainType) { return restTemplate.exchange( baseURL + "/api/components?componentTypes={componentTypes}&ruleChainType={ruleChainType}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, listEnumToString(componentTypes), ruleChainType) .getBody(); } public Optional getCustomerById(CustomerId customerId) { try { ResponseEntity customer = restTemplate.getForEntity(baseURL + "/api/customer/{customerId}", Customer.class, customerId.getId()); return Optional.ofNullable(customer.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getShortCustomerInfoById(CustomerId customerId) { try { ResponseEntity customerInfo = restTemplate.getForEntity(baseURL + "/api/customer/{customerId}/shortInfo", JsonNode.class, customerId.getId()); return Optional.ofNullable(customerInfo.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public String getCustomerTitleById(CustomerId customerId) { return restTemplate.getForObject(baseURL + "/api/customer/{customerId}/title", String.class, customerId.getId()); } public Customer saveCustomer(Customer customer) { return restTemplate.postForEntity(baseURL + "/api/customer", customer, Customer.class).getBody(); } public void deleteCustomer(CustomerId customerId) { restTemplate.delete(baseURL + "/api/customer/{customerId}", customerId.getId()); } public PageData getCustomers(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); ResponseEntity> customer = restTemplate.exchange( baseURL + "/api/customers?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params); return customer.getBody(); } public Optional getTenantCustomer(String customerTitle) { try { ResponseEntity customer = restTemplate.getForEntity(baseURL + "/api/tenant/customers?customerTitle={customerTitle}", Customer.class, customerTitle); return Optional.ofNullable(customer.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } @Deprecated public Optional findCustomer(String title) { Map params = new HashMap<>(); params.put("customerTitle", title); try { ResponseEntity customerEntity = restTemplate.getForEntity(baseURL + "/api/tenant/customers?customerTitle={customerTitle}", Customer.class, params); return Optional.of(customerEntity.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } @Deprecated public Customer createCustomer(Customer customer) { return restTemplate.postForEntity(baseURL + "/api/customer", customer, Customer.class).getBody(); } @Deprecated public Customer createCustomer(String title) { Customer customer = new Customer(); customer.setTitle(title); return restTemplate.postForEntity(baseURL + "/api/customer", customer, Customer.class).getBody(); } public Long getServerTime() { return restTemplate.getForObject(baseURL + "/api/dashboard/serverTime", Long.class); } public Long getMaxDatapointsLimit() { return restTemplate.getForObject(baseURL + "/api/dashboard/maxDatapointsLimit", Long.class); } public Optional getDashboardInfoById(DashboardId dashboardId) { try { ResponseEntity dashboardInfo = restTemplate.getForEntity(baseURL + "/api/dashboard/info/{dashboardId}", DashboardInfo.class, dashboardId.getId()); return Optional.ofNullable(dashboardInfo.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getDashboardById(DashboardId dashboardId) { try { ResponseEntity dashboard = restTemplate.getForEntity(baseURL + "/api/dashboard/{dashboardId}", Dashboard.class, dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Dashboard saveDashboard(Dashboard dashboard) { return restTemplate.postForEntity(baseURL + "/api/dashboard", dashboard, Dashboard.class).getBody(); } public void deleteDashboard(DashboardId dashboardId) { restTemplate.delete(baseURL + "/api/dashboard/{dashboardId}", dashboardId.getId()); } public Optional assignDashboardToCustomer(CustomerId customerId, DashboardId dashboardId) { try { ResponseEntity dashboard = restTemplate.postForEntity(baseURL + "/api/customer/{customerId}/dashboard/{dashboardId}", null, Dashboard.class, customerId.getId(), dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignDashboardFromCustomer(CustomerId customerId, DashboardId dashboardId) { try { ResponseEntity dashboard = restTemplate.exchange(baseURL + "/api/customer/{customerId}/dashboard/{dashboardId}", HttpMethod.DELETE, HttpEntity.EMPTY, Dashboard.class, customerId.getId(), dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional updateDashboardCustomers(DashboardId dashboardId, List customerIds) { Object[] customerIdArray = customerIds.stream().map(customerId -> customerId.getId().toString()).toArray(); try { ResponseEntity dashboard = restTemplate.postForEntity(baseURL + "/api/dashboard/{dashboardId}/customers", customerIdArray, Dashboard.class, dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional addDashboardCustomers(DashboardId dashboardId, List customerIds) { Object[] customerIdArray = customerIds.stream().map(customerId -> customerId.getId().toString()).toArray(); try { ResponseEntity dashboard = restTemplate.postForEntity(baseURL + "/api/dashboard/{dashboardId}/customers/add", customerIdArray, Dashboard.class, dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional removeDashboardCustomers(DashboardId dashboardId, List customerIds) { Object[] customerIdArray = customerIds.stream().map(customerId -> customerId.getId().toString()).toArray(); try { ResponseEntity dashboard = restTemplate.postForEntity(baseURL + "/api/dashboard/{dashboardId}/customers/remove", customerIdArray, Dashboard.class, dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional assignDashboardToPublicCustomer(DashboardId dashboardId) { try { ResponseEntity dashboard = restTemplate.postForEntity(baseURL + "/api/customer/public/dashboard/{dashboardId}", null, Dashboard.class, dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignDashboardFromPublicCustomer(DashboardId dashboardId) { try { ResponseEntity dashboard = restTemplate.exchange(baseURL + "/api/customer/public/dashboard/{dashboardId}", HttpMethod.DELETE, HttpEntity.EMPTY, Dashboard.class, dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getTenantDashboards(TenantId tenantId, PageLink pageLink) { Map params = new HashMap<>(); params.put("tenantId", tenantId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenant/{tenantId}/dashboards?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getTenantDashboards(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenant/dashboards?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getCustomerDashboards(CustomerId customerId, PageLink pageLink) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/customer/{customerId}/dashboards?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } @Deprecated public Dashboard createDashboard(Dashboard dashboard) { return restTemplate.postForEntity(baseURL + "/api/dashboard", dashboard, Dashboard.class).getBody(); } @Deprecated public List findTenantDashboards() { try { ResponseEntity> dashboards = restTemplate.exchange(baseURL + "/api/tenant/dashboards?pageSize=100000", HttpMethod.GET, null, new ParameterizedTypeReference>() { }); return dashboards.getBody().getData(); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Collections.emptyList(); } else { throw exception; } } } public Optional getDeviceById(DeviceId deviceId) { try { ResponseEntity device = restTemplate.getForEntity(baseURL + "/api/device/{deviceId}", Device.class, deviceId.getId()); return Optional.ofNullable(device.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getDeviceInfoById(DeviceId deviceId) { try { ResponseEntity device = restTemplate.getForEntity(baseURL + "/api/device/info/{deviceId}", DeviceInfo.class, deviceId); return Optional.ofNullable(device.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Device saveDevice(Device device) { return saveDevice(device, null); } public Device saveDevice(Device device, String accessToken) { return restTemplate.postForEntity(baseURL + "/api/device?accessToken={accessToken}", device, Device.class, accessToken).getBody(); } public void deleteDevice(DeviceId deviceId) { restTemplate.delete(baseURL + "/api/device/{deviceId}", deviceId.getId()); } public Optional assignDeviceToCustomer(CustomerId customerId, DeviceId deviceId) { try { ResponseEntity device = restTemplate.postForEntity(baseURL + "/api/customer/{customerId}/device/{deviceId}", null, Device.class, customerId.getId(), deviceId.getId()); return Optional.ofNullable(device.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignDeviceFromCustomer(DeviceId deviceId) { try { ResponseEntity device = restTemplate.exchange(baseURL + "/api/customer/device/{deviceId}", HttpMethod.DELETE, HttpEntity.EMPTY, Device.class, deviceId.getId()); return Optional.ofNullable(device.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional assignDeviceToPublicCustomer(DeviceId deviceId) { try { ResponseEntity device = restTemplate.postForEntity(baseURL + "/api/customer/public/device/{deviceId}", null, Device.class, deviceId.getId()); return Optional.ofNullable(device.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getDeviceCredentialsByDeviceId(DeviceId deviceId) { try { ResponseEntity deviceCredentials = restTemplate.getForEntity(baseURL + "/api/device/{deviceId}/credentials", DeviceCredentials.class, deviceId.getId()); return Optional.ofNullable(deviceCredentials.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public DeviceCredentials saveDeviceCredentials(DeviceCredentials deviceCredentials) { return restTemplate.postForEntity(baseURL + "/api/device/credentials", deviceCredentials, DeviceCredentials.class).getBody(); } public Optional saveDeviceWithCredentials(Device device, DeviceCredentials credentials) { try { SaveDeviceWithCredentialsRequest request = new SaveDeviceWithCredentialsRequest(device, credentials); ResponseEntity deviceOpt = restTemplate.postForEntity(baseURL + "/api/device-with-credentials", request, Device.class); return Optional.ofNullable(deviceOpt.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getTenantDevices(String type, PageLink pageLink) { Map params = new HashMap<>(); params.put("type", type); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenant/devices?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getTenantDeviceInfos(String type, Boolean active, DeviceProfileId deviceProfileId, PageLink pageLink) { Map params = new HashMap<>(); params.put("type", type); params.put("deviceProfileId", deviceProfileId != null ? deviceProfileId.toString() : null); if (active != null) { params.put("active", active.toString()); } addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenant/deviceInfos?type={type}&deviceProfileId={deviceProfileId}&" + (active != null ? "active={active}&" : "") + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional getTenantDevice(String deviceName) { try { ResponseEntity device = restTemplate.getForEntity(baseURL + "/api/tenant/devices?deviceName={deviceName}", Device.class, deviceName); return Optional.ofNullable(device.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getCustomerDevices(CustomerId customerId, String deviceType, PageLink pageLink) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); params.put("type", deviceType); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/customer/{customerId}/devices?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getCustomerDeviceInfos(CustomerId customerId, String deviceType, DeviceProfileId deviceProfileId, PageLink pageLink) { Map params = new HashMap<>(); params.put("customerId", customerId.toString()); params.put("type", deviceType); params.put("deviceProfileId", deviceProfileId != null ? deviceProfileId.toString() : null); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/customer/{customerId}/devices?type={type}&deviceProfileId={deviceProfileId}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List getDevicesByIds(List deviceIds) { return restTemplate.exchange(baseURL + "/api/devices?deviceIds={deviceIds}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, listIdsToString(deviceIds)).getBody(); } public List findByQuery(DeviceSearchQuery query) { return restTemplate.exchange( baseURL + "/api/devices", HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference>() { }).getBody(); } @Deprecated(since = "3.6.2") public List getDeviceTypes() { return restTemplate.exchange( baseURL + "/api/device/types", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public List getDeviceProfileNames(boolean activeOnly) { return restTemplate.exchange( baseURL + "/api/deviceProfile/names?activeOnly={activeOnly}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, activeOnly).getBody(); } public List getDeviceProfileInfosByIds(Set ids) { URIBuilder builder; try { builder = new URIBuilder(baseURL); } catch (URISyntaxException e) { throw new IllegalArgumentException("Invalid base URL: " + baseURL, e); } builder.appendPath("/api/deviceProfileInfos"); String commaSeparatedIds = ids.stream() .filter(Objects::nonNull) .map(UUID::toString) .collect(joining(",")); builder.addParameter("deviceProfileIds", commaSeparatedIds); URI uri; try { uri = builder.build(); } catch (URISyntaxException e) { throw new IllegalStateException("Failed to construct API URI from base URL and provided params", e); } return restTemplate.exchange(uri, HttpMethod.GET, null, new ParameterizedTypeReference>() {}).getBody(); } public JsonNode claimDevice(String deviceName, ClaimRequest claimRequest) { return restTemplate.exchange( baseURL + "/api/customer/device/{deviceName}/claim", HttpMethod.POST, new HttpEntity<>(claimRequest), new ParameterizedTypeReference() { }, deviceName).getBody(); } public void reClaimDevice(String deviceName) { restTemplate.delete(baseURL + "/api/customer/device/{deviceName}/claim", deviceName); } public Device assignDeviceToTenant(TenantId tenantId, DeviceId deviceId) { return restTemplate.postForEntity( baseURL + "/api/tenant/{tenantId}/device/{deviceId}", HttpEntity.EMPTY, Device.class, tenantId, deviceId).getBody(); } public Long countByDeviceProfileAndEmptyOtaPackage(OtaPackageType otaPackageType, DeviceProfileId deviceProfileId) { Map params = new HashMap<>(); params.put("otaPackageType", otaPackageType.name()); params.put("deviceProfileId", deviceProfileId.getId().toString()); return restTemplate.exchange( baseURL + "/api/devices/count/{otaPackageType}/{deviceProfileId}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference() { }, params ).getBody(); } public BulkImportResult processDevicesBulkImport(BulkImportRequest request) { return restTemplate.exchange( baseURL + "/api/device/bulk_import", HttpMethod.POST, new HttpEntity<>(request), new ParameterizedTypeReference>() { }).getBody(); } @Deprecated public Device createDevice(String name, String type) { Device device = new Device(); device.setName(name); device.setType(type); return doCreateDevice(device, null); } @Deprecated public Device createDevice(Device device) { return doCreateDevice(device, null); } @Deprecated public Device createDevice(Device device, String accessToken) { return doCreateDevice(device, accessToken); } @Deprecated private Device doCreateDevice(Device device, String accessToken) { Map params = new HashMap<>(); String deviceCreationUrl = "/api/device"; if (!StringUtils.isEmpty(accessToken)) { deviceCreationUrl = deviceCreationUrl + "?accessToken={accessToken}"; params.put("accessToken", accessToken); } return restTemplate.postForEntity(baseURL + deviceCreationUrl, device, Device.class, params).getBody(); } @Deprecated public DeviceCredentials getCredentials(DeviceId id) { return restTemplate.getForEntity(baseURL + "/api/device/" + id.getId().toString() + "/credentials", DeviceCredentials.class).getBody(); } @Deprecated public Optional findDevice(String name) { Map params = new HashMap<>(); params.put("deviceName", name); try { ResponseEntity deviceEntity = restTemplate.getForEntity(baseURL + "/api/tenant/devices?deviceName={deviceName}", Device.class, params); return Optional.of(deviceEntity.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } @Deprecated public DeviceCredentials updateDeviceCredentials(DeviceId deviceId, String token) { DeviceCredentials deviceCredentials = getCredentials(deviceId); deviceCredentials.setCredentialsType(DeviceCredentialsType.ACCESS_TOKEN); deviceCredentials.setCredentialsId(token); return saveDeviceCredentials(deviceCredentials); } @Deprecated public Device assignDevice(CustomerId customerId, DeviceId deviceId) { return restTemplate.postForEntity(baseURL + "/api/customer/{customerId}/device/{deviceId}", null, Device.class, customerId.toString(), deviceId.toString()).getBody(); } public Optional getDeviceProfileById(DeviceProfileId deviceProfileId) { try { ResponseEntity deviceProfile = restTemplate.getForEntity(baseURL + "/api/deviceProfile/{deviceProfileId}", DeviceProfile.class, deviceProfileId); return Optional.ofNullable(deviceProfile.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getDeviceProfileInfoById(DeviceProfileId deviceProfileId) { try { ResponseEntity deviceProfileInfo = restTemplate.getForEntity(baseURL + "/api/deviceProfileInfo/{deviceProfileId}", DeviceProfileInfo.class, deviceProfileId); return Optional.ofNullable(deviceProfileInfo.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public DeviceProfileInfo getDefaultDeviceProfileInfo() { return restTemplate.getForEntity(baseURL + "/api/deviceProfileInfo/default", DeviceProfileInfo.class).getBody(); } public DeviceProfile saveDeviceProfile(DeviceProfile deviceProfile) { return restTemplate.postForEntity(baseURL + "/api/deviceProfile", deviceProfile, DeviceProfile.class).getBody(); } public void deleteDeviceProfile(DeviceProfileId deviceProfileId) { restTemplate.delete(baseURL + "/api/deviceProfile/{deviceProfileId}", deviceProfileId); } public DeviceProfile setDefaultDeviceProfile(DeviceProfileId deviceProfileId) { return restTemplate.postForEntity( baseURL + "/api/deviceProfile/{deviceProfileId}/default", HttpEntity.EMPTY, DeviceProfile.class, deviceProfileId).getBody(); } public PageData getDeviceProfiles(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/deviceProfiles?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getDeviceProfileInfos(PageLink pageLink, DeviceTransportType deviceTransportType) { Map params = new HashMap<>(); params.put("deviceTransportType", deviceTransportType != null ? deviceTransportType.name() : null); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/deviceProfileInfos?deviceTransportType={deviceTransportType}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional getAssetProfileById(AssetProfileId assetProfileId) { try { ResponseEntity assetProfile = restTemplate.getForEntity(baseURL + "/api/assetProfile/{assetProfileId}", AssetProfile.class, assetProfileId); return Optional.ofNullable(assetProfile.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getAssetProfileInfoById(AssetProfileId assetProfileId) { try { ResponseEntity assetProfileInfo = restTemplate.getForEntity(baseURL + "/api/assetProfileInfo/{assetProfileId}", AssetProfileInfo.class, assetProfileId); return Optional.ofNullable(assetProfileInfo.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public AssetProfileInfo getDefaultAssetProfileInfo() { return restTemplate.getForEntity(baseURL + "/api/assetProfileInfo/default", AssetProfileInfo.class).getBody(); } public AssetProfile saveAssetProfile(AssetProfile assetProfile) { return restTemplate.postForEntity(baseURL + "/api/assetProfile", assetProfile, AssetProfile.class).getBody(); } public void deleteAssetProfile(AssetProfileId assetProfileId) { restTemplate.delete(baseURL + "/api/assetProfile/{assetProfileId}", assetProfileId); } public AssetProfile setDefaultAssetProfile(AssetProfileId assetProfileId) { return restTemplate.postForEntity( baseURL + "/api/assetProfile/{assetProfileId}/default", HttpEntity.EMPTY, AssetProfile.class, assetProfileId).getBody(); } public PageData getAssetProfiles(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/assetProfiles?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getAssetProfileInfos(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/assetProfileInfos?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List getAssetProfilesByIds(Set ids) { URIBuilder builder; try { builder = new URIBuilder(baseURL); } catch (URISyntaxException e) { throw new IllegalArgumentException("Invalid base URL: " + baseURL, e); } builder.appendPath("/api/assetProfileInfos"); String commaSeparatedIds = ids.stream() .filter(Objects::nonNull) .map(UUID::toString) .collect(joining(",")); builder.addParameter("assetProfileIds", commaSeparatedIds); URI uri; try { uri = builder.build(); } catch (URISyntaxException e) { throw new IllegalStateException("Failed to construct API URI from base URL and provided params", e); } return restTemplate.exchange(uri, HttpMethod.GET, null, new ParameterizedTypeReference>() {}).getBody(); } public Long countEntitiesByQuery(EntityCountQuery query) { return restTemplate.postForObject(baseURL + "/api/entitiesQuery/count", query, Long.class); } public PageData findEntityDataByQuery(EntityDataQuery query) { return restTemplate.exchange( baseURL + "/api/entitiesQuery/find", HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference>() { }).getBody(); } /** * @deprecated Use {@link #findAvailableEntityKeysV2(EntityDataQuery, boolean, boolean, Set, boolean)} instead. */ @Deprecated(forRemoval = true) public AvailableEntityKeys findAvailableEntityKeysByQuery(EntityDataQuery query, boolean includeTimeseries, boolean includeAttributes, AttributeScope scope) { var uri = UriComponentsBuilder.fromUriString(baseURL) .path("/api/entitiesQuery/find/keys") .queryParam("timeseries", includeTimeseries) .queryParam("attributes", includeAttributes) .queryParamIfPresent("scope", Optional.ofNullable(scope)) .build() .toUri(); return restTemplate.exchange(uri, HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference() {}).getBody(); } @SneakyThrows(URISyntaxException.class) public AvailableEntityKeysV2 findAvailableEntityKeysV2( EntityDataQuery query, boolean includeTimeseries, boolean includeAttributes, Set scopes, boolean includeSamples ) { var builder = new URIBuilder(baseURL).appendPath("/api/v2/entitiesQuery/find/keys") .addParameter("includeTimeseries", String.valueOf(includeTimeseries)) .addParameter("includeAttributes", String.valueOf(includeAttributes)) .addParameter("includeSamples", String.valueOf(includeSamples)); if (scopes != null) { for (AttributeScope scope : scopes) { builder.addParameter("scopes", scope.name()); } } return restTemplate.exchange(builder.build(), HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference() {}).getBody(); } public PageData findAlarmDataByQuery(AlarmDataQuery query) { return restTemplate.exchange( baseURL + "/api/alarmsQuery/find", HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference>() { }).getBody(); } public Long countAlarmsByQuery(AlarmCountQuery query) { return restTemplate.postForObject(baseURL + "/api/alarmsQuery/count", query, Long.class); } public void saveRelation(EntityRelation relation) { restTemplate.postForLocation(baseURL + "/api/relation", relation); } public EntityRelation saveRelationV2(EntityRelation relation) { return restTemplate.postForEntity(baseURL + "/api/v2/relation", relation, EntityRelation.class).getBody(); } public void deleteRelation(EntityId fromId, String relationType, RelationTypeGroup relationTypeGroup, EntityId toId) { Map params = new HashMap<>(); params.put("fromId", fromId.getId().toString()); params.put("fromType", fromId.getEntityType().name()); params.put("relationType", relationType); params.put("relationTypeGroup", relationTypeGroup.name()); params.put("toId", toId.getId().toString()); params.put("toType", toId.getEntityType().name()); restTemplate.delete(baseURL + "/api/relation?fromId={fromId}&fromType={fromType}&relationType={relationType}&relationTypeGroup={relationTypeGroup}&toId={toId}&toType={toType}", params); } public Optional deleteRelationV2(EntityId fromId, String relationType, RelationTypeGroup relationTypeGroup, EntityId toId) { Map params = new HashMap<>(); params.put("fromId", fromId.getId().toString()); params.put("fromType", fromId.getEntityType().name()); params.put("relationType", relationType); params.put("relationTypeGroup", relationTypeGroup.name()); params.put("toId", toId.getId().toString()); params.put("toType", toId.getEntityType().name()); try { var relation = restTemplate.exchange(baseURL + "/api/relation?fromId={fromId}&fromType={fromType}&relationType={relationType}&relationTypeGroup={relationTypeGroup}&toId={toId}&toType={toType}", HttpMethod.DELETE, HttpEntity.EMPTY, EntityRelation.class, params); return Optional.ofNullable(relation.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public void deleteRelations(EntityId entityId) { restTemplate.delete(baseURL + "/api/relations?entityId={entityId}&entityType={entityType}", entityId.getId().toString(), entityId.getEntityType().name()); } public Optional getRelation(EntityId fromId, String relationType, RelationTypeGroup relationTypeGroup, EntityId toId) { Map params = new HashMap<>(); params.put("fromId", fromId.getId().toString()); params.put("fromType", fromId.getEntityType().name()); params.put("relationType", relationType); params.put("relationTypeGroup", relationTypeGroup.name()); params.put("toId", toId.getId().toString()); params.put("toType", toId.getEntityType().name()); try { ResponseEntity entityRelation = restTemplate.getForEntity( baseURL + "/api/relation?fromId={fromId}&fromType={fromType}&relationType={relationType}&relationTypeGroup={relationTypeGroup}&toId={toId}&toType={toType}", EntityRelation.class, params); return Optional.ofNullable(entityRelation.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public List findByFrom(EntityId fromId, RelationTypeGroup relationTypeGroup) { Map params = new HashMap<>(); params.put("fromId", fromId.getId().toString()); params.put("fromType", fromId.getEntityType().name()); params.put("relationTypeGroup", relationTypeGroup.name()); return restTemplate.exchange( baseURL + "/api/relations?fromId={fromId}&fromType={fromType}&relationTypeGroup={relationTypeGroup}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List findInfoByFrom(EntityId fromId, RelationTypeGroup relationTypeGroup) { Map params = new HashMap<>(); params.put("fromId", fromId.getId().toString()); params.put("fromType", fromId.getEntityType().name()); params.put("relationTypeGroup", relationTypeGroup.name()); return restTemplate.exchange( baseURL + "/api/relations/info?fromId={fromId}&fromType={fromType}&relationTypeGroup={relationTypeGroup}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List findByFrom(EntityId fromId, String relationType, RelationTypeGroup relationTypeGroup) { Map params = new HashMap<>(); params.put("fromId", fromId.getId().toString()); params.put("fromType", fromId.getEntityType().name()); params.put("relationType", relationType); params.put("relationTypeGroup", relationTypeGroup.name()); return restTemplate.exchange( baseURL + "/api/relations?fromId={fromId}&fromType={fromType}&relationType={relationType}&relationTypeGroup={relationTypeGroup}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List findByTo(EntityId toId, RelationTypeGroup relationTypeGroup) { Map params = new HashMap<>(); params.put("toId", toId.getId().toString()); params.put("toType", toId.getEntityType().name()); params.put("relationTypeGroup", relationTypeGroup.name()); return restTemplate.exchange( baseURL + "/api/relations?toId={toId}&toType={toType}&relationTypeGroup={relationTypeGroup}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List findInfoByTo(EntityId toId, RelationTypeGroup relationTypeGroup) { Map params = new HashMap<>(); params.put("toId", toId.getId().toString()); params.put("toType", toId.getEntityType().name()); params.put("relationTypeGroup", relationTypeGroup.name()); return restTemplate.exchange( baseURL + "/api/relations/info?toId={toId}&toType={toType}&relationTypeGroup={relationTypeGroup}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List findByTo(EntityId toId, String relationType, RelationTypeGroup relationTypeGroup) { Map params = new HashMap<>(); params.put("toId", toId.getId().toString()); params.put("toType", toId.getEntityType().name()); params.put("relationType", relationType); params.put("relationTypeGroup", relationTypeGroup.name()); return restTemplate.exchange( baseURL + "/api/relations?toId={toId}&toType={toType}&relationType={relationType}&relationTypeGroup={relationTypeGroup}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List findByQuery(EntityRelationsQuery query) { return restTemplate.exchange( baseURL + "/api/relations", HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference>() { }).getBody(); } public List findInfoByQuery(EntityRelationsQuery query) { return restTemplate.exchange( baseURL + "/api/relations/info", HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference>() { }).getBody(); } @Deprecated public EntityRelation makeRelation(String relationType, EntityId idFrom, EntityId idTo) { EntityRelation relation = new EntityRelation(); relation.setFrom(idFrom); relation.setTo(idTo); relation.setType(relationType); return restTemplate.postForEntity(baseURL + "/api/relation", relation, EntityRelation.class).getBody(); } public Optional getEntityViewById(EntityViewId entityViewId) { try { ResponseEntity entityView = restTemplate.getForEntity(baseURL + "/api/entityView/{entityViewId}", EntityView.class, entityViewId.getId()); return Optional.ofNullable(entityView.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getEntityViewInfoById(EntityViewId entityViewId) { try { ResponseEntity entityView = restTemplate.getForEntity(baseURL + "/api/entityView/info/{entityViewId}", EntityViewInfo.class, entityViewId); return Optional.ofNullable(entityView.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public EntityView saveEntityView(EntityView entityView) { return restTemplate.postForEntity(baseURL + "/api/entityView", entityView, EntityView.class).getBody(); } public void deleteEntityView(EntityViewId entityViewId) { restTemplate.delete(baseURL + "/api/entityView/{entityViewId}", entityViewId.getId()); } public Optional getTenantEntityView(String entityViewName) { try { ResponseEntity entityView = restTemplate.getForEntity(baseURL + "/api/tenant/entityViews?entityViewName={entityViewName}", EntityView.class, entityViewName); return Optional.ofNullable(entityView.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional assignEntityViewToCustomer(CustomerId customerId, EntityViewId entityViewId) { try { ResponseEntity entityView = restTemplate.postForEntity(baseURL + "/api/customer/{customerId}/entityView/{entityViewId}", null, EntityView.class, customerId.getId(), entityViewId.getId()); return Optional.ofNullable(entityView.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignEntityViewFromCustomer(EntityViewId entityViewId) { try { ResponseEntity entityView = restTemplate.exchange(baseURL + "/api/customer/entityView/{entityViewId}", HttpMethod.DELETE, HttpEntity.EMPTY, EntityView.class, entityViewId.getId()); return Optional.ofNullable(entityView.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getCustomerEntityViews(CustomerId customerId, String entityViewType, PageLink pageLink) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); params.put("type", entityViewType); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/customer/{customerId}/entityViews?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getCustomerEntityViewInfos(CustomerId customerId, String entityViewType, PageLink pageLink) { Map params = new HashMap<>(); params.put("customerId", customerId.toString()); params.put("type", entityViewType); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/customer/{customerId}/entityViewInfos?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getTenantEntityViews(String entityViewType, PageLink pageLink) { Map params = new HashMap<>(); params.put("type", entityViewType); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenant/entityViews?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getTenantEntityViewInfos(String entityViewType, PageLink pageLink) { Map params = new HashMap<>(); params.put("type", entityViewType); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenant/entityViewInfos?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List findByQuery(EntityViewSearchQuery query) { return restTemplate.exchange(baseURL + "/api/entityViews", HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference>() { }).getBody(); } public List getEntityViewTypes() { return restTemplate.exchange(baseURL + "/api/entityView/types", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public Optional assignEntityViewToPublicCustomer(EntityViewId entityViewId) { try { ResponseEntity entityView = restTemplate.postForEntity(baseURL + "/api/customer/public/entityView/{entityViewId}", null, EntityView.class, entityViewId.getId()); return Optional.ofNullable(entityView.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getEvents(EntityId entityId, String eventType, TenantId tenantId, TimePageLink pageLink) { Map params = new HashMap<>(); params.put("entityType", entityId.getEntityType().name()); params.put("entityId", entityId.getId().toString()); params.put("eventType", eventType); params.put("tenantId", tenantId.getId().toString()); addTimePageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/events/{entityType}/{entityId}/{eventType}?tenantId={tenantId}&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getEvents(EntityId entityId, TenantId tenantId, TimePageLink pageLink) { Map params = new HashMap<>(); params.put("entityType", entityId.getEntityType().name()); params.put("entityId", entityId.getId().toString()); params.put("tenantId", tenantId.getId().toString()); addTimePageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/events/{entityType}/{entityId}?tenantId={tenantId}&" + getTimeUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public OAuth2ClientRegistrationTemplate saveClientRegistrationTemplate(OAuth2ClientRegistrationTemplate clientRegistrationTemplate) { return restTemplate.postForEntity(baseURL + "/api/oauth2/config/template", clientRegistrationTemplate, OAuth2ClientRegistrationTemplate.class).getBody(); } public void deleteClientRegistrationTemplate(OAuth2ClientRegistrationTemplateId oAuth2ClientRegistrationTemplateId) { restTemplate.delete(baseURL + "/api/oauth2/config/template/{clientRegistrationTemplateId}", oAuth2ClientRegistrationTemplateId); } public List getClientRegistrationTemplates() { return restTemplate.exchange( baseURL + "/api/oauth2/config/template", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public List getOAuth2Clients(String pkgName, PlatformType platformType) { Map params = new HashMap<>(); StringBuilder urlBuilder = new StringBuilder(baseURL); urlBuilder.append("/api/noauth/oauth2Clients"); if (pkgName != null) { urlBuilder.append("?pkgName={pkgName}"); params.put("pkgName", pkgName); } if (platformType != null) { if (pkgName != null) { urlBuilder.append("&"); } else { urlBuilder.append("?"); } urlBuilder.append("platform={platform}"); params.put("platform", platformType.name()); } return restTemplate.exchange( urlBuilder.toString(), HttpMethod.POST, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getTenantOAuth2Clients() { return restTemplate.exchange( baseURL + "/api/oauth2/client/infos", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public Optional getOauth2ClientById(OAuth2ClientId oAuth2ClientId) { try { ResponseEntity oauth2Client = restTemplate.getForEntity(baseURL + "/api/oauth2/client/{id}", OAuth2Client.class, oAuth2ClientId.getId()); return Optional.ofNullable(oauth2Client.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public OAuth2Client saveOAuth2Client(OAuth2Client oAuth2Client) { return restTemplate.postForEntity(baseURL + "/api/oauth2/client", oAuth2Client, OAuth2Client.class).getBody(); } public void deleteOauth2CLient(OAuth2ClientId oAuth2ClientId) { restTemplate.delete(baseURL + "/api/oauth2/client/{id}", oAuth2ClientId.getId()); } public PageData getTenantDomainInfos(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/domain/infos?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional getDomainInfoById(DomainId domainId) { try { ResponseEntity domainInfo = restTemplate.getForEntity(baseURL + "/api/domain/info/{id}", DomainInfo.class, domainId.getId()); return Optional.ofNullable(domainInfo.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Domain saveDomain(Domain domain) { return restTemplate.postForEntity(baseURL + "/api/domain", domain, Domain.class).getBody(); } public void deleteDomain(DomainId domainId) { restTemplate.delete(baseURL + "/api/domain/{id}", domainId.getId()); } public void updateDomainOauth2Clients(DomainId domainId, UUID[] oauth2ClientIds) { restTemplate.postForLocation(baseURL + "/api/domain/{id}/oauth2Clients", oauth2ClientIds, domainId.getId()); } public PageData getTenantMobileApps(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/mobile/app?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional getMobileAppById(MobileAppId mobileAppId) { try { ResponseEntity mobileApp = restTemplate.getForEntity(baseURL + "/api/mobile/app/{id}", MobileApp.class, mobileAppId.getId()); return Optional.ofNullable(mobileApp.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public MobileApp saveMobileApp(MobileApp mobileApp) { return restTemplate.postForEntity(baseURL + "/api/mobile/app", mobileApp, MobileApp.class).getBody(); } public void deleteMobileApp(MobileAppId mobileAppId) { restTemplate.delete(baseURL + "/api/mobile/app/{id}", mobileAppId.getId()); } public PageData getTenantMobileBundleInfos(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/mobile/bundle/infos?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional getMobileBundleById(MobileAppBundleId mobileAppBundleId) { try { ResponseEntity mobileApp = restTemplate.getForEntity(baseURL + "/api/mobile/bundle/{id}", MobileAppBundle.class, mobileAppBundleId.getId()); return Optional.ofNullable(mobileApp.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public MobileAppBundle saveMobileBundle(MobileAppBundle mobileAppBundle) { return restTemplate.postForEntity(baseURL + "/api/mobile/bundle", mobileAppBundle, MobileAppBundle.class).getBody(); } public void deleteMobileBundle(MobileAppBundleId mobileAppBundleId) { restTemplate.delete(baseURL + "/api/mobile/bundle/{id}", mobileAppBundleId.getId()); } public void updateMobileAppBundleOauth2Clients(MobileAppBundleId mobileAppBundleId, UUID[] oauth2ClientIds) { restTemplate.postForLocation(baseURL + "/api/mobile/bundle/{id}/oauth2Clients", oauth2ClientIds, mobileAppBundleId.getId()); } public String getLoginProcessingUrl() { return restTemplate.getForEntity(baseURL + "/api/oauth2/loginProcessingUrl", String.class).getBody(); } public void handleOneWayDeviceRPCRequest(DeviceId deviceId, JsonNode requestBody) { restTemplate.postForLocation(baseURL + "/api/rpc/oneway/{deviceId}", requestBody, deviceId.getId()); } public JsonNode handleTwoWayDeviceRPCRequest(DeviceId deviceId, JsonNode requestBody) { return restTemplate.exchange( baseURL + "/api/rpc/twoway/{deviceId}", HttpMethod.POST, new HttpEntity<>(requestBody), new ParameterizedTypeReference() { }, deviceId.getId()).getBody(); } public Optional getRuleChainById(RuleChainId ruleChainId) { try { ResponseEntity ruleChain = restTemplate.getForEntity(baseURL + "/api/ruleChain/{ruleChainId}", RuleChain.class, ruleChainId.getId()); return Optional.ofNullable(ruleChain.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getRuleChainMetaData(RuleChainId ruleChainId) { try { ResponseEntity ruleChainMetaData = restTemplate.getForEntity(baseURL + "/api/ruleChain/{ruleChainId}/metadata", RuleChainMetaData.class, ruleChainId.getId()); return Optional.ofNullable(ruleChainMetaData.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public RuleChain saveRuleChain(RuleChain ruleChain) { return restTemplate.postForEntity(baseURL + "/api/ruleChain", ruleChain, RuleChain.class).getBody(); } public RuleChain saveRuleChain(DefaultRuleChainCreateRequest request) { return restTemplate.postForEntity(baseURL + "/api/ruleChain/device/default", request, RuleChain.class).getBody(); } public Optional setRootRuleChain(RuleChainId ruleChainId) { try { ResponseEntity ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/root", null, RuleChain.class, ruleChainId.getId()); return Optional.ofNullable(ruleChain.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public RuleChainMetaData saveRuleChainMetaData(RuleChainMetaData ruleChainMetaData) { return restTemplate.postForEntity(baseURL + "/api/ruleChain/metadata", ruleChainMetaData, RuleChainMetaData.class).getBody(); } public PageData getRuleChains(PageLink pageLink) { return getRuleChains(RuleChainType.CORE, pageLink); } public PageData getRuleChains(RuleChainType ruleChainType, PageLink pageLink) { Map params = new HashMap<>(); params.put("type", ruleChainType.name()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/ruleChains?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public void deleteRuleChain(RuleChainId ruleChainId) { restTemplate.delete(baseURL + "/api/ruleChain/{ruleChainId}", ruleChainId.getId()); } public Optional getLatestRuleNodeDebugInput(RuleNodeId ruleNodeId) { try { ResponseEntity jsonNode = restTemplate.getForEntity(baseURL + "/api/ruleNode/{ruleNodeId}/debugIn", JsonNode.class, ruleNodeId.getId()); return Optional.ofNullable(jsonNode.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional testScript(JsonNode inputParams) { try { ResponseEntity jsonNode = restTemplate.postForEntity(baseURL + "/api/ruleChain/testScript", inputParams, JsonNode.class); return Optional.ofNullable(jsonNode.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public RuleChainData exportRuleChains(int limit) { return restTemplate.getForEntity(baseURL + "/api/ruleChains/export?limit=" + limit, RuleChainData.class).getBody(); } public void importRuleChains(RuleChainData ruleChainData, boolean overwrite) { restTemplate.postForLocation(baseURL + "/api/ruleChains/import?overwrite=" + overwrite, ruleChainData); } public List getAttributeKeys(EntityId entityId) { return restTemplate.exchange( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/keys/attributes", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, entityId.getEntityType().name(), entityId.getId().toString()).getBody(); } public List getAttributeKeysByScope(EntityId entityId, String scope) { return restTemplate.exchange( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/keys/attributes/{scope}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, entityId.getEntityType().name(), entityId.getId().toString(), scope).getBody(); } public List getAttributeKvEntries(EntityId entityId, List keys) { List attributes = restTemplate.exchange( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/values/attributes?keys={keys}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, entityId.getEntityType().name(), entityId.getId(), listToString(keys)).getBody(); return RestJsonConverter.toAttributes(attributes); } public Future> getAttributeKvEntriesAsync(EntityId entityId, List keys) { return getExecutor().submit(() -> getAttributeKvEntries(entityId, keys)); } public List getAttributesByScope(EntityId entityId, String scope, List keys) { List attributes = restTemplate.exchange( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/values/attributes/{scope}?keys={keys}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, entityId.getEntityType().name(), entityId.getId().toString(), scope, listToString(keys)).getBody(); return RestJsonConverter.toAttributes(attributes); } public List getTimeseriesKeys(EntityId entityId) { return restTemplate.exchange( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/keys/timeseries", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, entityId.getEntityType().name(), entityId.getId().toString()).getBody(); } public List getLatestTimeseries(EntityId entityId, List keys) { return getLatestTimeseries(entityId, keys, true); } public List getLatestTimeseries(EntityId entityId, List keys, boolean useStrictDataTypes) { Map> timeseries = restTemplate.exchange( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/values/timeseries?keys={keys}&useStrictDataTypes={useStrictDataTypes}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>>() { }, entityId.getEntityType().name(), entityId.getId().toString(), listToString(keys), useStrictDataTypes).getBody(); return RestJsonConverter.toTimeseries(timeseries); } @Deprecated public List getTimeseries(EntityId entityId, List keys, Long interval, Aggregation agg, TimePageLink pageLink) { return getTimeseries(entityId, keys, interval, agg, pageLink, true); } @Deprecated public List getTimeseries(EntityId entityId, List keys, Long interval, Aggregation agg, TimePageLink pageLink, boolean useStrictDataTypes) { SortOrder sortOrder = pageLink.getSortOrder(); return getTimeseries(entityId, keys, interval, agg, sortOrder != null ? sortOrder.getDirection() : null, pageLink.getStartTime(), pageLink.getEndTime(), 100, useStrictDataTypes); } @Deprecated public List getTimeseries(EntityId entityId, List keys, Long interval, Aggregation agg, SortOrder.Direction sortOrder, Long startTime, Long endTime, Integer limit, boolean useStrictDataTypes) { return getTimeseries(entityId, keys, interval, null, null, agg, sortOrder, startTime, endTime, limit, useStrictDataTypes); } public List getTimeseries(EntityId entityId, List keys, Long interval, IntervalType intervalType, String timeZone, Aggregation agg, SortOrder.Direction sortOrder, Long startTime, Long endTime, Integer limit, boolean useStrictDataTypes) { Map params = new HashMap<>(); params.put("entityType", entityId.getEntityType().name()); params.put("entityId", entityId.getId().toString()); params.put("keys", listToString(keys)); params.put("interval", interval == null ? "0" : interval.toString()); params.put("agg", agg == null ? "NONE" : agg.name()); params.put("limit", limit != null ? limit.toString() : "100"); params.put("orderBy", sortOrder != null ? sortOrder.name() : "DESC"); params.put("useStrictDataTypes", Boolean.toString(useStrictDataTypes)); StringBuilder urlBuilder = new StringBuilder(baseURL); urlBuilder.append("/api/plugins/telemetry/{entityType}/{entityId}/values/timeseries?keys={keys}&interval={interval}&limit={limit}&agg={agg}&useStrictDataTypes={useStrictDataTypes}&orderBy={orderBy}"); if (intervalType != null) { urlBuilder.append("&intervalType={intervalType}"); params.put("intervalType", intervalType.name()); } if (timeZone != null) { urlBuilder.append("&timeZone={timeZone}"); params.put("timeZone", timeZone); } if (startTime != null) { urlBuilder.append("&startTs={startTs}"); params.put("startTs", String.valueOf(startTime)); } if (endTime != null) { urlBuilder.append("&endTs={endTs}"); params.put("endTs", String.valueOf(endTime)); } Map> timeseries = restTemplate.exchange( urlBuilder.toString(), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>>() { }, params).getBody(); return RestJsonConverter.toTimeseries(timeseries); } public boolean saveDeviceAttributes(DeviceId deviceId, String scope, JsonNode request) { return restTemplate .postForEntity(baseURL + "/api/plugins/telemetry/{deviceId}/{scope}", request, Object.class, deviceId.getId().toString(), scope) .getStatusCode() .is2xxSuccessful(); } public boolean saveEntityAttributesV1(EntityId entityId, String scope, JsonNode request) { return restTemplate .postForEntity( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/{scope}", request, Object.class, entityId.getEntityType().name(), entityId.getId().toString(), scope) .getStatusCode() .is2xxSuccessful(); } public boolean saveEntityAttributesV2(EntityId entityId, String scope, JsonNode request) { return restTemplate .postForEntity( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/attributes/{scope}", request, Object.class, entityId.getEntityType().name(), entityId.getId().toString(), scope) .getStatusCode() .is2xxSuccessful(); } public boolean saveEntityTelemetry(EntityId entityId, String scope, JsonNode request) { return restTemplate .postForEntity( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/timeseries/{scope}", request, Object.class, entityId.getEntityType().name(), entityId.getId().toString(), scope) .getStatusCode() .is2xxSuccessful(); } public boolean saveEntityTelemetryWithTTL(EntityId entityId, String scope, Long ttl, JsonNode request) { return restTemplate .postForEntity( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/timeseries/{scope}/{ttl}", request, Object.class, entityId.getEntityType().name(), entityId.getId().toString(), scope, ttl) .getStatusCode() .is2xxSuccessful(); } public boolean deleteEntityTimeseries(EntityId entityId, List keys, boolean deleteAllDataForKeys, Long startTs, Long endTs, boolean rewriteLatestIfDeleted, boolean deleteLatest) { Map params = new HashMap<>(); params.put("entityType", entityId.getEntityType().name()); params.put("entityId", entityId.getId().toString()); params.put("keys", listToString(keys)); params.put("deleteAllDataForKeys", String.valueOf(deleteAllDataForKeys)); params.put("startTs", startTs.toString()); params.put("endTs", endTs.toString()); params.put("rewriteLatestIfDeleted", String.valueOf(rewriteLatestIfDeleted)); params.put("deleteLatest", String.valueOf(deleteLatest)); return restTemplate .exchange( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/timeseries/delete?keys={keys}&deleteAllDataForKeys={deleteAllDataForKeys}&startTs={startTs}&endTs={endTs}&rewriteLatestIfDeleted={rewriteLatestIfDeleted}&deleteLatest={deleteLatest}", HttpMethod.DELETE, HttpEntity.EMPTY, Object.class, params) .getStatusCode() .is2xxSuccessful(); } public boolean deleteEntityLatestTimeseries(EntityId entityId, List keys) { Map params = new HashMap<>(); params.put("entityType", entityId.getEntityType().name()); params.put("entityId", entityId.getId().toString()); params.put("keys", listToString(keys)); return restTemplate .exchange( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/timeseries/latest/delete?keys={keys}", HttpMethod.DELETE, HttpEntity.EMPTY, Object.class, params) .getStatusCode() .is2xxSuccessful(); } public boolean deleteEntityAttributes(DeviceId deviceId, String scope, List keys) { return restTemplate .exchange( baseURL + "/api/plugins/telemetry/{deviceId}/{scope}?keys={keys}", HttpMethod.DELETE, HttpEntity.EMPTY, Object.class, deviceId.getId().toString(), scope, listToString(keys)) .getStatusCode() .is2xxSuccessful(); } public boolean deleteEntityAttributes(EntityId entityId, String scope, List keys) { return restTemplate .exchange( baseURL + "/api/plugins/telemetry/{entityType}/{entityId}/{scope}?keys={keys}", HttpMethod.DELETE, HttpEntity.EMPTY, Object.class, entityId.getEntityType().name(), entityId.getId().toString(), scope, listToString(keys)) .getStatusCode() .is2xxSuccessful(); } public Optional getTenantById(TenantId tenantId) { try { ResponseEntity tenant = restTemplate.getForEntity(baseURL + "/api/tenant/{tenantId}", Tenant.class, tenantId.getId()); return Optional.ofNullable(tenant.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getTenantInfoById(TenantId tenantId) { try { ResponseEntity tenant = restTemplate.getForEntity(baseURL + "/api/tenant/info/{tenantId}", TenantInfo.class, tenantId); return Optional.ofNullable(tenant.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Tenant saveTenant(Tenant tenant) { return restTemplate.postForEntity(baseURL + "/api/tenant", tenant, Tenant.class).getBody(); } public void deleteTenant(TenantId tenantId) { restTemplate.delete(baseURL + "/api/tenant/{tenantId}", tenantId.getId()); } public PageData getTenants(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenants?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getTenantInfos(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenantInfos?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public UsageInfo getUsageInfo() { return restTemplate.exchange( baseURL + "/api/usage", HttpMethod.GET, HttpEntity.EMPTY, UsageInfo.class).getBody(); } public Optional getTenantProfileById(TenantProfileId tenantProfileId) { try { ResponseEntity tenantProfile = restTemplate.getForEntity(baseURL + "/api/tenantProfile/{tenantProfileId}", TenantProfile.class, tenantProfileId); return Optional.ofNullable(tenantProfile.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getTenantProfileInfoById(TenantProfileId tenantProfileId) { try { ResponseEntity entityInfo = restTemplate.getForEntity(baseURL + "/api/tenantProfileInfo/{tenantProfileId}", EntityInfo.class, tenantProfileId); return Optional.ofNullable(entityInfo.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public EntityInfo getDefaultTenantProfileInfo() { return restTemplate.getForEntity(baseURL + "/api/tenantProfileInfo/default", EntityInfo.class).getBody(); } public TenantProfile saveTenantProfile(TenantProfile tenantProfile) { return restTemplate.postForEntity(baseURL + "/api/tenantProfile", tenantProfile, TenantProfile.class).getBody(); } public void deleteTenantProfile(TenantProfileId tenantProfileId) { restTemplate.delete(baseURL + "/api/tenantProfile/{tenantProfileId}", tenantProfileId); } public TenantProfile setDefaultTenantProfile(TenantProfileId tenantProfileId) { return restTemplate.exchange(baseURL + "/api/tenantProfile/{tenantProfileId}/default", HttpMethod.POST, HttpEntity.EMPTY, TenantProfile.class, tenantProfileId).getBody(); } public PageData getTenantProfiles(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenantProfiles?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getTenantProfileInfos(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenantProfileInfos?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional getUserById(UserId userId) { try { ResponseEntity user = restTemplate.getForEntity(baseURL + "/api/user/{userId}", User.class, userId.getId()); return Optional.ofNullable(user.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Boolean isUserTokenAccessEnabled() { return restTemplate.getForEntity(baseURL + "/api/user/tokenAccessEnabled", Boolean.class).getBody(); } public Optional getUserToken(UserId userId) { try { ResponseEntity userToken = restTemplate.getForEntity(baseURL + "/api/user/{userId}/token", JsonNode.class, userId.getId()); return Optional.ofNullable(userToken.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public User saveUser(User user, boolean sendActivationMail) { return restTemplate.postForEntity(baseURL + "/api/user?sendActivationMail={sendActivationMail}", user, User.class, sendActivationMail).getBody(); } public void sendActivationEmail(String email) { restTemplate.postForLocation(baseURL + "/api/user/sendActivationMail?email={email}", null, email); } public String getActivationLink(UserId userId) { return restTemplate.getForEntity(baseURL + "/api/user/{userId}/activationLink", String.class, userId.getId()).getBody(); } public void deleteUser(UserId userId) { restTemplate.delete(baseURL + "/api/user/{userId}", userId.getId()); } public PageData getUsers(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/users?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getUsersByQuery(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/users/info?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getTenantAdmins(TenantId tenantId, PageLink pageLink) { Map params = new HashMap<>(); params.put("tenantId", tenantId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenant/{tenantId}/users?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getCustomerUsers(CustomerId customerId, PageLink pageLink) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/customer/{customerId}/users?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getUsersForAssign(AlarmId alarmId, PageLink pageLink) { Map params = new HashMap<>(); params.put("alarmId", alarmId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/users/assign/{alarmId}" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public void setUserCredentialsEnabled(UserId userId, boolean userCredentialsEnabled) { restTemplate.postForLocation( baseURL + "/api/user/{userId}/userCredentialsEnabled?userCredentialsEnabled={userCredentialsEnabled}", null, userId.getId(), userCredentialsEnabled); } public ApiKey saveApiKey(ApiKeyInfo apiKeyInfo) { return restTemplate.postForEntity(baseURL + "/api/apiKey", apiKeyInfo, ApiKey.class).getBody(); } public PageData getUserApiKeys(UserId userId, PageLink pageLink) { Map params = new HashMap<>(); params.put("userId", userId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/apiKeys/{userId}?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() {}, params).getBody(); } public ApiKeyInfo updateApiKeyDescription(ApiKeyId apiKeyId, String description) { return restTemplate.exchange( baseURL + "/api/apiKey/{id}/description", HttpMethod.PUT, new HttpEntity<>(description), ApiKeyInfo.class, apiKeyId.getId()).getBody(); } public ApiKeyInfo enableApiKey(ApiKeyId apiKeyId, boolean enabled) { return restTemplate.exchange( baseURL + "/api/apiKey/{id}/enabled/{enabledValue}", HttpMethod.PUT, HttpEntity.EMPTY, ApiKeyInfo.class, apiKeyId.getId(), enabled).getBody(); } public void deleteApiKey(ApiKeyId apiKeyId) { restTemplate.delete(baseURL + "/api/apiKey/{id}", apiKeyId.getId()); } public Optional getWidgetsBundleById(WidgetsBundleId widgetsBundleId) { try { ResponseEntity widgetsBundle = restTemplate.getForEntity(baseURL + "/api/widgetsBundle/{widgetsBundleId}", WidgetsBundle.class, widgetsBundleId.getId()); return Optional.ofNullable(widgetsBundle.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public WidgetsBundle saveWidgetsBundle(WidgetsBundle widgetsBundle) { return restTemplate.postForEntity(baseURL + "/api/widgetsBundle", widgetsBundle, WidgetsBundle.class).getBody(); } public void updateWidgetsBundleWidgetTypes(WidgetsBundleId widgetsBundleId, List widgetTypeIds) { var httpEntity = new HttpEntity<>(widgetTypeIds.stream() .map(widgetTypeId -> widgetTypeId.getId().toString()) .collect(Collectors.toList())); restTemplate.exchange(baseURL + "/api/widgetsBundle/{widgetsBundleId}/widgetTypes", HttpMethod.POST, httpEntity, Void.class, widgetsBundleId.getId()); } public void updateWidgetsBundleWidgetFqns(WidgetsBundleId widgetsBundleId, List widgetTypeFqns) { restTemplate.exchange(baseURL + "/api/widgetsBundle/{widgetsBundleId}/widgetTypeFqns", HttpMethod.POST, new HttpEntity<>(widgetTypeFqns), Void.class, widgetsBundleId.getId()); } public void deleteWidgetsBundle(WidgetsBundleId widgetsBundleId) { restTemplate.delete(baseURL + "/api/widgetsBundle/{widgetsBundleId}", widgetsBundleId.getId()); } public PageData getWidgetsBundles(PageLink pageLink) { return getWidgetsBundles(pageLink, null, null); } public PageData getWidgetsBundles(PageLink pageLink, Boolean tenantOnly, Boolean fullSearch) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); addTenantOnlyAndFullSearchToParams(tenantOnly, fullSearch, params); return restTemplate.exchange( baseURL + "/api/widgetsBundles?" + getUrlParams(pageLink) + getTenantOnlyAndFullSearchUrlParams(tenantOnly, fullSearch), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List getWidgetsBundles() { return restTemplate.exchange( baseURL + "/api/widgetsBundles", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public Optional getWidgetTypeById(WidgetTypeId widgetTypeId) { try { ResponseEntity widgetTypeDetails = restTemplate.getForEntity(baseURL + "/api/widgetType/{widgetTypeId}", WidgetTypeDetails.class, widgetTypeId.getId()); return Optional.ofNullable(widgetTypeDetails.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getWidgetTypeInfoById(WidgetTypeId widgetTypeId) { try { ResponseEntity widgetTypeInfo = restTemplate.getForEntity(baseURL + "/api/widgetTypeInfo/{widgetTypeId}", WidgetTypeInfo.class, widgetTypeId.getId()); return Optional.ofNullable(widgetTypeInfo.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } throw exception; } } public WidgetTypeDetails saveWidgetType(WidgetTypeDetails widgetTypeDetails) { return saveWidgetType(widgetTypeDetails, null); } public WidgetTypeDetails saveWidgetType(WidgetTypeDetails widgetTypeDetails, Boolean updateExistingByFqn) { if (updateExistingByFqn == null) { return restTemplate.postForEntity(baseURL + "/api/widgetType", widgetTypeDetails, WidgetTypeDetails.class).getBody(); } return restTemplate.postForEntity(baseURL + "/api/widgetType?updateExistingByFqn={updateExistingByFqn}", widgetTypeDetails, WidgetTypeDetails.class, updateExistingByFqn).getBody(); } public void deleteWidgetType(WidgetTypeId widgetTypeId) { restTemplate.delete(baseURL + "/api/widgetType/{widgetTypeId}", widgetTypeId.getId()); } public PageData getWidgetTypes(PageLink pageLink) { return getWidgetTypes(pageLink, null, null, null, null); } public PageData getWidgetTypes(PageLink pageLink, Boolean tenantOnly, Boolean fullSearch, DeprecatedFilter deprecatedFilter, List widgetTypeList) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); addWidgetInfoFiltersToParams(tenantOnly, fullSearch, deprecatedFilter, widgetTypeList, params); return restTemplate.exchange( baseURL + "/api/widgetTypes?" + getUrlParams(pageLink) + getWidgetTypeInfoPageRequestUrlParams(tenantOnly, fullSearch, deprecatedFilter, widgetTypeList), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } @Deprecated // current name in the controller: getBundleWidgetTypesByBundleAlias public List getBundleWidgetTypes(boolean isSystem, String bundleAlias) { return restTemplate.exchange( baseURL + "/api/widgetTypes?isSystem={isSystem}&bundleAlias={bundleAlias}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, isSystem, bundleAlias).getBody(); } public List getBundleWidgetTypes(WidgetsBundleId widgetsBundleId) { return restTemplate.exchange( baseURL + "/api/widgetTypes?widgetsBundleId={widgetsBundleId}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, widgetsBundleId.getId()).getBody(); } @Deprecated // current name in the controller: getBundleWidgetTypesDetailsByBundleAlias public List getBundleWidgetTypesDetails(boolean isSystem, String bundleAlias) { return restTemplate.exchange( baseURL + "/api/widgetTypesDetails?isSystem={isSystem}&bundleAlias={bundleAlias}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, isSystem, bundleAlias).getBody(); } public List getBundleWidgetTypesDetails(WidgetsBundleId widgetsBundleId, boolean inlineImages) { return restTemplate.exchange( baseURL + "/api/widgetTypesDetails?widgetsBundleId={widgetsBundleId}&inlineImages={inlineImages}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, widgetsBundleId.getId(), inlineImages).getBody(); } public List getBundleWidgetTypeFqns(WidgetsBundleId widgetsBundleId) { return restTemplate.exchange( baseURL + "/api/widgetTypeFqns?widgetsBundleId={widgetsBundleId}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, widgetsBundleId.getId()).getBody(); } @Deprecated // current name in the controller: getBundleWidgetTypesInfosByBundleAlias public List getBundleWidgetTypesInfos(boolean isSystem, String bundleAlias) { return restTemplate.exchange( baseURL + "/api/widgetTypesInfos?isSystem={isSystem}&bundleAlias={bundleAlias}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, isSystem, bundleAlias).getBody(); } public PageData getBundleWidgetTypesInfos(WidgetsBundleId widgetsBundleId, PageLink pageLink) { return getBundleWidgetTypesInfos(widgetsBundleId, pageLink, null, null, null, null); } public PageData getBundleWidgetTypesInfos(WidgetsBundleId widgetsBundleId, PageLink pageLink, Boolean tenantOnly, Boolean fullSearch, DeprecatedFilter deprecatedFilter, List widgetTypeList) { Map params = new HashMap<>(); params.put("widgetsBundleId", widgetsBundleId.getId().toString()); addPageLinkToParam(params, pageLink); addWidgetInfoFiltersToParams(tenantOnly, fullSearch, deprecatedFilter, widgetTypeList, params); return restTemplate.exchange( baseURL + "/api/widgetTypesInfos?widgetsBundleId={widgetsBundleId}&" + getUrlParams(pageLink) + getWidgetTypeInfoPageRequestUrlParams(tenantOnly, fullSearch, deprecatedFilter, widgetTypeList), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } @Deprecated // current name in the controller: getWidgetTypeByBundleAliasAndTypeAlias public Optional getWidgetType(boolean isSystem, String bundleAlias, String alias) { try { ResponseEntity widgetType = restTemplate.getForEntity( baseURL + "/api/widgetType?isSystem={isSystem}&bundleAlias={bundleAlias}&alias={alias}", WidgetType.class, isSystem, bundleAlias, alias); return Optional.ofNullable(widgetType.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getWidgetType(String fqn) { try { ResponseEntity widgetType = restTemplate.getForEntity( baseURL + "/api/widgetType?fqn={fqn}", WidgetType.class, fqn); return Optional.ofNullable(widgetType.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } throw exception; } } public Boolean isEdgesSupportEnabled() { return restTemplate.getForEntity(baseURL + "/api/edges/enabled", Boolean.class).getBody(); } public Edge saveEdge(Edge edge) { return restTemplate.postForEntity(baseURL + "/api/edge", edge, Edge.class).getBody(); } public void deleteEdge(EdgeId edgeId) { restTemplate.delete(baseURL + "/api/edge/{edgeId}", edgeId.getId()); } public Optional getEdgeById(EdgeId edgeId) { try { ResponseEntity edge = restTemplate.getForEntity(baseURL + "/api/edge/{edgeId}", Edge.class, edgeId.getId()); return Optional.ofNullable(edge.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional getEdgeInfoById(EdgeId edgeId) { try { ResponseEntity edge = restTemplate.getForEntity(baseURL + "/api/edge/info/{edgeId}", EdgeInfo.class, edgeId.getId()); return Optional.ofNullable(edge.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional assignEdgeToCustomer(CustomerId customerId, EdgeId edgeId) { try { ResponseEntity edge = restTemplate.postForEntity(baseURL + "/api/customer/{customerId}/edge/{edgeId}", null, Edge.class, customerId.getId(), edgeId.getId()); return Optional.ofNullable(edge.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional assignEdgeToPublicCustomer(EdgeId edgeId) { try { ResponseEntity edge = restTemplate.postForEntity(baseURL + "/api/customer/public/edge/{edgeId}", null, Edge.class, edgeId.getId()); return Optional.ofNullable(edge.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional setEdgeRootRuleChain(EdgeId edgeId, RuleChainId ruleChainId) { try { ResponseEntity ruleChain = restTemplate.postForEntity(baseURL + "/api/edge/{edgeId}/{ruleChainId}/root", null, Edge.class, edgeId.getId(), ruleChainId.getId()); return Optional.ofNullable(ruleChain.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getEdges(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/edges?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional unassignEdgeFromCustomer(EdgeId edgeId) { try { ResponseEntity edge = restTemplate.exchange(baseURL + "/api/customer/edge/{edgeId}", HttpMethod.DELETE, HttpEntity.EMPTY, Edge.class, edgeId.getId()); return Optional.ofNullable(edge.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional assignDeviceToEdge(EdgeId edgeId, DeviceId deviceId) { try { ResponseEntity device = restTemplate.postForEntity(baseURL + "/api/edge/{edgeId}/device/{deviceId}", null, Device.class, edgeId.getId(), deviceId.getId()); return Optional.ofNullable(device.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignDeviceFromEdge(EdgeId edgeId, DeviceId deviceId) { try { ResponseEntity device = restTemplate.exchange(baseURL + "/api/edge/{edgeId}/device/{deviceId}", HttpMethod.DELETE, HttpEntity.EMPTY, Device.class, edgeId.getId(), deviceId.getId()); return Optional.ofNullable(device.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getEdgeDevices(EdgeId edgeId, PageLink pageLink) { Map params = new HashMap<>(); params.put("edgeId", edgeId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/edge/{edgeId}/devices?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional assignAssetToEdge(EdgeId edgeId, AssetId assetId) { try { ResponseEntity asset = restTemplate.postForEntity(baseURL + "/api/edge/{edgeId}/asset/{assetId}", null, Asset.class, edgeId.getId(), assetId.getId()); return Optional.ofNullable(asset.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignAssetFromEdge(EdgeId edgeId, AssetId assetId) { try { ResponseEntity asset = restTemplate.exchange(baseURL + "/api/edge/{edgeId}/asset/{assetId}", HttpMethod.DELETE, HttpEntity.EMPTY, Asset.class, edgeId.getId(), assetId.getId()); return Optional.ofNullable(asset.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getEdgeAssets(EdgeId edgeId, PageLink pageLink) { Map params = new HashMap<>(); params.put("edgeId", edgeId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/edge/{edgeId}/assets?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional assignDashboardToEdge(EdgeId edgeId, DashboardId dashboardId) { try { ResponseEntity dashboard = restTemplate.postForEntity(baseURL + "/api/edge/{edgeId}/dashboard/{dashboardId}", null, Dashboard.class, edgeId.getId(), dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignDashboardFromEdge(EdgeId edgeId, DashboardId dashboardId) { try { ResponseEntity dashboard = restTemplate.exchange(baseURL + "/api/edge/{edgeId}/dashboard/{dashboardId}", HttpMethod.DELETE, HttpEntity.EMPTY, Dashboard.class, edgeId.getId(), dashboardId.getId()); return Optional.ofNullable(dashboard.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getEdgeDashboards(EdgeId edgeId, TimePageLink pageLink) { Map params = new HashMap<>(); params.put("edgeId", edgeId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/edge/{edgeId}/dashboards?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional assignEntityViewToEdge(EdgeId edgeId, EntityViewId entityViewId) { try { ResponseEntity entityView = restTemplate.postForEntity(baseURL + "/api/edge/{edgeId}/entityView/{entityViewId}", null, EntityView.class, edgeId.getId(), entityViewId.getId()); return Optional.ofNullable(entityView.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignEntityViewFromEdge(EdgeId edgeId, EntityViewId entityViewId) { try { ResponseEntity entityView = restTemplate.exchange(baseURL + "/api/edge/{edgeId}/entityView/{entityViewId}", HttpMethod.DELETE, HttpEntity.EMPTY, EntityView.class, edgeId.getId(), entityViewId.getId()); return Optional.ofNullable(entityView.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getEdgeEntityViews(EdgeId edgeId, PageLink pageLink) { Map params = new HashMap<>(); params.put("edgeId", edgeId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/edge/{edgeId}/entityViews?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional assignRuleChainToEdge(EdgeId edgeId, RuleChainId ruleChainId) { try { ResponseEntity ruleChain = restTemplate.postForEntity(baseURL + "/api/edge/{edgeId}/ruleChain/{ruleChainId}", null, RuleChain.class, edgeId.getId(), ruleChainId.getId()); return Optional.ofNullable(ruleChain.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unassignRuleChainFromEdge(EdgeId edgeId, RuleChainId ruleChainId) { try { ResponseEntity ruleChain = restTemplate.exchange(baseURL + "/api/edge/{edgeId}/ruleChain/{ruleChainId}", HttpMethod.DELETE, HttpEntity.EMPTY, RuleChain.class, edgeId.getId(), ruleChainId.getId()); return Optional.ofNullable(ruleChain.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getEdgeRuleChains(EdgeId edgeId, TimePageLink pageLink) { Map params = new HashMap<>(); params.put("edgeId", edgeId.getId().toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/edge/{edgeId}/ruleChains?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional setAutoAssignToEdgeRuleChain(RuleChainId ruleChainId) { try { ResponseEntity ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/autoAssignToEdge", null, RuleChain.class, ruleChainId.getId()); return Optional.ofNullable(ruleChain.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional unsetAutoAssignToEdgeRuleChain(RuleChainId ruleChainId) { try { ResponseEntity ruleChain = restTemplate.exchange(baseURL + "/api/ruleChain/{ruleChainId}/autoAssignToEdge", HttpMethod.DELETE, HttpEntity.EMPTY, RuleChain.class, ruleChainId.getId()); return Optional.ofNullable(ruleChain.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public List getAutoAssignToEdgeRuleChains() { return restTemplate.exchange(baseURL + "/api/ruleChain/autoAssignToEdgeRuleChains", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public Optional setRootEdgeTemplateRuleChain(RuleChainId ruleChainId) { try { ResponseEntity ruleChain = restTemplate.postForEntity(baseURL + "/api/ruleChain/{ruleChainId}/edgeTemplateRoot", null, RuleChain.class, ruleChainId.getId()); return Optional.ofNullable(ruleChain.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getTenantEdges(String type, PageLink pageLink) { Map params = new HashMap<>(); params.put("type", type); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenant/edges?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getTenantEdgeInfos(String type, PageLink pageLink) { Map params = new HashMap<>(); params.put("type", type); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/tenant/edgeInfos?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Optional getTenantEdge(String edgeName) { try { ResponseEntity edge = restTemplate.getForEntity(baseURL + "/api/tenant/edges?edgeName={edgeName}", Edge.class, edgeName); return Optional.ofNullable(edge.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getCustomerEdges(CustomerId customerId, PageLink pageLink, String edgeType) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); params.put("type", edgeType); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/customer/{customerId}/edges?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData getCustomerEdgeInfos(CustomerId customerId, PageLink pageLink, String edgeType) { Map params = new HashMap<>(); params.put("customerId", customerId.getId().toString()); params.put("type", edgeType); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/customer/{customerId}/edgeInfos?type={type}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List getEdgesByIds(List edgeIds) { return restTemplate.exchange(baseURL + "/api/edges?edgeIds={edgeIds}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, listIdsToString(edgeIds)).getBody(); } public List findByQuery(EdgeSearchQuery query) { return restTemplate.exchange( baseURL + "/api/edges", HttpMethod.POST, new HttpEntity<>(query), new ParameterizedTypeReference>() { }).getBody(); } public List getEdgeTypes() { return restTemplate.exchange( baseURL + "/api/edge/types", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public PageData getEdgeEvents(EdgeId edgeId, TimePageLink pageLink) { Map params = new HashMap<>(); params.put("edgeId", edgeId.toString()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/edge/{edgeId}/events?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public void syncEdge(EdgeId edgeId) { Map params = new HashMap<>(); params.put("edgeId", edgeId.toString()); restTemplate.postForEntity(baseURL + "/api/edge/sync/{edgeId}", null, EdgeId.class, params); } public String findMissingToRelatedRuleChains(EdgeId edgeId) { return restTemplate.getForEntity(baseURL + "/api/edge/missingToRelatedRuleChains/{edgeId}", String.class, edgeId.getId()).getBody(); } public BulkImportResult processEdgesBulkImport(BulkImportRequest request) { return restTemplate.exchange( baseURL + "/api/edge/bulk_import", HttpMethod.POST, new HttpEntity<>(request), new ParameterizedTypeReference>() { }).getBody(); } public Optional getEdgeInstallInstructions(EdgeId edgeId, String method) { ResponseEntity edgeInstallInstructionsResult = restTemplate.getForEntity(baseURL + "/api/edge/instructions/install/{edgeId}/{method}", EdgeInstructions.class, edgeId.getId(), method); return Optional.ofNullable(edgeInstallInstructionsResult.getBody()); } public Optional getEdgeUpgradeInstructions(String edgeVersion, String method) { ResponseEntity edgeUpgradeInstructionsResult = restTemplate.getForEntity(baseURL + "/api/edge/instructions/upgrade/{edgeVersion}/{method}", EdgeInstructions.class, edgeVersion, method); return Optional.ofNullable(edgeUpgradeInstructionsResult.getBody()); } public UUID saveEntitiesVersion(VersionCreateRequest request) { return restTemplate.postForEntity(baseURL + "/api/entities/vc/version", request, UUID.class).getBody(); } public Optional getVersionCreateRequestStatus(UUID requestId) { try { ResponseEntity versionCreateResult = restTemplate.getForEntity(baseURL + "/api/entities/vc/version/{requestId}/status", VersionCreationResult.class, requestId); return Optional.ofNullable(versionCreateResult.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData listEntityVersions(EntityId externalEntityId, String branch, PageLink pageLink) { Map params = new HashMap<>(); params.put("entityType", externalEntityId.getEntityType().name()); params.put("externalEntityUuid", externalEntityId.getId().toString()); params.put("branch", branch); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/entities/vc/version/{entityType}/{externalEntityUuid}?branch={branch}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData listEntityTypeVersions(EntityType entityType, String branch, PageLink pageLink) { Map params = new HashMap<>(); params.put("entityType", entityType.name()); params.put("branch", branch); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/entities/vc/version/{entityType}?branch={branch}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public PageData listVersions(String branch, PageLink pageLink) { Map params = new HashMap<>(); params.put("branch", branch); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/entities/vc/version?branch={branch}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List listEntitiesAtVersion(EntityType entityType, String versionId) { Map params = new HashMap<>(); params.put("entityType", entityType.name()); params.put("versionId", versionId); return restTemplate.exchange( baseURL + "/api/entities/vc/entity/{entityType}/{versionId}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public List listAllEntitiesAtVersion(String versionId) { Map params = new HashMap<>(); params.put("versionId", versionId); return restTemplate.exchange( baseURL + "/api/entities/vc/entity/{versionId}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public EntityDataInfo getEntityDataInfo(EntityId externalEntityId, String versionId) { return restTemplate.getForEntity(baseURL + "/api/entities/vc/info/{versionId}/{entityType}/{externalEntityUuid}", EntityDataInfo.class, versionId, externalEntityId.getEntityType(), externalEntityId.getId()).getBody(); } public EntityDataDiff compareEntityDataToVersion(EntityId internalEntityId, String versionId) { return restTemplate.getForEntity(baseURL + "/api/entities/vc/diff/{entityType}/{internalEntityUuid}?versionId={versionId}", EntityDataDiff.class, internalEntityId.getEntityType(), internalEntityId.getId(), versionId).getBody(); } public UUID loadEntitiesVersion(VersionLoadRequest request) { return restTemplate.postForEntity(baseURL + "/api/entities/vc/entity", request, UUID.class).getBody(); } public Optional getVersionLoadRequestStatus(UUID requestId) { try { ResponseEntity versionLoadResult = restTemplate.getForEntity(baseURL + "/api/entities/vc/entity/{requestId}/status", VersionLoadResult.class, requestId); return Optional.ofNullable(versionLoadResult.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public List listBranches() { return restTemplate.exchange( baseURL + "/api/entities/vc/branches", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public ResponseEntity downloadResource(TbResourceId resourceId) { Map params = new HashMap<>(); params.put("resourceId", resourceId.getId().toString()); return restTemplate.exchange( baseURL + "/api/resource/{resourceId}/download", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference<>() { }, params ); } public TbResourceInfo getResourceInfoById(TbResourceId resourceId) { Map params = new HashMap<>(); params.put("resourceId", resourceId.getId().toString()); return restTemplate.exchange( baseURL + "/api/resource/info/{resourceId}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference() { }, params ).getBody(); } public TbResource getResourceId(TbResourceId resourceId) { Map params = new HashMap<>(); params.put("resourceId", resourceId.getId().toString()); return restTemplate.exchange( baseURL + "/api/resource/{resourceId}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference() { }, params ).getBody(); } public TbResource saveResource(TbResource resource) { return restTemplate.postForEntity( baseURL + "/api/resource", resource, TbResource.class ).getBody(); } public PageData getResources(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/resource?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params ).getBody(); } public void deleteResource(TbResourceId resourceId) { restTemplate.delete("/api/resource/{resourceId}", resourceId.getId().toString()); } public TbResourceInfo getImageInfo(String type, String key) { return restTemplate.getForObject(baseURL + "/api/images/{type}/{key}/info", TbResourceInfo.class, Map.of( "type", type, "key", key )); } public PageData getImages(PageLink pageLink, boolean includeSystemImages) { return this.getImages(pageLink, null, includeSystemImages); } public PageData getImages(PageLink pageLink, ResourceSubType imageSubType, boolean includeSystemImages) { Map params = new HashMap<>(); var url = baseURL + "/api/images?includeSystemImages={includeSystemImages}&"; addPageLinkToParam(params, pageLink); params.put("includeSystemImages", String.valueOf(includeSystemImages)); if (imageSubType != null) { url += "imageSubType={imageSubType}&"; params.put("imageSubType", imageSubType.name()); } return restTemplate.exchange(url + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() {}, params ).getBody(); } public TbResourceInfo uploadImage(String fileName, byte[] data, String contentType, String title) { HttpEntity> request = createMultipartRequest(fileName, data, contentType, Map.of( "title", Strings.nullToEmpty(title) )); return restTemplate.postForObject(baseURL + "/api/image", request, TbResourceInfo.class); } public TbResourceInfo updateImage(String type, String key, String fileName, byte[] data, String contentType) { HttpEntity> request = createMultipartRequest(fileName, data, contentType, Map.of()); return restTemplate.exchange(baseURL + "/api/images/{type}/{key}", HttpMethod.PUT, request, TbResourceInfo.class, Map.of( "type", type, "key", key )).getBody(); } public TbResourceInfo updateImageInfo(String type, String key, TbResourceInfo request) { return restTemplate.exchange(baseURL + "/api/images/{type}/{key}/info", HttpMethod.PUT, new HttpEntity<>(request), TbResourceInfo.class, Map.of( "type", type, "key", key )).getBody(); } public void updateImagePublicStatus(String type, String key, boolean isPublic) { restTemplate.put(baseURL + "/api/images/{type}/{key}/public/{isPublic}", null, Map.of( "type", type, "key", key, "isPublic", isPublic )); } public byte[] downloadImage(String type, String key) throws IOException { Resource image = restTemplate.exchange(baseURL + "/api/images/{type}/{key}", HttpMethod.GET, null, Resource.class, Map.of( "type", type, "key", key )).getBody(); return IOUtils.toByteArray(image.getInputStream()); } public byte[] downloadImagePreview(String type, String key) throws IOException { Resource image = restTemplate.exchange(baseURL + "/api/images/{type}/{key}/preview", HttpMethod.GET, null, Resource.class, Map.of( "type", type, "key", key )).getBody(); return IOUtils.toByteArray(image.getInputStream()); } public byte[] downloadPublicImage(String publicResourceKey) throws IOException { Resource image = restTemplate.exchange(baseURL + "/api/images/public/{publicResourceKey}", HttpMethod.GET, null, Resource.class, Map.of( "publicResourceKey", publicResourceKey )).getBody(); return IOUtils.toByteArray(image.getInputStream()); } public ResourceExportData exportImage(String type, String key) { return restTemplate.getForObject(baseURL + "/api/images/{type}/{key}/export", ResourceExportData.class, Map.of( "type", type, "key", key )); } public TbResourceInfo importImage(ResourceExportData exportData) { return restTemplate.exchange(baseURL + "/api/image/import", HttpMethod.PUT, new HttpEntity<>(exportData), TbResourceInfo.class).getBody(); } public TbImageDeleteResult deleteImage(String type, String key, boolean force) { return restTemplate.exchange(baseURL + "/api/images/{type}/{key}?force={force}", HttpMethod.DELETE, null, TbImageDeleteResult.class, Map.of( "type", type, "key", key, "force", force )).getBody(); } public ResponseEntity downloadOtaPackage(OtaPackageId otaPackageId) { Map params = new HashMap<>(); params.put("otaPackageId", otaPackageId.getId().toString()); return restTemplate.exchange( baseURL + "/api/otaPackage/{otaPackageId}/download", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference<>() { }, params ); } public OtaPackageInfo getOtaPackageInfoById(OtaPackageId otaPackageId) { Map params = new HashMap<>(); params.put("otaPackageId", otaPackageId.getId().toString()); return restTemplate.exchange( baseURL + "/api/otaPackage/info/{otaPackageId}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference() { }, params ).getBody(); } public OtaPackage getOtaPackageById(OtaPackageId otaPackageId) { Map params = new HashMap<>(); params.put("otaPackageId", otaPackageId.getId().toString()); return restTemplate.exchange( baseURL + "/api/otaPackage/{otaPackageId}", HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference() { }, params ).getBody(); } public OtaPackageInfo saveOtaPackageInfo(OtaPackageInfo otaPackageInfo, boolean isUrl) { Map params = new HashMap<>(); params.put("isUrl", Boolean.toString(isUrl)); return restTemplate.postForEntity(baseURL + "/api/otaPackage?isUrl={isUrl}", otaPackageInfo, OtaPackageInfo.class, params).getBody(); } public OtaPackageInfo saveOtaPackageData(OtaPackageId otaPackageId, String checkSum, ChecksumAlgorithm checksumAlgorithm, String fileName, byte[] fileBytes) throws Exception { HttpEntity> requestEntity = createMultipartRequest(fileName, fileBytes, null, Collections.emptyMap()); Map params = new HashMap<>(); params.put("otaPackageId", otaPackageId.getId().toString()); params.put("checksumAlgorithm", checksumAlgorithm.name()); String url = "/api/otaPackage/{otaPackageId}?checksumAlgorithm={checksumAlgorithm}"; if (checkSum != null) { url += "&checkSum={checkSum}"; } return restTemplate.postForEntity( baseURL + url, requestEntity, OtaPackageInfo.class, params ).getBody(); } public PageData getOtaPackages(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/otaPackages?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params ).getBody(); } public PageData getOtaPackages(DeviceProfileId deviceProfileId, OtaPackageType otaPackageType, boolean hasData, PageLink pageLink) { Map params = new HashMap<>(); params.put("hasData", String.valueOf(hasData)); params.put("deviceProfileId", deviceProfileId.getId().toString()); params.put("type", otaPackageType.name()); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/otaPackages/{deviceProfileId}/{type}/{hasData}?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params ).getBody(); } public void deleteOtaPackage(OtaPackageId otaPackageId) { restTemplate.delete(baseURL + "/api/otaPackage/{otaPackageId}", otaPackageId.getId().toString()); } public PageData getQueuesByServiceType(String serviceType, PageLink pageLink) { Map params = new HashMap<>(); params.put("serviceType", serviceType); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/queues?serviceType={serviceType}&" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params ).getBody(); } public Queue getQueueById(QueueId queueId) { return restTemplate.exchange( baseURL + "/api/queues/" + queueId, HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference() { } ).getBody(); } public Queue saveQueue(Queue queue, String serviceType) { return restTemplate.postForEntity(baseURL + "/api/queues?serviceType=" + serviceType, queue, Queue.class).getBody(); } public void deleteQueue(QueueId queueId) { restTemplate.delete(baseURL + "/api/queues/" + queueId); } @Deprecated public Optional getAttributes(String accessToken, String clientKeys, String sharedKeys) { Map params = new HashMap<>(); params.put("accessToken", accessToken); params.put("clientKeys", clientKeys); params.put("sharedKeys", sharedKeys); try { ResponseEntity telemetryEntity = restTemplate.getForEntity(baseURL + "/api/v1/{accessToken}/attributes?clientKeys={clientKeys}&sharedKeys={sharedKeys}", JsonNode.class, params); return Optional.of(telemetryEntity.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public JsonNode handleRuleEngineRequest(JsonNode requestBody) { return restTemplate.exchange( baseURL + "/api/rule-engine", HttpMethod.POST, new HttpEntity<>(requestBody), new ParameterizedTypeReference() { }).getBody(); } public JsonNode handleRuleEngineRequest(EntityId entityId, JsonNode requestBody) { return restTemplate.exchange( baseURL + "/api/rule-engine/{entityType}/{entityId}", HttpMethod.POST, new HttpEntity<>(requestBody), new ParameterizedTypeReference() { }, entityId.getEntityType(), entityId.getId()).getBody(); } public JsonNode handleRuleEngineRequest(EntityId entityId, int timeout, JsonNode requestBody) { return restTemplate.exchange( baseURL + "/api/rule-engine/{entityType}/{entityId}/{timeout}", HttpMethod.POST, new HttpEntity<>(requestBody), new ParameterizedTypeReference() { }, entityId.getEntityType(), entityId.getId(), timeout).getBody(); } public JsonNode handleRuleEngineRequest(EntityId entityId, String queueName, int timeout, JsonNode requestBody) { return restTemplate.exchange( baseURL + "/api/rule-engine/{entityType}/{entityId}/{queueName}/{timeout}", HttpMethod.POST, new HttpEntity<>(requestBody), new ParameterizedTypeReference() { }, entityId.getEntityType(), entityId.getId(), queueName, timeout).getBody(); } public CalculatedField saveCalculatedField(CalculatedField calculatedField) { return restTemplate.postForEntity(baseURL + "/api/calculatedField", calculatedField, CalculatedField.class).getBody(); } public Optional getCalculatedFieldById(CalculatedFieldId calculatedFieldId) { try { ResponseEntity calculatedField = restTemplate.getForEntity(baseURL + "/api/calculatedField/{calculatedFieldId}", CalculatedField.class, calculatedFieldId.getId()); return Optional.ofNullable(calculatedField.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getCalculatedFieldsByEntityId(EntityId entityId, PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/" + entityId.getEntityType() + "/" + entityId.getId() + "/calculatedFields?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } @SneakyThrows(URISyntaxException.class) public PageData getCalculatedFields(PageLink pageLink, Set types, EntityType entityType, Set entities, Set names) { var urlBuilder = new URIBuilder(baseURL).appendPath("/api/calculatedFields"); urlBuilder.addParameter("pageSize", String.valueOf(pageLink.getPageSize())); urlBuilder.addParameter("page", String.valueOf(pageLink.getPage())); if (!isEmpty(pageLink.getTextSearch())) { urlBuilder.addParameter("textSearch", pageLink.getTextSearch()); } if (pageLink.getSortOrder() != null) { urlBuilder.addParameter("sortProperty", pageLink.getSortOrder().getProperty()); urlBuilder.addParameter("sortOrder", pageLink.getSortOrder().getDirection().name()); } if (!CollectionUtils.isEmpty(types)) { for (CalculatedFieldType type : types) { urlBuilder.addParameter("types", type.name()); } } if (entityType != null) { urlBuilder.addParameter("entityType", entityType.name()); } if (!CollectionUtils.isEmpty(entities)) { for (UUID entity : entities) { urlBuilder.addParameter("entities", entity.toString()); } } if (!CollectionUtils.isEmpty(names)) { for (String name : names) { urlBuilder.addParameter("name", name); } } return restTemplate.exchange( urlBuilder.build(), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() {}).getBody(); } public void deleteCalculatedField(CalculatedFieldId calculatedFieldId) { restTemplate.delete(baseURL + "/api/calculatedField/{calculatedFieldId}", calculatedFieldId.getId()); } public Optional getLatestCalculatedFieldDebugEvent(CalculatedFieldId calculatedFieldId) { try { ResponseEntity jsonNode = restTemplate.getForEntity(baseURL + "/api/calculatedField/{calculatedFieldId}/debug", JsonNode.class, calculatedFieldId.getId()); return Optional.ofNullable(jsonNode.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public Optional testCalculatedFieldScript(JsonNode inputParams) { try { ResponseEntity jsonNode = restTemplate.postForEntity(baseURL + "/api/calculatedField/testScript", inputParams, JsonNode.class); return Optional.ofNullable(jsonNode.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getNotifications(Boolean unreadOnly, NotificationDeliveryMethod deliveryMethod, PageLink pageLink) { Map params = new HashMap<>(); StringBuilder urlBuilder = new StringBuilder(); urlBuilder.append(baseURL).append("/api/notifications?").append(getUrlParams(pageLink)); addPageLinkToParam(params, pageLink); if (unreadOnly != null) { urlBuilder.append("&unreadOnly={unreadOnly}"); params.put("unreadOnly", unreadOnly.toString()); } if (deliveryMethod != null) { urlBuilder.append("&deliveryMethod={deliveryMethod}"); params.put("deliveryMethod", deliveryMethod.name()); } return restTemplate.exchange(urlBuilder.toString(), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public Integer getUnreadNotificationsCount(NotificationDeliveryMethod deliveryMethod) { String uri = "/api/notifications/unread/count?"; Map params = new HashMap<>(); if (deliveryMethod != null) { params.put("deliveryMethod", deliveryMethod.name()); uri += "&deliveryMethod={deliveryMethod}"; } return restTemplate.exchange( baseURL + uri, HttpMethod.GET, HttpEntity.EMPTY, Integer.class, params).getBody(); } public void markNotificationAsRead(NotificationId notificationId) { restTemplate.exchange( baseURL + "/api/notification/{id}/read", HttpMethod.PUT, HttpEntity.EMPTY, Void.class, notificationId.getId()); } public void markAllNotificationsAsRead(NotificationDeliveryMethod deliveryMethod) { String uri = "/api/notifications/read?"; Map params = new HashMap<>(); if (deliveryMethod != null) { params.put("deliveryMethod", deliveryMethod.name()); uri += "&deliveryMethod={deliveryMethod}"; } restTemplate.exchange( baseURL + uri, HttpMethod.PUT, HttpEntity.EMPTY, Void.class, params); } public void deleteNotification(NotificationId notificationId) { restTemplate.delete(baseURL + "/api/notification/{id}", notificationId.getId()); } public NotificationRequest saveNotificationRequest(NotificationRequest notificationRequest) { return restTemplate.postForEntity(baseURL + "/api/notification/request", notificationRequest, NotificationRequest.class).getBody(); } public NotificationRequestPreview getNotificationRequestPreview(NotificationRequest notificationRequest, int recipientsPreviewSize) { return restTemplate.postForEntity(baseURL + "/api/notification/request/preview?recipientsPreviewSize={recipientsPreviewSize}", notificationRequest, NotificationRequestPreview.class, recipientsPreviewSize).getBody(); } public Optional getNotificationRequestById(NotificationRequestId notificationRequestId) { try { ResponseEntity notificationRequest = restTemplate.getForEntity(baseURL + "/api/notification/request/{id}", NotificationRequestInfo.class, notificationRequestId.getId()); return Optional.ofNullable(notificationRequest.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public PageData getNotificationRequests(PageLink pageLink) { Map params = new HashMap<>(); addPageLinkToParam(params, pageLink); return restTemplate.exchange( baseURL + "/api/notification/requests?" + getUrlParams(pageLink), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }, params).getBody(); } public void deleteNotificationRequest(NotificationRequestId notificationRequestId) { restTemplate.delete(baseURL + "/api/notification/request/{id}", notificationRequestId.getId()); } public NotificationSettings saveNotificationSettings(NotificationSettings notificationSettings) { return restTemplate.postForEntity(baseURL + "/api/notification/settings", notificationSettings, NotificationSettings.class).getBody(); } public Optional getNotificationSettings() { try { ResponseEntity notificationSettings = restTemplate.getForEntity(baseURL + "/api/notification/settings", NotificationSettings.class); return Optional.ofNullable(notificationSettings.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public List getAvailableDeliveryMethods() { return restTemplate.exchange(URI.create( baseURL + "/api/notification/deliveryMethods"), HttpMethod.GET, HttpEntity.EMPTY, new ParameterizedTypeReference>() { }).getBody(); } public UserNotificationSettings saveUserNotificationSettings(UserNotificationSettings userNotificationSettings) { return restTemplate.postForEntity(baseURL + "/api/notification/settings/user", userNotificationSettings, UserNotificationSettings.class).getBody(); } public Optional getUserNotificationSettings() { try { ResponseEntity userNotificationSettings = restTemplate.getForEntity(baseURL + "/api/notification/settings/user", UserNotificationSettings.class); return Optional.ofNullable(userNotificationSettings.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public NotificationTarget saveNotificationTarget(NotificationTarget notificationTarget) { return restTemplate.postForEntity(baseURL + "/api/notification/target", notificationTarget, NotificationTarget.class).getBody(); } public NotificationTemplate saveNotificationTemplate(NotificationTemplate notificationTemplate) { return restTemplate.postForEntity(baseURL + "/api/notification/template", notificationTemplate, NotificationTemplate.class).getBody(); } public AiModel saveAiModel(AiModel aiModel) { return restTemplate.postForEntity(baseURL + "/api/ai/model", aiModel, AiModel.class).getBody(); } public Optional getAiModel(AiModelId aiModelId) { try { ResponseEntity response = restTemplate.getForEntity( baseURL + "/api/ai/model/{aiModelId}", AiModel.class, aiModelId.getId()); return Optional.ofNullable(response.getBody()); } catch (HttpClientErrorException exception) { if (exception.getStatusCode() == HttpStatus.NOT_FOUND) { return Optional.empty(); } else { throw exception; } } } public void deleteAiModel(AiModelId aiModelId) { restTemplate.delete(baseURL + "/api/ai/model/{aiModelId}", aiModelId.getId()); } private String getTimeUrlParams(TimePageLink pageLink) { String urlParams = getUrlParams(pageLink); if (pageLink.getStartTime() != null) { urlParams += "&startTime={startTime}"; } if (pageLink.getEndTime() != null) { urlParams += "&endTime={endTime}"; } return urlParams; } private String getUrlParams(PageLink pageLink) { String urlParams = "pageSize={pageSize}&page={page}"; if (!isEmpty(pageLink.getTextSearch())) { urlParams += "&textSearch={textSearch}"; } if (pageLink.getSortOrder() != null) { urlParams += "&sortProperty={sortProperty}&sortOrder={sortOrder}"; } return urlParams; } private String getWidgetTypeInfoPageRequestUrlParams(Boolean tenantOnly, Boolean fullSearch, DeprecatedFilter deprecatedFilter, List widgetTypeList) { String urlParams = getTenantOnlyAndFullSearchUrlParams(tenantOnly, fullSearch); if (deprecatedFilter != null) { urlParams += "&deprecatedFilter={deprecatedFilter}"; } if (!CollectionUtils.isEmpty(widgetTypeList)) { urlParams += "&widgetTypeList={widgetTypeList}"; } return urlParams; } private String getTenantOnlyAndFullSearchUrlParams(Boolean tenantOnly, Boolean fullSearch) { String urlParams = ""; if (tenantOnly != null) { urlParams = "&tenantOnly={tenantOnly}"; } if (fullSearch != null) { urlParams += "&fullSearch={fullSearch}"; } return urlParams; } private void addTimePageLinkToParam(Map params, TimePageLink pageLink) { this.addPageLinkToParam(params, pageLink); if (pageLink.getStartTime() != null) { params.put("startTime", String.valueOf(pageLink.getStartTime())); } if (pageLink.getEndTime() != null) { params.put("endTime", String.valueOf(pageLink.getEndTime())); } } private void addPageLinkToParam(Map params, PageLink pageLink) { params.put("pageSize", String.valueOf(pageLink.getPageSize())); params.put("page", String.valueOf(pageLink.getPage())); if (!isEmpty(pageLink.getTextSearch())) { params.put("textSearch", pageLink.getTextSearch()); } if (pageLink.getSortOrder() != null) { params.put("sortProperty", pageLink.getSortOrder().getProperty()); params.put("sortOrder", pageLink.getSortOrder().getDirection().name()); } } private void addWidgetInfoFiltersToParams(Boolean tenantOnly, Boolean fullSearch, DeprecatedFilter deprecatedFilter, List widgetTypeList, Map params) { addTenantOnlyAndFullSearchToParams(tenantOnly, fullSearch, params); if (deprecatedFilter != null) { params.put("deprecatedFilter", deprecatedFilter.name()); } if (!CollectionUtils.isEmpty(widgetTypeList)) { params.put("widgetTypeList", listToString(widgetTypeList)); } } private void addTenantOnlyAndFullSearchToParams(Boolean tenantOnly, Boolean fullSearch, Map params) { if (tenantOnly != null) { params.put("tenantOnly", tenantOnly.toString()); } if (fullSearch != null) { params.put("fullSearch", fullSearch.toString()); } } private String listToString(List list) { return String.join(",", list); } private String listIdsToString(List list) { return listToString(list.stream().map(id -> id.getId().toString()).collect(Collectors.toList())); } private String listEnumToString(List list) { return listToString(list.stream().map(Enum::name).collect(Collectors.toList())); } private HttpEntity> createMultipartRequest(String fileName, byte[] fileData, String fileContentType, Map otherParts) { HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.MULTIPART_FORM_DATA); MultiValueMap fileMap = new LinkedMultiValueMap<>(); fileMap.add(HttpHeaders.CONTENT_DISPOSITION, "form-data; name=file; filename=" + fileName); if (fileContentType != null) { fileMap.add(HttpHeaders.CONTENT_TYPE, fileContentType); } HttpEntity fileEntity = new HttpEntity<>(new ByteArrayResource(fileData), fileMap); MultiValueMap body = new LinkedMultiValueMap<>(); body.setAll(otherParts); body.add("file", fileEntity); return new HttpEntity<>(body, headers); } @Override public void close() { if (executor.isInitialized()) { getExecutor().shutdown(); } } @SneakyThrows private ExecutorService getExecutor() { return executor.get(); } }