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 static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_CATEGORY;
+import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_OPEN_ECOMP_COMPONENT;
+import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_MODEL;
+import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_NAME;
+import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_NONE;
+import static org.openecomp.sdc.action.ActionConstants.FILTER_TYPE_VENDOR;
+import static org.openecomp.sdc.action.ActionConstants.STATUS;
+import static org.openecomp.sdc.action.ActionConstants.TARGET_ENTITY;
+import static org.openecomp.sdc.action.ActionConstants.TARGET_ENTITY_DB;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_NOT_EXIST;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_NOT_LOCKED_CODE;
+import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_NOT_LOCKED_MSG;
+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 com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Row;
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.sdc.logging.api.Logger;
+import org.openecomp.sdc.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.dao.types.OpenEcompComponentEntity;
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.types.OpenEcompComponent;
import org.openecomp.sdc.action.util.ActionUtil;
import org.openecomp.sdc.versioning.VersioningManagerFactory;
import org.openecomp.sdc.versioning.dao.VersionInfoDao;
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 =
+ private static NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
+ private static Mapper<ActionEntity> mapper =
noSqlDb.getMappingManager().mapper(ActionEntity.class);
- private static final ActionAccessor accessor =
+ private static ActionAccessor accessor =
noSqlDb.getMappingManager().createAccessor(ActionAccessor.class);
- private static final UDTMapper<Version> versionMapper =
+ private static UDTMapper<Version> versionMapper =
noSqlDb.getMappingManager().udtMapper(Version.class);
- private static final VersionInfoDao versionInfoDao =
+ private static VersionInfoDao versionInfoDao =
VersionInfoDaoFactory.getInstance().createInterface();
- private static final VersionInfoDeletedDao versionInfoDeletedDao =
+ private static VersionInfoDeletedDao versionInfoDeletedDao =
VersionInfoDeletedDaoFactory.getInstance().createInterface();
private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName());
-
@Override
public void registerVersioning(String versionableEntityType) {
VersioningManagerFactory.getInstance().createInterface()
}
@Override
- public Action createAction(Action actionDto) {
+ public Action createAction(Action action) {
try {
- ActionUtil.actionLogPreProcessor(
- ActionSubOperation.CREATE_ACTION_ENTITY, ActionConstants.TARGET_ENTITY_DB);
- this.create(actionDto.toEntity());
+ ActionUtil.actionLogPreProcessor(ActionSubOperation.CREATE_ACTION_ENTITY, TARGET_ENTITY_DB);
+ this.create(action.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);
+ return action;
+ } catch (NoHostAvailableException exception) {
+ logGenericException(exception);
+ throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+ ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
}
}
@Override
- public Action updateAction(Action actionDto) {
+ public Action updateAction(Action action) {
try {
- log.debug(" entering updateAction with actionUUID= " + actionDto.getActionUuId());
- ActionUtil
- .actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION,
- ActionConstants.TARGET_ENTITY_DB);
- this.update(actionDto.toEntity());
+ log.debug(" entering updateAction with actionUUID= " + action.getActionUuId());
+ ActionUtil.actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION, TARGET_ENTITY_DB);
+ this.update(action.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);
+ log.debug(" exit updateAction with actionUUID= " + action.getActionUuId());
+ return action;
+ } catch (NoHostAvailableException exception) {
+ logGenericException(exception);
+ throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+ 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);
+ log.debug("entering deleteAction with actionInvariantUuId = " + actionInvariantUuId);
+ ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, 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);
+ .actionLogPreProcessor(ActionSubOperation.GET_NAME_BY_ACTIONINVID, 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);
}
} catch (NoHostAvailableException noHostAvailableException) {
logGenericException(noHostAvailableException);
- throw new ActionException(ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE,
- ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+ throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+ 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<>();
" entering getFilteredActions By filterType = " + filterType + " With value = " + filterId);
try {
switch (filterType) {
- case ActionConstants.FILTER_TYPE_VENDOR:
+ case FILTER_TYPE_VENDOR:
ActionUtil
.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_VENDOR,
- ActionConstants.TARGET_ENTITY_DB);
+ TARGET_ENTITY_DB);
result = accessor.getActionsByVendor(filterId);
ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
log.metrics("");
break;
- case ActionConstants.FILTER_TYPE_CATEGORY:
+ case FILTER_TYPE_CATEGORY:
ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_CATEGORY,
- ActionConstants.TARGET_ENTITY_DB);
+ TARGET_ENTITY_DB);
result = accessor.getActionsByCategory(filterId);
ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
log.metrics("");
break;
- case ActionConstants.FILTER_TYPE_MODEL:
+ case FILTER_TYPE_MODEL:
ActionUtil
.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_MODEL,
- ActionConstants.TARGET_ENTITY_DB);
+ TARGET_ENTITY_DB);
result = accessor.getActionsByModel(filterId);
ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
log.metrics("");
break;
- case ActionConstants.FILTER_TYPE_ECOMP_COMPONENT:
+ case FILTER_TYPE_OPEN_ECOMP_COMPONENT:
ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_COMPONENT,
- ActionConstants.TARGET_ENTITY_DB);
- result = accessor.getActionsByEcompComponent(filterId);
+ TARGET_ENTITY_DB);
+ result = accessor.getActionsByOpenEcompComponent(filterId);
ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
log.metrics("");
break;
- case ActionConstants.FILTER_TYPE_NONE:
- ActionUtil
- .actionLogPreProcessor(ActionSubOperation.GET_ALL_ACTIONS,
- ActionConstants.TARGET_ENTITY_DB);
+ case FILTER_TYPE_NONE:
+ ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ALL_ACTIONS, TARGET_ENTITY_DB);
result = accessor.getAllActions();
ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
log.metrics("");
break;
- case ActionConstants.FILTER_TYPE_NAME:
+ case FILTER_TYPE_NAME:
ActionUtil
- .actionLogPreProcessor(ActionSubOperation.GET_ACTIONINVID_BY_NAME,
- ActionConstants.TARGET_ENTITY_DB);
+ .actionLogPreProcessor(ActionSubOperation.GET_ACTIONINVID_BY_NAME, TARGET_ENTITY_DB);
result = accessor.getInvIdByName(filterId);
ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE);
log.metrics("");
" 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);
+ throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+ ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
}
return actions;
}
@Override
- public List<EcompComponent> getEcompComponents() {
- List<EcompComponent> ecompComponents = new ArrayList<>();
- Result<EcompComponentEntity> result;
+ public Action getActionsByActionUuId(String actionUuId) {
try {
- log.debug(" entering getECOMPComponents ");
- ActionUtil
- .actionLogPreProcessor(ActionSubOperation.GET_ECOMP_COMPONENTS_ENTITY,
- ActionConstants.TARGET_ENTITY_DB);
- result = accessor.getEcompComponents();
+ log.debug(" entering getActionsByActionUuId with actionUUID= " + actionUuId);
+ ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONUUID,
+ TARGET_ENTITY_DB);
+ Result<ActionEntity> result = accessor.actionInvariantUuId(actionUuId);
ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
log.metrics("");
if (result != null) {
- ecompComponents.addAll(
- result.all().stream().map(EcompComponentEntity::toDto).collect(Collectors.toList()));
+ log.debug(" exit getActionsByActionUuId with actionUUID= " + actionUuId);
+ ActionEntity entity = result.one();
+ if (entity != null) {
+ return entity.toDto();
+ }
}
+ log.debug(" exit getActionsByActionUuId with actionUUID= " + actionUuId);
+ return null;
} catch (NoHostAvailableException noHostAvailableException) {
logGenericException(noHostAvailableException);
- throw new ActionException(ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE,
- ActionErrorConstants.ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+ throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+ ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
}
- log.debug(" exit getECOMPComponents ");
- return ecompComponents;
}
@Override
- public Action getActionsByActionUuId(String uniqueId) {
+ public List<OpenEcompComponent> getOpenEcompComponents() {
+ List<OpenEcompComponent> openEcompComponents = new ArrayList<>();
+ Result<OpenEcompComponentEntity> result;
try {
- log.debug(" entering getActionsByActionUUID with actionUUID= " + uniqueId);
+ log.debug(" entering getOpenEcompComponents ");
ActionUtil
- .actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONUUID,
- ActionConstants.TARGET_ENTITY_DB);
- Result<ActionEntity> result = accessor.actionInvariantUuId(uniqueId);
+ .actionLogPreProcessor(ActionSubOperation.GET_OPEN_ECOMP_COMPONENTS_ENTITY, TARGET_ENTITY_DB);
+ result = accessor.getOpenEcompComponents();
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();
+ openEcompComponents.addAll(
+ result.all().stream().map(OpenEcompComponentEntity::toDto).collect(Collectors.toList()));
+ }
+ } catch (NoHostAvailableException noHostAvailableException) {
+ logGenericException(noHostAvailableException);
+ throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+ ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
+ }
+ log.debug(" exit getOpenEcompComponents ");
+ return openEcompComponents;
+ }
+
+ @Override
+ public List<Action> getActionsByActionInvariantUuId(String actionInvariantUuId) {
+ List<Action> actions = new ArrayList<Action>();
+ try {
+ log.debug(" entering getActionsByActionInvariantUuId with actionInvariantUuId= "
+ + actionInvariantUuId);
+ Set<Version> viewableVersions = new HashSet<>();
+ VersionPredicate filter = new VersionPredicate();
+ ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, 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(TARGET_ENTITY, 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,
+ 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()));
}
}
- 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);
+ throw new ActionException(ACTION_INTERNAL_SERVER_ERR_CODE,
+ ACTION_ENTITY_INTERNAL_SERVER_ERROR_MSG);
}
+ log.debug(
+ " exit getActionsByActionInvariantUuId with actionInvariantUuId= " + actionInvariantUuId);
+ return actions;
}
@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);
+ log.debug(" entering getLockedAction with actionInvariantUuId= " + actionInvariantUuId);
+ ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_DB);
Action action = null;
VersionInfoEntity versionInfoEntity = versionInfoDao
.get(new VersionInfoEntity(ActionConstants.ACTION_VERSIONABLE_TYPE, actionInvariantUuId));
Set<Version> versions = new HashSet<>();
versions.add(versionInfoEntity.getCandidate().getVersion());
ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONINVID,
- ActionConstants.TARGET_ENTITY_DB);
+ TARGET_ENTITY_DB);
Result<ActionEntity> result = accessor.getActionsByInvId(actionInvariantUuId, versions);
ActionUtil.actionLogPostProcessor(StatusCode.COMPLETE, null, "", false);
log.metrics("");
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));
+ throw new ActionException(ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER_CODE,
+ String.format(ACTION_ARTIFACT_DEL_LOCKED_OTHER_USER, actionUser));
}
} else {
- throw new ActionException(
- ActionErrorConstants.ACTION_NOT_LOCKED_CODE,
- ActionErrorConstants.ACTION_NOT_LOCKED_MSG);
+ throw new ActionException(ACTION_NOT_LOCKED_CODE, ACTION_NOT_LOCKED_MSG);
}
} else {
- throw new ActionException(ActionErrorConstants.ACTION_ENTITY_NOT_EXIST_CODE,
- ActionErrorConstants.ACTION_ENTITY_NOT_EXIST);
+ throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, ACTION_ENTITY_NOT_EXIST);
}
return action;
}
+ 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());
+ }
+
@Override
protected Mapper<ActionEntity> getMapper() {
return mapper;
}
/**
- * param actionInvariantUuId. param versions.
+ *
+ * @param actionInvariantUUID.
+ * @param versions.
*/
private void updateActionStatusForDelete(String actionInvariantUuId, List<Version> versions) {
log.debug(
- "entering updateActionStatusForDelete with actionInvariantUUID = " + actionInvariantUuId
+ "entering updateActionStatusForDelete with actionInvariantUuId = " + actionInvariantUuId
+ " for versions " + versions);
List<UDTValue> versionUdt = new ArrayList<>();
+ for (Version v : versions) {
+ versionUdt.add(versionMapper.toUDT(v));
+ }
- versions.forEach(v -> versionMapper.toUDT(v));
- ActionUtil
- .actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION_STATUS,
- ActionConstants.TARGET_ENTITY_DB);
-
+ ActionUtil.actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION_STATUS, TARGET_ENTITY_DB);
//Update the status column of action table
Statement updateStatusStatement =
QueryBuilder.update("dox", "Action").with(set("status", ActionStatus.Deleted.name()))
log.metrics("");
//Update the status in the data field of action table
updateStatusInActionData(actionInvariantUuId, versions, ActionStatus.Deleted);
- log.debug("exit updateActionStatusForDelete with actionInvariantUUID = " + actionInvariantUuId
+ log.debug("exit updateActionStatusForDelete with actionInvariantUuId = " + actionInvariantUuId
+ " for versions " + versions);
}
*/
private void updateStatusInActionData(String actionInvariantUuId, List<Version> versions,
ActionStatus status) {
- log.debug("entering updateStatusInActionData for actionInvariantUUID = " + actionInvariantUuId
- + " and status = " + status + " for versions " + versions);
+ 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);
+ currentDataMap.put(STATUS, status);
String updatedActionData = JsonUtil.object2Json(currentDataMap);
entity.setData(updatedActionData);
this.updateAction(entity.toDto());
/**
* 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
+ * @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);
+ ActionUtil.actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, 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"));
Result<ActionEntity> getActionsByModel(String resource);
@Query("SELECT * FROM Action where supportedComponents CONTAINS ?")
- Result<ActionEntity> getActionsByEcompComponent(String resource);
+ Result<ActionEntity> getActionsByOpenEcompComponent(String resource);
@Query("SELECT * FROM Action where vendor_list CONTAINS ?")
Result<ActionEntity> getActionsByVendor(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 EcompComponent")
+ Result<OpenEcompComponentEntity> getOpenEcompComponents();
@Query("SELECT * FROM Action where actionUUID = ?")
Result<ActionEntity> actionInvariantUuId(String actionUuId);
Code Review / sdc.git / blobdiff