push addional code

Change-Id: Ia427bb3460cda3a896f8faced2de69eaf3807b74
Signed-off-by: Michael Lando <ml636r@att.com>

4 files changed, 799 insertions, 0 deletions

diff --git a/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionArtifactDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionArtifactDaoFactoryImpl.java
new file mode 100644
index 0000000000..2767c9eeca
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionArtifactDaoFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.action.dao.impl;
+
+import org.openecomp.sdc.action.dao.ActionArtifactDao;
+import org.openecomp.sdc.action.dao.ActionArtifactDaoFactory;
+
+public class ActionArtifactDaoFactoryImpl extends ActionArtifactDaoFactory {
+  private static final ActionArtifactDao INSTANCE = new ActionArtifactDaoImpl();
+
+  @Override
+  public ActionArtifactDao createInterface() {
+    return INSTANCE;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionArtifactDaoImpl.java b/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionArtifactDaoImpl.java
new file mode 100644
index 0000000000..3e884c24e3
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionArtifactDaoImpl.java
@@ -0,0 +1,150 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.action.dao.impl;
+
+import static org.openecomp.sdc.action.ActionConstants.TARGET_ENTITY_DB;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_QUERY_FAILURE_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_QUERY_FAILURE_MSG;
+import static org.openecomp.sdc.action.util.ActionUtil.actionLogPostProcessor;
+
+import com.datastax.driver.core.exceptions.NoHostAvailableException;
+import com.datastax.driver.mapping.Mapper;
+import com.datastax.driver.mapping.Result;
+import com.datastax.driver.mapping.annotations.Accessor;
+import com.datastax.driver.mapping.annotations.Query;
+import org.openecomp.core.dao.impl.CassandraBaseDao;
+import org.openecomp.core.logging.api.Logger;
+import org.openecomp.core.logging.api.LoggerFactory;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import org.openecomp.sdc.action.dao.ActionArtifactDao;
+import org.openecomp.sdc.action.dao.types.ActionArtifactEntity;
+import org.openecomp.sdc.action.errors.ActionException;
+import org.openecomp.sdc.action.logging.CategoryLogLevel;
+import org.openecomp.sdc.action.logging.StatusCode;
+import org.openecomp.sdc.action.types.ActionArtifact;
+import org.openecomp.sdc.action.types.ActionSubOperation;
+import org.openecomp.sdc.action.util.ActionUtil;
+
+import java.util.Collection;
+import java.util.List;
+
+public class ActionArtifactDaoImpl extends CassandraBaseDao<ActionArtifactEntity>
+    implements ActionArtifactDao {
+  private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+  private static final Mapper<ActionArtifactEntity> mapper =
+      noSqlDb.getMappingManager().mapper(ActionArtifactEntity.class);
+  private static final ActionArtifactAccessor accessor =
+      noSqlDb.getMappingManager().createAccessor(ActionArtifactAccessor.class);
+  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
+
+  @Override
+  protected Mapper<ActionArtifactEntity> getMapper() {
+    return mapper;
+  }
+
+  @Override
+  protected Object[] getKeys(ActionArtifactEntity entity) {
+    return new Object[]{entity.getArtifactUuId(), entity.getEffectiveVersion()};
+  }
+
+  @Override
+  public Collection<ActionArtifactEntity> list(ActionArtifactEntity entity) {
+    return null;
+  }
+
+
+  @Override
+  public void uploadArtifact(ActionArtifact data) {
+    log.debug(" entering uploadArtifact with artifactName= " + data.getArtifactName());
+    try {
+      ActionUtil.actionLogPreProcessor(ActionSubOperation.CREATE_ACTION_ARTIFACT, TARGET_ENTITY_DB);
+      this.create(data.toEntity());
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+          ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+    log.debug(" exit uploadArtifact with artifactName= " + data.getArtifactName());
+  }
+
+  @Override
+  public ActionArtifact downloadArtifact(int effectiveVersion, String artifactUuId) {
+    log.debug(" entering downloadArtifact with artifactUUID= " + artifactUuId);
+    ActionArtifact actionArtifact = null;
+    try {
+      ActionUtil
+          .actionLogPreProcessor(ActionSubOperation.GET_ARTIFACT_BY_ARTIFACTUUID, TARGET_ENTITY_DB);
+      Result<ActionArtifactEntity> result;
+      result = accessor.getArtifactByUuId(effectiveVersion, artifactUuId);
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+      List<ActionArtifactEntity> artifactEntities = result.all();
+      if (artifactEntities != null && !artifactEntities.isEmpty()) {
+        ActionArtifactEntity artifactEntity = artifactEntities.get(0);
+        actionArtifact = artifactEntity.toDto();
+      }
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+          ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+    log.debug(" exit downloadArtifact with artifactUUID= " + artifactUuId);
+    return actionArtifact;
+  }
+
+  @Override
+  public void updateArtifact(ActionArtifact data) {
+    log.debug(" entering updateArtifact with artifactName= " + data.getArtifactName());
+    try {
+      ActionUtil.actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION_ARTIFACT, TARGET_ENTITY_DB);
+      this.update(data.toEntity());
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+          ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+    log.debug(" exit updateArtifact with artifactName= " + data.getArtifactName());
+  }
+
+  private void logGenericException(Exception exception) {
+    ActionUtil.actionLogPostProcessor(StatusCode.ERROR, ACTION_QUERY_FAILURE_CODE,
+        ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG, false);
+    log.metrics("");
+    ActionUtil.actionErrorLogProcessor(CategoryLogLevel.FATAL, ACTION_QUERY_FAILURE_CODE,
+        ACTION_QUERY_FAILURE_MSG);
+    log.error(exception.getMessage());
+  }
+
+  @Accessor
+  interface ActionArtifactAccessor {
+
+    @Query(
+        "SELECT * FROM action_artifact WHERE effective_version <= ? and artifactuuid = ? limit 1")
+    Result<ActionArtifactEntity> getArtifactByUuId(int effectiveVersion, String artifactUuId);
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionDaoFactoryImpl.java b/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionDaoFactoryImpl.java
new file mode 100644
index 0000000000..66bd20687d
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionDaoFactoryImpl.java
@@ -0,0 +1,33 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.action.dao.impl;
+
+import org.openecomp.sdc.action.dao.ActionDao;
+import org.openecomp.sdc.action.dao.ActionDaoFactory;
+
+public class ActionDaoFactoryImpl extends ActionDaoFactory {
+  private static final ActionDao INSTANCE = new ActionDaoImpl();
+
+  @Override
+  public ActionDao createInterface() {
+    return INSTANCE;
+  }
+}
diff --git a/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionDaoImpl.java b/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionDaoImpl.java
new file mode 100644
index 0000000000..29b5171470
--- /dev/null
+++ b/openecomp-be/lib/openecomp-sdc-action-lib/openecomp-sdc-action-core/src/main/java/org/openecomp/sdc/action/dao/impl/ActionDaoImpl.java
@@ -0,0 +1,583 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.action.dao.impl;
+
+import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
+import static com.datastax.driver.core.querybuilder.QueryBuilder.in;
+import static com.datastax.driver.core.querybuilder.QueryBuilder.set;
+import static org.openecomp.core.nosqldb.impl.cassandra.CassandraSessionFactory.getSession;
+import static org.openecomp.sdc.action.util.ActionUtil.actionLogPostProcessor;
+
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.Statement;
+import com.datastax.driver.core.UDTValue;
+import com.datastax.driver.core.exceptions.NoHostAvailableException;
+import com.datastax.driver.core.querybuilder.QueryBuilder;
+import com.datastax.driver.mapping.Mapper;
+import com.datastax.driver.mapping.Result;
+import com.datastax.driver.mapping.UDTMapper;
+import com.datastax.driver.mapping.annotations.Accessor;
+import com.datastax.driver.mapping.annotations.Query;
+import org.openecomp.core.dao.impl.CassandraBaseDao;
+import org.openecomp.core.logging.api.Logger;
+import org.openecomp.core.logging.api.LoggerFactory;
+import org.openecomp.core.nosqldb.api.NoSqlDb;
+import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
+import org.openecomp.core.utilities.json.JsonUtil;
+import org.openecomp.sdc.action.ActionConstants;
+import org.openecomp.sdc.action.dao.ActionDao;
+import org.openecomp.sdc.action.dao.types.ActionEntity;
+import org.openecomp.sdc.action.dao.types.EcompComponentEntity;
+import org.openecomp.sdc.action.errors.ActionErrorConstants;
+import org.openecomp.sdc.action.errors.ActionException;
+import org.openecomp.sdc.action.logging.CategoryLogLevel;
+import org.openecomp.sdc.action.logging.StatusCode;
+import org.openecomp.sdc.action.types.Action;
+import org.openecomp.sdc.action.types.ActionStatus;
+import org.openecomp.sdc.action.types.ActionSubOperation;
+import org.openecomp.sdc.action.types.EcompComponent;
+import org.openecomp.sdc.action.util.ActionUtil;
+import org.openecomp.sdc.versioning.VersioningManagerFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
+import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
+import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
+import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
+import org.slf4j.MDC;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class ActionDaoImpl extends CassandraBaseDao<ActionEntity> implements ActionDao {
+  private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+  private static final Mapper<ActionEntity> mapper =
+      noSqlDb.getMappingManager().mapper(ActionEntity.class);
+  private static final ActionAccessor accessor =
+      noSqlDb.getMappingManager().createAccessor(ActionAccessor.class);
+  private static final UDTMapper<Version> versionMapper =
+      noSqlDb.getMappingManager().udtMapper(Version.class);
+  private static final VersionInfoDao versionInfoDao =
+      VersionInfoDaoFactory.getInstance().createInterface();
+  private static final VersionInfoDeletedDao versionInfoDeletedDao =
+      VersionInfoDeletedDaoFactory.getInstance().createInterface();
+
+  private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
+
+
+  @Override
+  public void registerVersioning(String versionableEntityType) {
+    VersioningManagerFactory.getInstance().createInterface()
+        .register(versionableEntityType, new VersionableEntityMetadata(
+            mapper.getTableMetadata().getName(),
+            mapper.getTableMetadata().getPartitionKey().get(0).getName(),
+            mapper.getTableMetadata().getPartitionKey().get(1).getName()));
+  }
+
+  @Override
+  public Action createAction(Action actionDto) {
+    try {
+      ActionUtil.actionLogPreProcessor(
+          ActionSubOperation.CREATE_ACTION_ENTITY, ActionConstants.TARGET_ENTITY_DB);
+      this.create(actionDto.toEntity());
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+      return actionDto;
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE,
+          ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+  }
+
+  @Override
+  public Action updateAction(Action actionDto) {
+    try {
+      log.debug(" entering updateAction with actionUUID= " + actionDto.getActionUuId());
+      ActionUtil
+          .actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION,
+              ActionConstants.TARGET_ENTITY_DB);
+      this.update(actionDto.toEntity());
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+      log.debug(" exit updateAction with actionUUID= " + actionDto.getActionUuId());
+      return actionDto;
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE,
+          ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+  }
+
+  @Override
+  public void deleteAction(String actionInvariantUuId) {
+    try {
+      log.debug("entering deleteAction with actionInvariantUUID = " + actionInvariantUuId);
+      ActionUtil
+          .actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION,
+              ActionConstants.TARGET_ENTITY_DB);
+      VersionInfoDeletedEntity activeVersionEntity = versionInfoDeletedDao.get(
+          new VersionInfoDeletedEntity(ActionConstants.ACTION_VERSIONABLE_TYPE,
+              actionInvariantUuId));
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+      Version activeVersion = activeVersionEntity.getActiveVersion();
+      Statement getNameFromInvUuId = QueryBuilder.select().column("name").from("dox", "Action")
+          .where(eq("actioninvariantuuid", actionInvariantUuId))
+          .and(in("version", versionMapper.toUDT(activeVersion)));
+      ActionUtil
+          .actionLogPreProcessor(ActionSubOperation.GET_NAME_BY_ACTIONINVID,
+              ActionConstants.TARGET_ENTITY_DB);
+      ResultSet results = getSession().execute(getNameFromInvUuId);
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+      if (!results.isExhausted()) {
+        String name = results.one().getString("name");
+        List<Version> versions = getVersionsByName(name);
+        updateActionStatusForDelete(actionInvariantUuId, versions);
+      }
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE,
+          ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+    log.debug("exit deleteAction");
+  }
+
+
+  @Override
+  public List<Action> getActionsByActionInvariantUuId(String actionInvariantUuId) {
+    List<Action> actions = new ArrayList<>();
+    try {
+      log.debug(" entering getActionsByActionInvariantUUID with actionInvariantUUID= "
+          + actionInvariantUuId);
+      Set<Version> viewableVersions = new HashSet<>();
+      VersionPredicate filter = new VersionPredicate();
+      ActionUtil
+          .actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION,
+              ActionConstants.TARGET_ENTITY_DB);
+      VersionInfoEntity versionInfoEntity = versionInfoDao
+          .get(new VersionInfoEntity(ActionConstants.ACTION_VERSIONABLE_TYPE, actionInvariantUuId));
+      if (versionInfoEntity == null) {
+        //Check for action in the Delete version info table
+        VersionInfoDeletedEntity versionInfoDeletedEntity = versionInfoDeletedDao.get(
+            new VersionInfoDeletedEntity(ActionConstants.ACTION_VERSIONABLE_TYPE,
+                actionInvariantUuId));
+        if (versionInfoDeletedEntity != null) {
+          viewableVersions = versionInfoDeletedEntity.getViewableVersions();
+          //Remove intermediate minor versions from viewable versions
+          if (versionInfoDeletedEntity.getActiveVersion() != null) {
+            filter.activeVersion = versionInfoDeletedEntity.getActiveVersion();
+            filter.finalVersion = versionInfoDeletedEntity.getLatestFinalVersion();
+            viewableVersions.removeIf(filter::isIntermediateMinorVersion);
+          }
+        }
+      } else {
+        viewableVersions = versionInfoEntity.getViewableVersions();
+        //Remove intermediate minor versions from viewable versions
+        if (versionInfoEntity.getActiveVersion() != null) {
+          filter.activeVersion = versionInfoEntity.getActiveVersion();
+          filter.finalVersion = versionInfoEntity.getLatestFinalVersion();
+          viewableVersions.removeIf(filter::isIntermediateMinorVersion);
+        }
+        //Add candidate version if available
+        if (versionInfoEntity.getCandidate() != null) {
+          viewableVersions.add(versionInfoEntity.getCandidate().getVersion());
+        }
+      }
+      MDC.put(ActionConstants.TARGET_ENTITY, ActionConstants.TARGET_ENTITY_DB);
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+
+      log.debug(
+          "Found " + viewableVersions + " viewable version for action with actionInvariantUUID "
+              + actionInvariantUuId);
+
+      //Fetch action data for the viewable versions
+      if (!viewableVersions.isEmpty()) {
+        ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONINVID,
+            ActionConstants.TARGET_ENTITY_DB);
+        Result<ActionEntity> result =
+            accessor.getActionsByInvId(actionInvariantUuId, viewableVersions);
+        ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+        log.metrics("");
+        if (result != null) {
+          actions
+              .addAll(result.all().stream().map(ActionEntity::toDto).collect(Collectors.toList()));
+        }
+      }
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE,
+          ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+    log.debug(
+        " exit getActionsByActionInvariantUUID with actionInvariantUUID= " + actionInvariantUuId);
+    return actions;
+  }
+
+  private void logGenericException(Exception exception) {
+    ActionUtil
+        .actionLogPostProcessor(StatusCode.ERROR, ActionErrorConstants.ACTION_QUERY_FAILURE_CODE,
+            ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG, false);
+    log.metrics("");
+    ActionUtil.actionErrorLogProcessor(
+        CategoryLogLevel.FATAL, ActionErrorConstants.ACTION_QUERY_FAILURE_CODE,
+        ActionErrorConstants.ACTION_QUERY_FAILURE_MSG);
+    log.error(exception.getMessage());
+  }
+
+
+  @Override
+  public List<Action> getFilteredActions(String filterType, String filterId) {
+    List<Action> actions = new ArrayList<>();
+    Result<ActionEntity> result = null;
+    log.debug(
+        " entering getFilteredActions By filterType = " + filterType + " With value = " + filterId);
+    try {
+      switch (filterType) {
+        case ActionConstants.FILTER_TYPE_VENDOR:
+          ActionUtil
+              .actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_VENDOR,
+                  ActionConstants.TARGET_ENTITY_DB);
+          result = accessor.getActionsByVendor(filterId);
+          ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
+          log.metrics("");
+          break;
+        case ActionConstants.FILTER_TYPE_CATEGORY:
+          ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_CATEGORY,
+              ActionConstants.TARGET_ENTITY_DB);
+          result = accessor.getActionsByCategory(filterId);
+          ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
+          log.metrics("");
+          break;
+        case ActionConstants.FILTER_TYPE_MODEL:
+          ActionUtil
+              .actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_MODEL,
+                  ActionConstants.TARGET_ENTITY_DB);
+          result = accessor.getActionsByModel(filterId);
+          ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
+          log.metrics("");
+          break;
+        case ActionConstants.FILTER_TYPE_ECOMP_COMPONENT:
+          ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_COMPONENT,
+              ActionConstants.TARGET_ENTITY_DB);
+          result = accessor.getActionsByEcompComponent(filterId);
+          ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
+          log.metrics("");
+          break;
+        case ActionConstants.FILTER_TYPE_NONE:
+          ActionUtil
+              .actionLogPreProcessor(ActionSubOperation.GET_ALL_ACTIONS,
+                  ActionConstants.TARGET_ENTITY_DB);
+          result = accessor.getAllActions();
+          ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
+          log.metrics("");
+          break;
+        case ActionConstants.FILTER_TYPE_NAME:
+          ActionUtil
+              .actionLogPreProcessor(ActionSubOperation.GET_ACTIONINVID_BY_NAME,
+                  ActionConstants.TARGET_ENTITY_DB);
+          result = accessor.getInvIdByName(filterId);
+          ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
+          log.metrics("");
+          List<ActionEntity> actionEntities = result.all();
+          if (actionEntities != null && !actionEntities.isEmpty()) {
+            String actionInvariantUuId = actionEntities.get(0).getActionInvariantUuId();
+            if (actionInvariantUuId != null) {
+              return getActionsByActionInvariantUuId(actionInvariantUuId);
+            } else {
+              return actions;
+            }
+          }
+          break;
+        default:
+          break;
+      }
+      if (result != null) {
+        actions.addAll(result.all().stream().map(ActionEntity::toDto).collect(Collectors.toList()));
+      }
+      log.debug(
+          " exit getFilteredActions By filterType = " + filterType + " With value = " + filterId);
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE,
+          ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+    return actions;
+  }
+
+  @Override
+  public List<EcompComponent> getEcompComponents() {
+    List<EcompComponent> ecompComponents = new ArrayList<>();
+    Result<EcompComponentEntity> result;
+    try {
+      log.debug(" entering getECOMPComponents ");
+      ActionUtil
+          .actionLogPreProcessor(ActionSubOperation.GET_ECOMP_COMPONENTS_ENTITY,
+              ActionConstants.TARGET_ENTITY_DB);
+      result = accessor.getEcompComponents();
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+      if (result != null) {
+        ecompComponents.addAll(
+            result.all().stream().map(EcompComponentEntity::toDto).collect(Collectors.toList()));
+      }
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE,
+          ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+    log.debug(" exit getECOMPComponents ");
+    return ecompComponents;
+  }
+
+  @Override
+  public Action getActionsByActionUuId(String uniqueId) {
+    try {
+      log.debug(" entering getActionsByActionUUID with actionUUID= " + uniqueId);
+      ActionUtil
+          .actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONUUID,
+              ActionConstants.TARGET_ENTITY_DB);
+      Result<ActionEntity> result = accessor.actionInvariantUuId(uniqueId);
+      ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+      log.metrics("");
+      if (result != null) {
+        log.debug(" exit getActionsByActionUUID with actionUUID= " + uniqueId);
+        ActionEntity entity = result.one();
+        if (entity != null) {
+          return entity.toDto();
+        }
+      }
+      log.debug(" exit getActionsByActionUUID with actionUUID= " + uniqueId);
+      return null;
+    } catch (NoHostAvailableException noHostAvailableException) {
+      logGenericException(noHostAvailableException);
+      throw new ActionException(ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE,
+          ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+    }
+  }
+
+  @Override
+  public Action getLockedAction(String actionInvariantUuId, String user) throws ActionException {
+    log.debug(" entering getLockedAction with actionInvariantUUID= " + actionInvariantUuId);
+    ActionUtil
+        .actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION,
+            ActionConstants.TARGET_ENTITY_DB);
+    Action action = null;
+    VersionInfoEntity versionInfoEntity = versionInfoDao
+        .get(new VersionInfoEntity(ActionConstants.ACTION_VERSIONABLE_TYPE, actionInvariantUuId));
+    ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+    log.metrics("");
+    if (versionInfoEntity != null) {
+      if (versionInfoEntity.getCandidate() != null) {
+        String actionUser = versionInfoEntity.getCandidate().getUser();
+        if (actionUser != null && actionUser.equals(user)) {
+          Set<Version> versions = new HashSet<>();
+          versions.add(versionInfoEntity.getCandidate().getVersion());
+          ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONINVID,
+              ActionConstants.TARGET_ENTITY_DB);
+          Result<ActionEntity> result = accessor.getActionsByInvId(actionInvariantUuId, versions);
+          ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+          log.metrics("");
+          if (result != null) {
+            ActionEntity actionEntity = result.one();
+            action = actionEntity != null ? actionEntity.toDto() : null;
+          }
+        } else {
+          throw new ActionException(ActionErrorConstants.ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER_CODE,
+              String
+                  .format(ActionErrorConstants.ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER, actionUser));
+        }
+      } else {
+        throw new ActionException(
+            ActionErrorConstants.ACTION_NOT_LOCKED_CODE,
+            ActionErrorConstants.ACTION_NOT_LOCKED_MSG);
+      }
+    } else {
+      throw new ActionException(ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE,
+          ActionErrorConstants.ACTION_ENTITY_NOT_EXIST);
+    }
+    return action;
+  }
+
+  @Override
+  protected Mapper<ActionEntity> getMapper() {
+    return mapper;
+  }
+
+
+  @Override
+  protected Object[] getKeys(ActionEntity entity) {
+    return new Object[]{entity.getActionInvariantUuId(), versionMapper.toUDT(entity.getVersion())};
+  }
+
+  @Override
+  public Collection<ActionEntity> list(ActionEntity entity) {
+    return accessor.getAllActions().all();
+  }
+
+  /**
+   * param actionInvariantUuId. param versions.
+   */
+  private void updateActionStatusForDelete(String actionInvariantUuId, List<Version> versions) {
+    log.debug(
+        "entering updateActionStatusForDelete with actionInvariantUUID = " + actionInvariantUuId
+            + " for versions " + versions);
+    List<UDTValue> versionUdt = new ArrayList<>();
+
+    versions.forEach(v -> versionMapper.toUDT(v));
+    ActionUtil
+        .actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION_STATUS,
+            ActionConstants.TARGET_ENTITY_DB);
+
+    //Update the status column of action table
+    Statement updateStatusStatement =
+        QueryBuilder.update("dox", "Action").with(set("status", ActionStatus.Deleted.name()))
+            .where(eq("actioninvariantuuid", actionInvariantUuId)).and(in("version", versionUdt));
+    getSession().execute(updateStatusStatement);
+    ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+    log.metrics("");
+    //Update the status in the data field of action table
+    updateStatusInActionData(actionInvariantUuId, versions, ActionStatus.Deleted);
+    log.debug("exit updateActionStatusForDelete with actionInvariantUUID = " + actionInvariantUuId
+        + " for versions " + versions);
+  }
+
+  /**
+   * Update status for a list of versions for a given action.
+   *
+   * @param actionInvariantUuId Invariant UUID of the action.
+   * @param versions            List of {@link Version} for which the status has to be updated.
+   * @param status              The status value.
+   */
+  private void updateStatusInActionData(String actionInvariantUuId, List<Version> versions,
+                                        ActionStatus status) {
+    log.debug("entering updateStatusInActionData for actionInvariantUUID = " + actionInvariantUuId
+        + " and status = " + status + " for versions " + versions);
+    for (Version v : versions) {
+      ActionEntity entity = this.get(new ActionEntity(actionInvariantUuId, v));
+      String currentData = entity.getData();
+      Map<String, Object> currentDataMap = JsonUtil.json2Object(currentData, LinkedHashMap.class);
+      currentDataMap.put(ActionConstants.STATUS, status);
+      String updatedActionData = JsonUtil.object2Json(currentDataMap);
+      entity.setData(updatedActionData);
+      this.updateAction(entity.toDto());
+    }
+    log.debug("exit updateStatusInActionData");
+  }
+
+  /**
+   * Get list of all major and minor version values for a given action by action name.
+   *
+   * @param name Name of the action
+   * @return List of {@link Version} objects for the action
+   */
+  private List<Version> getVersionsByName(String name) {
+    log.debug("entering getVersionsByName for Action Name = " + name);
+    ActionUtil
+        .actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION,
+            ActionConstants.TARGET_ENTITY_DB);
+    Statement statement =
+        QueryBuilder.select().column("version").from("dox", "Action").where(eq("name", name));
+    ResultSet results = getSession().execute(statement);
+    ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
+    log.metrics("");
+    List<Version> versionList = new ArrayList<>();
+    for (Row row : results) {
+      Version version = versionMapper.fromUDT((UDTValue) row.getObject("version"));
+      versionList.add(version);
+    }
+    log.debug("exit getVersionsByName for Action Name = " + name);
+    return versionList;
+  }
+
+  @Accessor
+  interface ActionAccessor {
+
+    @Query("SELECT * FROM Action")
+    Result<ActionEntity> getAllActions();
+
+    @Query("SELECT * FROM Action where actionInvariantUuId = ? and version in ? ")
+    Result<ActionEntity> getActionsByInvId(String actionInvariantUuId, Set<Version> versions);
+
+    @Query("SELECT * FROM Action where supportedModels CONTAINS ?")
+    Result<ActionEntity> getActionsByModel(String resource);
+
+    @Query("SELECT * FROM Action where supportedComponents CONTAINS ?")
+    Result<ActionEntity> getActionsByEcompComponent(String resource);
+
+    @Query("SELECT * FROM Action where vendor_list CONTAINS ?")
+    Result<ActionEntity> getActionsByVendor(String vendor);
+
+    @Query("SELECT * FROM Action where category_list CONTAINS ?")
+    Result<ActionEntity> getActionsByCategory(String vendor);
+
+    @Query("SELECT actionInvariantUuId FROM Action where name = ? limit 1")
+    Result<ActionEntity> getInvIdByName(String name);
+
+    @Query("SELECT * FROM ECOMPComponent")
+    Result<EcompComponentEntity> getEcompComponents();
+
+    @Query("SELECT * FROM Action where actionUUID = ?")
+    Result<ActionEntity> actionInvariantUuId(String actionUuId);
+
+  }
+
+  class VersionPredicate {
+    Version activeVersion;
+    Version finalVersion;
+
+    public boolean isIntermediateMinorVersion(Version version) {
+      int activeMajorVersion = activeVersion.getMajor();
+      int activeMinorVersion = activeVersion.getMinor();
+      int currentMinorVersion = version.getMinor();
+      int currentMajorVersion = version.getMajor();
+
+      if (finalVersion != null) {
+        if (finalVersion.getMajor() == activeMajorVersion
+            && currentMajorVersion == finalVersion.getMajor()) {
+          if (currentMinorVersion < activeMinorVersion && currentMinorVersion != 0) {
+            return true;
+          }
+        } else {
+          return false;
+        }
+      } else {
+        if (!version.equals(activeVersion)) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+  }
+}