removed unnecessary methods

2 years ago · 2fc32ee232
9 changed files with 84 additions and 29 deletions
--- a/application/src/main/java/org/thingsboard/server/service/entitiy/cf/CalculatedFieldState.java
+++ b/application/src/main/java/org/thingsboard/server/service/entitiy/cf/CalculatedFieldState.java
@ -15,6 +15,7 @@
 */
 package org.thingsboard.server.service.entitiy.cf;

+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import org.thingsboard.server.common.data.cf.CalculatedFieldConfiguration;
@ -32,6 +33,7 @@ import java.util.Map;
 })
 public interface CalculatedFieldState {

+    @JsonIgnore
    CalculatedFieldType getType();

    void performCalculation(Map<String, String> argumentValues, CalculatedFieldConfiguration calculatedFieldConfiguration, boolean initialCalculation);
--- a/application/src/main/java/org/thingsboard/server/service/entitiy/cf/DefaultTbCalculatedFieldService.java
+++ b/application/src/main/java/org/thingsboard/server/service/entitiy/cf/DefaultTbCalculatedFieldService.java
@ -96,7 +96,7 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
    private final ConcurrentMap<CalculatedFieldId, List<CalculatedFieldLink>> calculatedFieldLinks = new ConcurrentHashMap<>();
    private final ConcurrentMap<String, CalculatedFieldCtx> states = new ConcurrentHashMap<>();

-    @Value("${state.initFetchPackSize:50000}")
+    @Value("${calculatedField.initFetchPackSize:50000}")
    @Getter
    private int initFetchPackSize;

@ -145,7 +145,10 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
            CalculatedField cf = calculatedFieldService.findById(tenantId, calculatedFieldId);
            if (proto.getUpdated()) {
                log.info("Executing onCalculatedFieldUpdate, calculatedFieldId=[{}]", calculatedFieldId);
-                onCalculatedFieldUpdate(cf, callback);
+                boolean shouldReinit = onCalculatedFieldUpdate(cf, callback);
+                if (!shouldReinit) {
+                    return;
+                }
            }
            List<CalculatedFieldLink> links = calculatedFieldService.findAllCalculatedFieldLinksById(tenantId, calculatedFieldId);
            if (cf != null) {
@ -172,12 +175,13 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
                    default ->
                            throw new IllegalArgumentException("Entity type '" + calculatedFieldId.getEntityType() + "' does not support calculated fields.");
                }
-                log.info("Successfully processed calculated field message for calculatedFieldId: [{}]", calculatedFieldId);
            } else {
                //Calculated field was probably deleted while message was in queue;
                log.warn("Calculated field not found, possibly deleted: {}", calculatedFieldId);
                callback.onSuccess();
            }
+            callback.onSuccess();
+            log.info("Successfully processed calculated field message for calculatedFieldId: [{}]", calculatedFieldId);
        } catch (Exception e) {
            log.trace("Failed to process calculated field msg: [{}]", proto, e);
            callback.onFailure(e);
@ -235,17 +239,20 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
        }
    }

-    private void onCalculatedFieldUpdate(CalculatedField newCalculatedField, TbCallback callback) {
+    private boolean onCalculatedFieldUpdate(CalculatedField newCalculatedField, TbCallback callback) {
        CalculatedField oldCalculatedField = calculatedFields.get(newCalculatedField.getId());
-        if (hasSignificantChanged(oldCalculatedField, newCalculatedField)) {
+        boolean shouldReinit = true;
+        if (hasSignificantChanges(oldCalculatedField, newCalculatedField)) {
            onCalculatedFieldDelete(newCalculatedField.getId(), callback);
        } else {
            calculatedFields.put(newCalculatedField.getId(), newCalculatedField);
            callback.onSuccess();
+            shouldReinit = false;
        }
+        return shouldReinit;
    }

-    private boolean hasSignificantChanged(CalculatedField oldCalculatedField, CalculatedField newCalculatedField) {
+    private boolean hasSignificantChanges(CalculatedField oldCalculatedField, CalculatedField newCalculatedField) {
        if (oldCalculatedField == null) {
            return true;
        }
@ -255,9 +262,9 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
        CalculatedFieldConfiguration newConfig = newCalculatedField.getConfiguration();
        boolean argumentsChanged = !oldConfig.getArguments().equals(newConfig.getArguments());
        boolean outputTypeChanged = !oldConfig.getOutput().getType().equals(newConfig.getOutput().getType());
-        boolean outputNameChanged = !oldConfig.getOutput().getName().equals(newConfig.getOutput().getName());
+        boolean outputExpressionChanged = !oldConfig.getOutput().getExpression().equals(newConfig.getOutput().getExpression());

-        return entityIdChanged || typeChanged || argumentsChanged || outputTypeChanged || outputNameChanged;
+        return entityIdChanged || typeChanged || argumentsChanged || outputTypeChanged || outputExpressionChanged;
    }

    private void fetchCalculatedFields() {
@ -344,6 +351,7 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
        } else {
            CalculatedFieldState newState = createStateByType(calculatedField.getType());
            newState.performCalculation(argumentValues, calculatedField.getConfiguration(), true);
+            state = newState;
        }
        calculatedFieldCtx.setState(state);

--- a/application/src/main/resources/thingsboard.yml
+++ b/application/src/main/resources/thingsboard.yml
@ -424,6 +424,10 @@ sql:
    pool_size: "${SQL_RELATIONS_POOL_SIZE:4}" # This value has to be reasonably small to prevent the relation query from blocking all other DB calls
    query_timeout: "${SQL_RELATIONS_QUERY_TIMEOUT_SEC:20}" # This value has to be reasonably small to prevent the relation query from blocking all other DB calls

+# Calculated Field parameters
+calculatedField:
+  initFetchPackSize: "${INIT_FETCH_PACK_SIZE:50000}"
+
 rocksdb:
  # Rocksdb path
  db_path: "${ROCKS_DB_PATH:${java.io.tmpdir}/rocksdb}"
--- a/common/dao-api/src/main/java/org/thingsboard/server/dao/cf/CalculatedFieldService.java
+++ b/common/dao-api/src/main/java/org/thingsboard/server/dao/cf/CalculatedFieldService.java
@ -15,6 +15,7 @@
 */
 package org.thingsboard.server.dao.cf;

+import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
@ -33,6 +34,8 @@ public interface CalculatedFieldService extends EntityDaoService {

    CalculatedField findById(TenantId tenantId, CalculatedFieldId calculatedFieldId);

+    ListenableFuture<CalculatedField> findCalculatedFieldByIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId);
+
    List<CalculatedField> findAllCalculatedFields();

    PageData<CalculatedField> findAllCalculatedFields(PageLink pageLink);
@ -45,13 +48,15 @@ public interface CalculatedFieldService extends EntityDaoService {

    CalculatedFieldLink findCalculatedFieldLinkById(TenantId tenantId, CalculatedFieldLinkId calculatedFieldLinkId);

+    ListenableFuture<CalculatedFieldLink> findCalculatedFieldLinkByIdAsync(TenantId tenantId, CalculatedFieldLinkId calculatedFieldLinkId);
+
    List<CalculatedFieldLink> findAllCalculatedFieldLinks();

    List<CalculatedFieldLink> findAllCalculatedFieldLinksById(TenantId tenantId, CalculatedFieldId calculatedFieldId);

-    PageData<CalculatedFieldLink> findAllCalculatedFieldLinks(PageLink pageLink);
+    ListenableFuture<List<CalculatedFieldLink>> findAllCalculatedFieldLinksByIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId);

-    boolean existsByEntityId(TenantId tenantId, EntityId entityId);
+    PageData<CalculatedFieldLink> findAllCalculatedFieldLinks(PageLink pageLink);

    boolean referencedInAnyCalculatedField(TenantId tenantId, EntityId referencedEntityId);

--- a/dao/src/main/java/org/thingsboard/server/dao/cf/BaseCalculatedFieldService.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/cf/BaseCalculatedFieldService.java
@ -15,6 +15,7 @@
 */
 package org.thingsboard.server.dao.cf;

+import com.google.common.util.concurrent.ListenableFuture;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@ -30,7 +31,9 @@ import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.dao.entity.AbstractEntityService;
+import org.thingsboard.server.dao.eventsourcing.DeleteEntityEvent;
 import org.thingsboard.server.dao.eventsourcing.SaveEntityEvent;
+import org.thingsboard.server.dao.exception.IncorrectParameterException;
 import org.thingsboard.server.dao.service.DataValidator;

 import java.util.List;
@ -55,14 +58,14 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements

    @Override
    public CalculatedField save(CalculatedField calculatedField) {
-        calculatedFieldDataValidator.validate(calculatedField, CalculatedField::getTenantId);
+        CalculatedField oldCalculatedField = calculatedFieldDataValidator.validate(calculatedField, CalculatedField::getTenantId);
        try {
            TenantId tenantId = calculatedField.getTenantId();
            log.trace("Executing save calculated field, [{}]", calculatedField);
            CalculatedField savedCalculatedField = calculatedFieldDao.save(tenantId, calculatedField);
            createOrUpdateCalculatedFieldLink(tenantId, savedCalculatedField);
            eventPublisher.publishEvent(SaveEntityEvent.builder().tenantId(savedCalculatedField.getTenantId()).entityId(savedCalculatedField.getId())
-                    .entity(savedCalculatedField).created(calculatedField.getId() == null).build());
+                    .entity(savedCalculatedField).oldEntity(oldCalculatedField).created(calculatedField.getId() == null).build());
            return savedCalculatedField;
        } catch (Exception e) {
            checkConstraintViolation(e,
@ -80,6 +83,13 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
        return calculatedFieldDao.findById(tenantId, calculatedFieldId.getId());
    }

+    @Override
+    public ListenableFuture<CalculatedField> findCalculatedFieldByIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId) {
+        log.trace("Executing findCalculatedFieldByIdAsync [{}]", calculatedFieldId);
+        validateId(calculatedFieldId, id -> INCORRECT_CALCULATED_FIELD_ID + id);
+        return calculatedFieldDao.findByIdAsync(tenantId, calculatedFieldId.getId());
+    }
+
    @Override
    public List<CalculatedField> findAllCalculatedFields() {
        log.trace("Executing findAll");
@ -95,10 +105,28 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements

    @Override
    public void deleteCalculatedField(TenantId tenantId, CalculatedFieldId calculatedFieldId) {
-        log.trace("Executing deleteCalculatedField, tenantId [{}], calculatedFieldId [{}]", tenantId, calculatedFieldId);
        validateId(tenantId, id -> INCORRECT_TENANT_ID + id);
        validateId(calculatedFieldId, id -> INCORRECT_CALCULATED_FIELD_ID + id);
-        calculatedFieldDao.removeById(tenantId, calculatedFieldId.getId());
+        deleteEntity(tenantId, calculatedFieldId, false);
+    }
+
+    @Override
+    public void deleteEntity(TenantId tenantId, EntityId id, boolean force) {
+        CalculatedField calculatedField = calculatedFieldDao.findById(tenantId, id.getId());
+        if (calculatedField == null) {
+            if (force) {
+                return;
+            } else {
+                throw new IncorrectParameterException("Unable to delete non-existent calculated field.");
+            }
+        }
+        deleteCalculatedField(tenantId, calculatedField);
+    }
+
+    private void deleteCalculatedField(TenantId tenantId, CalculatedField calculatedField) {
+        log.trace("Executing deleteCalculatedField, tenantId [{}], calculatedFieldId [{}]", tenantId, calculatedField.getId());
+        calculatedFieldDao.removeById(tenantId, calculatedField.getUuidId());
+        eventPublisher.publishEvent(DeleteEntityEvent.builder().tenantId(tenantId).entityId(calculatedField.getId()).entity(calculatedField).build());
    }

    @Override
@ -125,6 +153,14 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
        return calculatedFieldLinkDao.findById(tenantId, calculatedFieldLinkId.getId());
    }

+    @Override
+    public ListenableFuture<CalculatedFieldLink> findCalculatedFieldLinkByIdAsync(TenantId tenantId, CalculatedFieldLinkId calculatedFieldLinkId) {
+        log.trace("Executing findCalculatedFieldLinkByIdAsync [{}]", calculatedFieldLinkId);
+        validateId(tenantId, id -> INCORRECT_TENANT_ID + id);
+        validateId(calculatedFieldLinkId, id -> "Incorrect calculatedFieldLinkId " + id);
+        return calculatedFieldLinkDao.findByIdAsync(tenantId, calculatedFieldLinkId.getId());
+    }
+
    @Override
    public List<CalculatedFieldLink> findAllCalculatedFieldLinks() {
        log.trace("Executing findAllCalculatedFieldLinks");
@ -137,6 +173,12 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
        return calculatedFieldLinkDao.findCalculatedFieldLinksByCalculatedFieldId(tenantId, calculatedFieldId);
    }

+    @Override
+    public ListenableFuture<List<CalculatedFieldLink>> findAllCalculatedFieldLinksByIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId) {
+        log.trace("Executing findAllCalculatedFieldLinksByIdAsync, calculatedFieldId [{}]", calculatedFieldId);
+        return calculatedFieldLinkDao.findCalculatedFieldLinksByCalculatedFieldIdAsync(tenantId, calculatedFieldId);
+    }
+
    @Override
    public PageData<CalculatedFieldLink> findAllCalculatedFieldLinks(PageLink pageLink) {
        log.trace("Executing findAllCalculatedFieldLinks, pageLink [{}]", pageLink);
@ -144,11 +186,6 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
        return calculatedFieldLinkDao.findAll(pageLink);
    }

-    @Override
-    public boolean existsByEntityId(TenantId tenantId, EntityId entityId) {
-        return calculatedFieldDao.existsByTenantIdAndEntityId(tenantId, entityId);
-    }
-
    @Override
    public boolean referencedInAnyCalculatedField(TenantId tenantId, EntityId referencedEntityId) {
        return calculatedFieldDao.findAllByTenantId(tenantId).stream()
--- a/dao/src/main/java/org/thingsboard/server/dao/cf/CalculatedFieldDao.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/cf/CalculatedFieldDao.java
@ -26,8 +26,6 @@ import java.util.List;

 public interface CalculatedFieldDao extends Dao<CalculatedField> {

-    boolean existsByTenantIdAndEntityId(TenantId tenantId, EntityId entityId);
-
    List<CalculatedField> findAllByTenantId(TenantId tenantId);

    List<CalculatedField> findAll();
--- a/dao/src/main/java/org/thingsboard/server/dao/cf/CalculatedFieldLinkDao.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/cf/CalculatedFieldLinkDao.java
@ -15,6 +15,7 @@
 */
 package org.thingsboard.server.dao.cf;

+import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
 import org.thingsboard.server.common.data.id.TenantId;
@ -28,6 +29,8 @@ public interface CalculatedFieldLinkDao extends Dao<CalculatedFieldLink> {

    List<CalculatedFieldLink> findCalculatedFieldLinksByCalculatedFieldId(TenantId tenantId, CalculatedFieldId calculatedFieldId);

+    ListenableFuture<List<CalculatedFieldLink>> findCalculatedFieldLinksByCalculatedFieldIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId);
+
    List<CalculatedFieldLink> findAll();

    PageData<CalculatedFieldLink> findAll(PageLink pageLink);
--- a/dao/src/main/java/org/thingsboard/server/dao/sql/cf/JpaCalculatedFieldDao.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/sql/cf/JpaCalculatedFieldDao.java
@ -18,7 +18,6 @@ package org.thingsboard.server.dao.sql.cf;
 import jakarta.transaction.Transactional;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.EntityType;
@ -31,7 +30,6 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.cf.CalculatedFieldDao;
 import org.thingsboard.server.dao.model.sql.CalculatedFieldEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
-import org.thingsboard.server.dao.sql.device.NativeDeviceRepository;
 import org.thingsboard.server.dao.util.SqlDao;

 import java.util.List;
@ -46,11 +44,6 @@ public class JpaCalculatedFieldDao extends JpaAbstractDao<CalculatedFieldEntity,
    private final CalculatedFieldRepository calculatedFieldRepository;
    private final NativeCalculatedFieldRepository nativeCalculatedFieldRepository;

-    @Override
-    public boolean existsByTenantIdAndEntityId(TenantId tenantId, EntityId entityId) {
-        return calculatedFieldRepository.existsByTenantIdAndEntityId(tenantId.getId(), entityId.getId());
-    }
-
    @Override
    public List<CalculatedField> findAllByTenantId(TenantId tenantId) {
        return DaoUtil.convertDataList(calculatedFieldRepository.findAllByTenantId(tenantId.getId()));
--- a/dao/src/main/java/org/thingsboard/server/dao/sql/cf/JpaCalculatedFieldLinkDao.java
+++ b/dao/src/main/java/org/thingsboard/server/dao/sql/cf/JpaCalculatedFieldLinkDao.java
@ -15,6 +15,7 @@
 */
 package org.thingsboard.server.dao.sql.cf;

+import com.google.common.util.concurrent.ListenableFuture;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.jpa.repository.JpaRepository;
@ -22,7 +23,6 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
-import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
@ -49,6 +49,11 @@ public class JpaCalculatedFieldLinkDao extends JpaAbstractDao<CalculatedFieldLin
        return DaoUtil.convertDataList(calculatedFieldLinkRepository.findAllByTenantIdAndCalculatedFieldId(tenantId.getId(), calculatedFieldId.getId()));
    }

+    @Override
+    public ListenableFuture<List<CalculatedFieldLink>> findCalculatedFieldLinksByCalculatedFieldIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId) {
+        return service.submit(() -> findCalculatedFieldLinksByCalculatedFieldId(tenantId, calculatedFieldId));
+    }
+
    @Override
    public List<CalculatedFieldLink> findAll() {
        return DaoUtil.convertDataList(calculatedFieldLinkRepository.findAll());