diff options
Diffstat (limited to 'openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java')
| -rw-r--r-- | openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java | 1217 |
1 files changed, 1217 insertions, 0 deletions
diff --git a/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java b/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java new file mode 100644 index 0000000000..53ab943765 --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-action-manager/src/main/java/org/openecomp/sdc/action/impl/ActionManagerImpl.java @@ -0,0 +1,1217 @@ +/*- + * ============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.impl; + +import static org.openecomp.sdc.action.ActionConstants.SERVICE_INSTANCE_ID; +import static org.openecomp.sdc.action.ActionConstants.TARGET_ENTITY_API; +import static org.openecomp.sdc.action.ActionConstants.TARGET_ENTITY_DB; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_ALREADY_EXISTS; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_ALREADY_EXISTS_CODE; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_DELETE_READ_ONLY; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_DELETE_READ_ONLY_MSG; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_UPDATE_NAME_INVALID; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_UPDATE_READ_ONLY; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ARTIFACT_UPDATE_READ_ONLY_MSG; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_CHECKIN_ON_ENTITY_LOCKED_BY_OTHER_USER; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_CHECKIN_ON_UNLOCKED_ENTITY; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_CHECKOUT_ON_LOCKED_ENTITY; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_CHECKOUT_ON_LOCKED_ENTITY_OTHER_USER; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_DELETE_ON_LOCKED_ENTITY_CODE; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER; +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_ENTITY_UNIQUE_VALUE_ERROR; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_ENTITY_UNIQUE_VALUE_MSG; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_INTERNAL_SERVER_ERR_CODE; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_REQUESTED_VERSION_INVALID; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_SUBMIT_FINALIZED_ENTITY_NOT_ALLOWED; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_SUBMIT_LOCKED_ENTITY_NOT_ALLOWED; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UNDO_CHECKOUT_ON_ENTITY_LOCKED_BY_OTHER_USER; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UNDO_CHECKOUT_ON_UNLOCKED_ENTITY; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_INVALID_VERSION; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_CODE; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_CODE_NAME; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_NOT_ALLOWED_FOR_NAME; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_ON_UNLOCKED_ENTITY; +import static org.openecomp.sdc.action.errors.ActionErrorConstants.ACTION_UPDATE_PARAM_INVALID; +import static org.openecomp.sdc.action.util.ActionUtil.actionLogPostProcessor; +import static org.openecomp.sdc.action.util.ActionUtil.actionLogPreProcessor; +import static org.openecomp.sdc.versioning.dao.types.Version.VERSION_STRING_VIOLATION_MSG; + +import org.apache.commons.lang.StringUtils; +import org.openecomp.core.logging.api.Logger; +import org.openecomp.core.logging.api.LoggerFactory; +import org.openecomp.core.util.UniqueValueUtil; +import org.openecomp.core.utilities.CommonMethods; +import org.openecomp.core.utilities.json.JsonUtil; +import org.openecomp.sdc.action.ActionConstants; +import org.openecomp.sdc.action.ActionManager; +import org.openecomp.sdc.action.dao.ActionArtifactDao; +import org.openecomp.sdc.action.dao.ActionArtifactDaoFactory; +import org.openecomp.sdc.action.dao.ActionDao; +import org.openecomp.sdc.action.dao.ActionDaoFactory; +import org.openecomp.sdc.action.dao.types.ActionArtifactEntity; +import org.openecomp.sdc.action.dao.types.ActionEntity; +import org.openecomp.sdc.action.errors.ActionErrorConstants; +import org.openecomp.sdc.action.errors.ActionException; +import org.openecomp.sdc.action.logging.StatusCode; +import org.openecomp.sdc.action.types.Action; +import org.openecomp.sdc.action.types.ActionArtifact; +import org.openecomp.sdc.action.types.ActionArtifactProtection; +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.common.errors.CoreException; +import org.openecomp.sdc.versioning.VersioningManager; +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.types.UserCandidateVersion; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity; +import org.openecomp.sdc.versioning.errors.EntityNotExistErrorBuilder; +import org.openecomp.sdc.versioning.errors.VersioningErrorCodes; +import org.openecomp.sdc.versioning.types.VersionInfo; +import org.openecomp.sdc.versioning.types.VersionableEntityAction; +import org.slf4j.MDC; + +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Date; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.UUID; + + +/** + * Manager Implementation for {@link ActionManager Action Library Operations}. <br> Handles Business + * layer validations and acts as an interface between the REST and DAO layers. + */ +public class ActionManagerImpl implements ActionManager { + + private static final ActionDao actionDao = ActionDaoFactory.getInstance().createInterface(); + private static final VersioningManager versioningManager = + VersioningManagerFactory.getInstance().createInterface(); + private static final ActionArtifactDao actionArtifactDao = + ActionArtifactDaoFactory.getInstance().createInterface(); + private static VersionInfoDao versionInfoDao = + VersionInfoDaoFactory.getInstance().createInterface(); + + private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName()); + + public ActionManagerImpl() { + actionDao.registerVersioning(ActionConstants.ACTION_VERSIONABLE_TYPE); + } + + /** + * Get Current Timestamp in UTC format. + * + * @return Current Timestamp in UTC format. + */ + public static Date getCurrentTimeStampUtc() { + return Date.from(java.time.ZonedDateTime.now(ZoneOffset.UTC).toInstant()); + } + + /** + * List All Major, Last Minor and Candidate version (if any) for Given Action Invariant UUID. + * + * @param invariantId Invariant UUID of the action for which the information is required. + * @return List of All Major, Last Minor and Candidate version if any Of {@link Action} with given + actionInvariantUuId. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred during the operation. + */ + @Override + public List<Action> getActionsByActionInvariantUuId(String invariantId) throws ActionException { + log.debug(" entering getActionsByActionInvariantUUID with invariantID = " + invariantId); + List<Action> actions = actionDao + .getActionsByActionInvariantUuId(invariantId != null ? invariantId.toUpperCase() : null); + if (actions != null && actions.isEmpty()) { + throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, ACTION_ENTITY_NOT_EXIST); + } + log.debug(" exit getActionsByActionInvariantUUID with invariantID = " + invariantId); + return actions; + } + + /** + * Get list of actions based on a filter criteria. If no filter is sent all actions will be + * returned. + * + * @param filterType Filter by Vendor/Category/Model/Component/None. + * @param filterValue Filter Parameter Value (Vendor ID/Category ID/Model ID/Component ID). + * @return List of {@link Action} objects based on a filter criteria <br> Empty List if no records + match the provided filter criteria. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred for the error occurred during + * the operation. + */ + @Override + public List<Action> getFilteredActions(String filterType, String filterValue) + throws ActionException { + log.debug(" entering getFilteredActions By filterType = " + filterType + " With value = " + + filterValue); + List<Action> actions; + switch (filterType) { + case ActionConstants.FILTER_TYPE_NONE: + //Business validation for ECOMP Component type fetch (if any) + break; + case ActionConstants.FILTER_TYPE_VENDOR: + //Business validation for vendor type fetch (if any) + break; + case ActionConstants.FILTER_TYPE_CATEGORY: + //Business validation for Category type fetch (if any) + break; + case ActionConstants.FILTER_TYPE_MODEL: + //Business validation for model type fetch (if any) + break; + case ActionConstants.FILTER_TYPE_ECOMP_COMPONENT: + //Business validation for ECOMP Component type fetch (if any) + break; + case ActionConstants.FILTER_TYPE_NAME: + actions = actionDao + .getFilteredActions(filterType, filterValue != null ? filterValue.toLowerCase() : null); + if (actions != null && actions.isEmpty()) { + throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, ACTION_ENTITY_NOT_EXIST); + } + log.debug(" exit getFilteredActions By filterType = " + filterType + " With value = " + + filterValue); + return actions; + default: + break; + } + actions = actionDao + .getFilteredActions(filterType, filterValue != null ? filterValue.toLowerCase() : null); + List<Action> majorMinorVersionList = getMajorMinorVersionActions(actions); + Collections.sort(majorMinorVersionList); + log.debug( + " exit getFilteredActions By filterType = " + filterType + " With value = " + filterValue); + return majorMinorVersionList; + } + + /** + * Get the properties of an action version by its UUID. + * + * @param actionUuId UUID of the specific action version. + * @return {@link Action} object corresponding the version represented by the UUID. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred for the error occurred during + * the operation. + */ + @Override + public Action getActionsByActionUuId(String actionUuId) throws ActionException { + log.debug(" entering getActionsByActionUUID with actionUUID = " + actionUuId); + Action action = + actionDao.getActionsByActionUuId(actionUuId != null ? actionUuId.toUpperCase() : null); + + if (action == null) { + throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, ACTION_ENTITY_NOT_EXIST); + } + log.debug(" exit getActionsByActionUUID with actionUUID = " + actionUuId); + return action; + } + + /** + * List ECOMP Components supported by Action Library + * + * @return List of {@link EcompComponent} objects supported by Action Library <br> Empty List if + no components are found. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred for the error occurred during + * the operation. + */ + @Override + public List<EcompComponent> getEcompComponents() throws ActionException { + return actionDao.getEcompComponents(); + } + + + /** + * Delete an action. + * + * @param actionInvariantUuId Invariant UUID of the action to be deleted. + * @param user User id of the user performing the operation. + */ + @Override + public void deleteAction(String actionInvariantUuId, String user) throws ActionException { + try { + log.debug("entering deleteAction with actionInvariantUUID = " + actionInvariantUuId + + " and user = " + user); + actionLogPreProcessor(ActionSubOperation.DELETE_ACTION, TARGET_ENTITY_API); + versioningManager.delete(ActionConstants.ACTION_VERSIONABLE_TYPE, actionInvariantUuId, user); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + actionDao.deleteAction(actionInvariantUuId); + } catch (CoreException ce) { + formAndThrowException(ce); + } + } + + /** + * Create a new Action. + * + * @param action Action object model of the user request for creating an action. + * @param user AT&T id of the user sending the create request. + * @return {@link Action} model object for the created action. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred for the error occurred during + * the operation. + */ + @Override + public Action createAction(Action action, String user) throws ActionException { + try { + actionLogPreProcessor(ActionSubOperation.VALIDATE_ACTION_UNIQUE_NAME, TARGET_ENTITY_API); + UniqueValueUtil + .validateUniqueValue(ActionConstants.UniqueValues.ACTION_NAME, action.getName()); + actionLogPostProcessor(StatusCode.COMPLETE); + } catch (CoreException ce) { + String errorDesc = String + .format(ACTION_ENTITY_UNIQUE_VALUE_MSG, ActionConstants.UniqueValues.ACTION_NAME, + action.getName()); + actionLogPostProcessor(StatusCode.ERROR, ACTION_ENTITY_UNIQUE_VALUE_ERROR, errorDesc, false); + throw new ActionException(ACTION_ENTITY_UNIQUE_VALUE_ERROR, errorDesc); + } finally { + log.metrics(""); + } + + action.setUser(user); + action.setTimestamp(getCurrentTimeStampUtc()); + action.setActionInvariantUuId(CommonMethods.nextUuId()); + action.setActionUuId(CommonMethods.nextUuId()); + + actionLogPreProcessor(ActionSubOperation.CREATE_ACTION_VERSION, TARGET_ENTITY_API); + Version version = versioningManager + .create(ActionConstants.ACTION_VERSIONABLE_TYPE, action.getActionInvariantUuId(), user); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + action.setVersion(version.toString()); + action.setStatus(ActionStatus.Locked); + action = updateData(action); + action = actionDao.createAction(action); + actionLogPreProcessor(ActionSubOperation.CREATE_ACTION_UNIQUE_VALUE, TARGET_ENTITY_API); + UniqueValueUtil.createUniqueValue(ActionConstants.UniqueValues.ACTION_NAME, action.getName()); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + return action; + } + + /** + * Update an existing action. + * + * @param action Action object model of the user request for creating an action. + * @param user AT&T id of the user sending the update request. + * @return {@link Action} model object for the update action. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred for the error occurred during + * the operation. + */ + @Override + public Action updateAction(Action action, String user) throws ActionException { + try { + log.debug("entering updateAction to update action with invariantUUID = " + + action.getActionInvariantUuId() + " by user = " + user); + String invariantUuId = action.getActionInvariantUuId(); + actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_API); + VersionInfo versionInfo = versioningManager + .getEntityVersionInfo(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user, + VersionableEntityAction.Write); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + Version activeVersion = versionInfo.getActiveVersion(); + validateActions(action, activeVersion); + action.setStatus(ActionStatus.Locked); //Status will be Checkout for update + updateData(action); + action.setUser(user); + action.setTimestamp(getCurrentTimeStampUtc()); + actionDao.updateAction(action); + } catch (CoreException ce) { + formAndThrowException(ce); + } + log.debug("exit updateAction"); + return action; + } + + /** + * Checkout an existing action. + * + * @param invariantUuId actionInvariantUuId of the action to be checked out. + * @param user AT&T id of the user sending the checkout request. + * @return {@link Action} model object for the checkout action. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred for the error occurred during + * the operation. + */ + @Override + public Action checkout(String invariantUuId, String user) throws ActionException { + Version version = null; + ActionEntity actionEntity = null; + try { + log.debug( + "entering checkout for Action with invariantUUID= " + invariantUuId + " by user = " + + user); + actionLogPreProcessor(ActionSubOperation.CHECKOUT_ACTION, TARGET_ENTITY_API); + version = + versioningManager.checkout(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + actionEntity = + updateUniqueIdForVersion(invariantUuId, version, ActionStatus.Locked.name(), user); + } catch (CoreException e0) { + if (e0.code() != null + && e0.code().id().equals(VersioningErrorCodes.CHECKOT_ON_LOCKED_ENTITY)) { + actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_DB); + VersionInfoEntity versionInfoEntity = versionInfoDao + .get(new VersionInfoEntity(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId)); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + String checkoutUser = versionInfoEntity.getCandidate().getUser(); + log.debug( + "Actual checkout user for Action with invariantUUID= " + invariantUuId + " is = " + + checkoutUser); + if (!checkoutUser.equals(user)) { + throw new ActionException(ACTION_CHECKOUT_ON_LOCKED_ENTITY_OTHER_USER, e0.getMessage()); + } + } + formAndThrowException(e0); + } + log.debug( + "exit checkout for Action with invariantUUID= " + invariantUuId + " by user = " + user); + return actionEntity != null ? actionEntity.toDto() : new Action(); + } + + /** + * Undo an already checked out action. + * + * @param invariantUuId actionInvariantUuId of the checked out action. + * @param user AT&T id of the user sending the request. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred for the error occurred during + * the operation. + */ + @Override + public void undoCheckout(String invariantUuId, String user) throws ActionException { + Version version; + try { + log.debug( + "entering undoCheckout for Action with invariantUUID= " + invariantUuId + " by user = " + + user); + actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_DB); + //Get list of uploaded artifacts in this checked out version + VersionInfoEntity versionInfoEntity = versionInfoDao + .get(new VersionInfoEntity(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId)); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + if (versionInfoEntity == null) { + throw new CoreException( + new EntityNotExistErrorBuilder(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId) + .build()); + } + UserCandidateVersion candidate = versionInfoEntity.getCandidate(); + Version activeVersion; + if (candidate != null) { + activeVersion = candidate.getVersion(); + } else { + activeVersion = versionInfoEntity.getActiveVersion(); + } + actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_VERSION, TARGET_ENTITY_DB); + Action action = actionDao.get(new ActionEntity(invariantUuId, activeVersion)).toDto(); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + //Perform undo checkout on the action + actionLogPreProcessor(ActionSubOperation.UNDO_CHECKOUT_ACTION, TARGET_ENTITY_API); + version = versioningManager + .undoCheckout(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + if (version.equals(new Version(0, 0))) { + actionLogPreProcessor(ActionSubOperation.DELETE_UNIQUEVALUE, TARGET_ENTITY_API); + UniqueValueUtil + .deleteUniqueValue(ActionConstants.UniqueValues.ACTION_NAME, action.getName()); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + actionLogPreProcessor(ActionSubOperation.DELETE_ACTIONVERSION, TARGET_ENTITY_DB ); + //Added for the case where Create->Undo_Checkout->Checkout should not get the action + versionInfoDao + .delete(new VersionInfoEntity(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId)); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + } + List<ActionArtifact> currentVersionArtifacts = action.getArtifacts(); + + //Delete the artifacts from action_artifact table (if any) + if (currentVersionArtifacts != null && currentVersionArtifacts.size() > 0) { + for (ActionArtifact artifact : currentVersionArtifacts) { + ActionArtifactEntity artifactDeleteEntity = + new ActionArtifactEntity(artifact.getArtifactUuId(), + getEffectiveVersion(activeVersion.toString())); + actionLogPreProcessor(ActionSubOperation.DELETE_ARTIFACT, TARGET_ENTITY_DB); + actionArtifactDao.delete(artifactDeleteEntity); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + } + } + } catch (CoreException e0) { + formAndThrowException(e0); + } + log.debug( + "exit undoCheckout for Action with invariantUUID= " + invariantUuId + " by user = " + user); + } + + /** + * Checkin a checked out action. + * + * @param invariantUuId actionInvariantUuId of the checked out action. + * @param user AT&T id of the user sending the request. + * @return {@link Action} model object for the updated action. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred for the error occurred during + * the operation. + */ + @Override + public Action checkin(String invariantUuId, String user) throws ActionException { + Version version = null; + ActionEntity actionEntity = null; + try { + log.debug("entering checkin for Action with invariantUUID= " + invariantUuId + " by user = " + + user); + actionLogPreProcessor(ActionSubOperation.CHECKIN_ACTION, TARGET_ENTITY_API); + version = versioningManager + .checkin(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user, null); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + actionEntity = + updateStatusForVersion(invariantUuId, version, ActionStatus.Available.name(), user); + } catch (CoreException e0) { + formAndThrowException(e0); + } + log.debug( + "exit checkin for Action with invariantUUID= " + invariantUuId + " by user = " + user); + return actionEntity != null ? actionEntity.toDto() : new Action(); + } + + /** + * Submit a checked in action. + * + * @param invariantUuId actionInvariantUuId of the checked in action. + * @param user AT&T id of the user sending the request. + * @return {@link Action} model object for the updated action. + * @throws ActionException Exception with an action library specific code, short description and + * detailed message for the error occurred for the error occurred during + * the operation. + */ + @Override + public Action submit(String invariantUuId, String user) throws ActionException { + Version version = null; + ActionEntity actionEntity = null; + try { + log.debug("entering checkin for Action with invariantUUID= " + invariantUuId + " by user = " + + user); + actionLogPreProcessor(ActionSubOperation.CHECKIN_ACTION, TARGET_ENTITY_API); + version = versioningManager + .submit(ActionConstants.ACTION_VERSIONABLE_TYPE, invariantUuId, user, null); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + actionEntity = + updateUniqueIdForVersion(invariantUuId, version, ActionStatus.Final.name(), user); + } catch (CoreException e0) { + formAndThrowException(e0); + } + log.debug( + "exit checkin for Action with invariantUUID= " + invariantUuId + " by user = " + user); + return actionEntity != null ? actionEntity.toDto() : new Action(); + } + + /** + * Download an artifact of an action. + * + * @param artifactUuId {@link ActionArtifact} object representing the artifact and its metadata. + * @param actionUuId UUID of the action for which the artifact has to be downloaded. + * @return downloaded action artifact object. + */ + @Override + public ActionArtifact downloadArtifact(String actionUuId, String artifactUuId) + throws ActionException { + log.debug(" entering downloadArtifact with actionUUID= " + actionUuId + " and artifactUUID= " + + artifactUuId); + Action action = actionDao.getActionsByActionUuId(actionUuId); + ActionArtifact actionArtifact; + if (action != null) { + MDC.put(SERVICE_INSTANCE_ID, action.getActionInvariantUuId()); + List<ActionArtifact> artifacts = action.getArtifacts(); + String actionVersion = action.getVersion(); + int effectiveVersion = getEffectiveVersion(actionVersion); + ActionArtifact artifactMetadata = + getArtifactMetadataFromAction(artifacts, ActionConstants.ARTIFACT_METADATA_ATTR_UUID, + artifactUuId); + if (artifactMetadata != null) { + String artifactName = artifactMetadata.getArtifactName(); + actionArtifact = actionArtifactDao.downloadArtifact(effectiveVersion, artifactUuId); + actionArtifact.setArtifactName(artifactName); + + } else { + throw new ActionException(ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE, + ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST); + } + } else { + throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, + ACTION_ENTITY_NOT_EXIST); + } + log.debug(" exit downloadArtifact with actionUUID= " + actionUuId + " and artifactUUID= " + + artifactUuId); + return actionArtifact; + } + + /** + * Upload an artifact to an action. + * + * @param artifact {@link ActionArtifact} object representing the artifact and its + * metadata. + * @param actionInvariantUuId Invariant UUID of the action to which the artifact has to be + * uploaded. + * @param user User ID of the user sending the request. + * @return Uploaded action artifact object. + */ + @Override + public ActionArtifact uploadArtifact(ActionArtifact artifact, String actionInvariantUuId, + String user) { + ActionArtifact uploadArtifactResponse = new ActionArtifact(); + try { + log.debug("entering uploadArtifact with actionInvariantUUID= " + actionInvariantUuId + + "artifactName= " + artifact.getArtifactName()); + actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_DB); + VersionInfo versionInfo = versioningManager + .getEntityVersionInfo(ActionConstants.ACTION_VERSIONABLE_TYPE, actionInvariantUuId, user, + VersionableEntityAction.Write); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + Version activeVersion = versionInfo.getActiveVersion(); + actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONINVID, TARGET_ENTITY_DB); + Action action = actionDao.get(new ActionEntity(actionInvariantUuId, activeVersion)).toDto(); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + String artifactUuId = generateActionArtifactUuId(action, artifact.getArtifactName()); + //Check for Unique document name + List<ActionArtifact> actionArtifacts = action.getArtifacts(); + ActionArtifact artifactMetadata = getArtifactMetadataFromAction(actionArtifacts, + ActionConstants.ARTIFACT_METADATA_ATTR_NAME, artifact.getArtifactName()); + if (artifactMetadata != null) { + throw new ActionException(ACTION_ARTIFACT_ALREADY_EXISTS_CODE, + String.format(ACTION_ARTIFACT_ALREADY_EXISTS, actionInvariantUuId)); + } + + //Create the artifact + artifact.setArtifactUuId(artifactUuId); + artifact.setTimestamp(getCurrentTimeStampUtc()); + artifact.setEffectiveVersion(getEffectiveVersion(activeVersion.toString())); + actionArtifactDao.uploadArtifact(artifact); + + //Update the action data field and timestamp + addArtifactMetadataInActionData(action, artifact); + + //Set the response object + uploadArtifactResponse.setArtifactUuId(artifact.getArtifactUuId()); + } catch (CoreException ce) { + formAndThrowException(ce); + } + log.debug( + "exit uploadArtifact with actionInvariantUUID= " + actionInvariantUuId + "artifactName= " + + artifact.getArtifactName()); + return uploadArtifactResponse; + } + + @Override + public void deleteArtifact(String actionInvariantUuId, String artifactUuId, String user) + throws ActionException { + log.debug( + "enter deleteArtifact with actionInvariantUUID= " + actionInvariantUuId + "artifactUUID= " + + artifactUuId + " and user = " + user); + Action action = actionDao.getLockedAction(actionInvariantUuId, user); + List<ActionArtifact> actionArtifacts = action.getArtifacts(); + ActionArtifact artifactMetadata = + getArtifactMetadataFromAction(actionArtifacts, ActionConstants.ARTIFACT_METADATA_ATTR_UUID, + artifactUuId); + if (artifactMetadata == null) { + throw new ActionException(ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE, + ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST); + } + if (artifactMetadata.getArtifactProtection().equals(ActionArtifactProtection.readOnly.name())) { + throw new ActionException(ACTION_ARTIFACT_DELETE_READ_ONLY, + ACTION_ARTIFACT_DELETE_READ_ONLY_MSG); + } else { + + //Update action by removing artifact metadata + String jsonData = action.getData(); + List<ActionArtifact> artifacts = action.getArtifacts();//action.getArtifacts(); + ActionArtifact artifact = null; + Iterator<ActionArtifact> it = artifacts.iterator(); + while (it.hasNext()) { + artifact = it.next(); + String artifactId = artifact.getArtifactUuId(); + if (artifactId.equals(artifactUuId)) { + it.remove(); + } + } + + Map dataMap = JsonUtil.json2Object(jsonData, LinkedHashMap.class); + dataMap.put("artifacts", artifacts); + String data = JsonUtil.object2Json(dataMap); + ActionEntity actionEntity = action.toEntity(); + actionEntity.setData(data); + actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION, TARGET_ENTITY_DB); + actionDao.update(actionEntity); + actionLogPostProcessor(StatusCode.COMPLETE, null, "", false); + log.metrics(""); + // delete Artifact if it's upload and delete action on same checkout version + String artifactName = artifactMetadata.getArtifactName(); + String generatedArtifactUuId = generateActionArtifactUuId(action, artifactName); + if (generatedArtifactUuId.equals(artifactUuId)) { + ActionArtifactEntity artifactDeleteEntity = + new ActionArtifactEntity(artifact.getArtifactUuId(), + getEffectiveVersion(action.getVersion())); + actionLogPreProcessor(ActionSubOperation.DELETE_ACTION_ARTIFACT, TARGET_ENTITY_DB); + actionArtifactDao.delete(artifactDeleteEntity); + actionLogPostProcessor(StatusCode.COMPLETE, null, "", false); + log.metrics(""); + } + + } + log.debug( + "exit deleteArtifact with actionInvariantUUID= " + actionInvariantUuId + "artifactUUID= " + + artifactUuId + " and user = " + user); + } + + /** + * Update an existing artifact. + * + * @param artifact {@link ActionArtifact} object representing the artifact and its + * metadata. + * @param actionInvariantUuId Invariant UUID of the action to which the artifact has to be + * uploaded. + * @param user User ID of the user sending the request. + */ + public void updateArtifact(ActionArtifact artifact, String actionInvariantUuId, String user) { + try { + log.debug("Enter updateArtifact with actionInvariantUUID= " + actionInvariantUuId + + "artifactUUID= " + artifact.getArtifactUuId() + " and user = " + user); + actionLogPreProcessor(ActionSubOperation.GET_ACTION_VERSION, TARGET_ENTITY_API); + VersionInfo versionInfo = versioningManager + .getEntityVersionInfo(ActionConstants.ACTION_VERSIONABLE_TYPE, actionInvariantUuId, user, + VersionableEntityAction.Write); + actionLogPostProcessor(StatusCode.COMPLETE, null, "", false); + log.metrics(""); + Version activeVersion = versionInfo.getActiveVersion(); + actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_ACTIONINVID, TARGET_ENTITY_DB); + Action action = actionDao.get(new ActionEntity(actionInvariantUuId, activeVersion)).toDto(); + actionLogPostProcessor(StatusCode.COMPLETE, null, "", false); + log.metrics(""); + List<ActionArtifact> actionArtifacts = action.getArtifacts(); + ActionArtifact artifactMetadataByUuId = getArtifactMetadataFromAction(actionArtifacts, + ActionConstants.ARTIFACT_METADATA_ATTR_UUID, artifact.getArtifactUuId()); + //Check if artifact is already in action or not + if (artifactMetadataByUuId == null) { + throw new ActionException(ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST_CODE, + ActionErrorConstants.ACTION_ARTIFACT_ENTITY_NOT_EXIST); + } + //If user tries to change artifact name + if (artifact.getArtifactName() != null + && !artifactMetadataByUuId.getArtifactName() + .equalsIgnoreCase(artifact.getArtifactName())) { + throw new ActionException(ACTION_UPDATE_NOT_ALLOWED_CODE, + ACTION_ARTIFACT_UPDATE_NAME_INVALID); + } + + byte[] payload = artifact.getArtifact(); + String artifactLabel = artifact.getArtifactLabel(); + String artifactCategory = artifact.getArtifactCategory(); + String artifactDescription = artifact.getArtifactDescription(); + String artifactProtection = artifact.getArtifactProtection(); + String artifactName = artifact.getArtifactName(); + //If artifact read only + if (artifactMetadataByUuId.getArtifactProtection() + .equals(ActionArtifactProtection.readOnly.name())) { + if (artifactName != null || artifactLabel != null || artifactCategory != null + || artifactDescription != null || payload != null) { + throw new ActionException(ACTION_ARTIFACT_UPDATE_READ_ONLY, + ACTION_ARTIFACT_UPDATE_READ_ONLY_MSG); + } + //Changing value from readOnly to readWrite + if (artifactProtection != null + && artifactProtection.equals(ActionArtifactProtection.readWrite.name())) { + artifactMetadataByUuId.setArtifactProtection(ActionArtifactProtection.readWrite.name()); + artifactMetadataByUuId.setTimestamp(getCurrentTimeStampUtc()); + updateArtifactMetadataInActionData(action, artifactMetadataByUuId); + } + } else { + int effectiveVersion = getEffectiveVersion(activeVersion.toString()); + if (artifactLabel != null) { + artifactMetadataByUuId.setArtifactLabel(artifactLabel); + } + if (artifactCategory != null) { + artifactMetadataByUuId.setArtifactCategory(artifactCategory); + } + if (artifactDescription != null) { + artifactMetadataByUuId.setArtifactDescription(artifactDescription); + } + if (artifactProtection != null) { + artifactMetadataByUuId.setArtifactProtection(artifactProtection); + } + if (payload != null) { + //get artifact data from action_artifact table for updating the content + ActionArtifact artifactContent = new ActionArtifact(); + artifactContent.setArtifactUuId(artifact.getArtifactUuId()); + artifactContent.setArtifact(payload); + artifactContent.setEffectiveVersion(effectiveVersion); + actionArtifactDao.updateArtifact(artifactContent); + } + //Update the action data field and timestamp + artifactMetadataByUuId.setTimestamp(getCurrentTimeStampUtc()); + updateArtifactMetadataInActionData(action, artifactMetadataByUuId); + } + log.debug("exit updateArtifact with actionInvariantUUID= " + actionInvariantUuId + + "artifactUUID= " + artifact.getArtifactUuId() + " and user = " + user); + } catch (CoreException coreException) { + formAndThrowException(coreException); + } + } + + /** + * Generate artifact UUID at runtime using action name and effective version. + * + * @param action {@link Action} for which the artifact is being uploaded/updated/downloaded. + * @param artifactName Artifact name. + * @return Generated UUID string. + */ + private String generateActionArtifactUuId(Action action, String artifactName) { + int effectiveVersion = getEffectiveVersion(action.getVersion()); + //Upper case for maintaining case-insensitive behavior for the artifact names + String artifactUuIdString + = action.getName().toUpperCase() + effectiveVersion + artifactName.toUpperCase(); + String generateArtifactUuId + = UUID.nameUUIDFromBytes((artifactUuIdString).getBytes()).toString(); + String artifactUuId = generateArtifactUuId.replace("-", ""); + return artifactUuId.toUpperCase(); + } + + /** + * Generate the effective action version for artifact operations. + * + * @param actionVersion Version of the action as a string. + * @return Effective version to be used for artifact operations. + */ + private int getEffectiveVersion(String actionVersion) { + Version version = Version.valueOf(actionVersion); + return version.getMajor() * 10000 + version.getMinor(); + } + + /** + * Update the data field of the Action object with the modified/generated fields after an + * operation. + * + * @param action Action object whose data field has to be updated. + * @return Updated {@link Action} object. + */ + private Action updateData(Action action) { + log.debug("entering updateData to update data json for action with actionuuid= " + + action.getActionUuId()); + Map<String, String> dataMap = new LinkedHashMap<>(); + dataMap.put(ActionConstants.UNIQUE_ID, action.getActionUuId()); + dataMap.put(ActionConstants.VERSION, action.getVersion()); + dataMap.put(ActionConstants.INVARIANTUUID, action.getActionInvariantUuId()); + dataMap.put(ActionConstants.STATUS, action.getStatus().name()); + + String data = action.getData(); + Map<String, String> currentDataMap = JsonUtil.json2Object(data, LinkedHashMap.class); + dataMap.putAll(currentDataMap); + data = JsonUtil.object2Json(dataMap); + action.setData(data); + log.debug("exit updateData"); + return action; + } + + /** + * Method to add the artifact metadata in the data attribute of action table. + * + * @param action Action to which artifact is uploaded. + * @param artifact Uploaded artifact object. + */ + private void addArtifactMetadataInActionData(Action action, ActionArtifact artifact) { + + ActionArtifact artifactMetadata = new ActionArtifact(); + artifactMetadata.setArtifactUuId(artifact.getArtifactUuId()); + artifactMetadata.setArtifactName(artifact.getArtifactName()); + artifactMetadata.setArtifactProtection(artifact.getArtifactProtection()); + artifactMetadata.setArtifactLabel(artifact.getArtifactLabel()); + artifactMetadata.setArtifactDescription(artifact.getArtifactDescription()); + artifactMetadata.setArtifactCategory(artifact.getArtifactCategory()); + artifactMetadata.setTimestamp(artifact.getTimestamp()); + List<ActionArtifact> actionArtifacts = action.getArtifacts(); + if (actionArtifacts == null) { + actionArtifacts = new ArrayList<>(); + } + actionArtifacts.add(artifactMetadata); + action.setArtifacts(actionArtifacts); + String currentData = action.getData(); + Map<String, Object> currentDataMap = JsonUtil.json2Object(currentData, LinkedHashMap.class); + currentDataMap.put(ActionConstants.ARTIFACTS, actionArtifacts); + String updatedActionData = JsonUtil.object2Json(currentDataMap); + action.setData(updatedActionData); + action.setTimestamp(artifact.getTimestamp()); + actionDao.updateAction(action); + } + + /** + * Get a list of last major and last minor version (no candidate) of action from a list of + * actions. + * + * @param actions Exhaustive list of the action versions. + * @return List {@link Action} of last major and last minor version (no candidate) of action from + a list of actions. + */ + private List<Action> getMajorMinorVersionActions(List<Action> actions) { + log.debug(" entering getMajorMinorVersionActions for actions "); + List<Action> list = new LinkedList<>(); + actionLogPreProcessor(ActionSubOperation.GET_VERSIONINFO_FOR_ALL_ACTIONS, TARGET_ENTITY_API); + Map<String, VersionInfo> actionVersionMap = versioningManager + .listEntitiesVersionInfo(ActionConstants.ACTION_VERSIONABLE_TYPE, "", + VersionableEntityAction.Read); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + for (Action action : actions) { + if (action.getStatus() == ActionStatus.Deleted) { + continue; + } + VersionInfo actionVersionInfo = actionVersionMap.get(action.getActionInvariantUuId()); + if (actionVersionInfo.getActiveVersion() != null + && actionVersionInfo.getActiveVersion().equals(Version.valueOf(action.getVersion()))) { + list.add(action); + } else if (actionVersionInfo.getLatestFinalVersion() != null + && actionVersionInfo.getLatestFinalVersion().equals(Version.valueOf(action.getVersion())) + && + !actionVersionInfo.getLatestFinalVersion().equals(actionVersionInfo.getActiveVersion())) { + list.add(action); + } + } + log.debug(" exit getMajorMinorVersionActions for actions "); + return list; + } + + /** + * CoreException object wrapper from Version library to Action Library Exception. + * + * @param exception CoreException object from version library. + */ + private void formAndThrowException(CoreException exception) { + log.debug( + "entering formAndThrowException with input CoreException =" + exception.code().id() + " " + + exception.getMessage()); + String errorDescription = exception.getMessage(); + String errorCode = exception.code().id(); + ActionException actionException = new ActionException(); + switch (errorCode) { + case VersioningErrorCodes.VERSIONABLE_ENTITY_NOT_EXIST: + actionException.setErrorCode(ACTION_ENTITY_NOT_EXIST_CODE); + actionException.setDescription(ACTION_ENTITY_NOT_EXIST); + break; + case VersioningErrorCodes.CHECKOT_ON_LOCKED_ENTITY: + actionException.setErrorCode(ACTION_CHECKOUT_ON_LOCKED_ENTITY); + actionException.setDescription(errorDescription); + break; + case VersioningErrorCodes.CHECKIN_ON_UNLOCKED_ENTITY: + actionException.setErrorCode(ACTION_CHECKIN_ON_UNLOCKED_ENTITY); + actionException.setDescription(errorDescription); + break; + case VersioningErrorCodes.SUBMIT_FINALIZED_ENTITY_NOT_ALLOWED: + actionException.setErrorCode(ACTION_SUBMIT_FINALIZED_ENTITY_NOT_ALLOWED); + actionException.setDescription(errorDescription); + break; + case VersioningErrorCodes.SUBMIT_LOCKED_ENTITY_NOT_ALLOWED: + actionException.setErrorCode(ACTION_SUBMIT_LOCKED_ENTITY_NOT_ALLOWED); + actionException.setDescription(errorDescription); + break; + case VersioningErrorCodes.UNDO_CHECKOUT_ON_UNLOCKED_ENTITY: + actionException.setErrorCode(ACTION_UNDO_CHECKOUT_ON_UNLOCKED_ENTITY); + actionException.setDescription(errorDescription); + break; + case VersioningErrorCodes.EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER: + actionException.setErrorCode(ACTION_EDIT_ON_ENTITY_LOCKED_BY_OTHER_USER); + actionException.setDescription(errorDescription.replace("edit", "updat")); + break; + case VersioningErrorCodes.CHECKIN_ON_ENTITY_LOCKED_BY_OTHER_USER: + actionException.setErrorCode(ACTION_CHECKIN_ON_ENTITY_LOCKED_BY_OTHER_USER); + actionException.setDescription(errorDescription); + break; + case VersioningErrorCodes.UNDO_CHECKOUT_ON_ENTITY_LOCKED_BY_OTHER_USER: + actionException.setErrorCode(ACTION_UNDO_CHECKOUT_ON_ENTITY_LOCKED_BY_OTHER_USER); + actionException.setDescription(errorDescription); + break; + case VersioningErrorCodes.EDIT_ON_UNLOCKED_ENTITY: + actionException.setErrorCode(ACTION_UPDATE_ON_UNLOCKED_ENTITY); + actionException.setDescription(errorDescription.replace("edit", "update")); + break; + case VersioningErrorCodes.DELETE_ON_LOCKED_ENTITY: + actionException.setErrorCode(ACTION_DELETE_ON_LOCKED_ENTITY_CODE); + actionException.setDescription(errorDescription); + break; + default: + actionException.setErrorCode(ACTION_INTERNAL_SERVER_ERR_CODE); + actionException.setDescription(exception.getMessage()); + + } + log.debug( + "exit formAndThrowException with ActionException =" + actionException.getErrorCode() + " " + + actionException.getDescription()); + throw actionException; + } + + /** + * Validates an action object for business layer validations before an update operation. + * + * @param action Action object to be validated. + * @param activeVersion Active version of the actoin object. + */ + private void validateActions(Action action, Version activeVersion) { + try { + //Set version if not already available in input request + //If version set in input compare it with version from DB + if (StringUtils.isEmpty(action.getVersion())) { + action.setVersion(activeVersion.toString()); + } else { + if (!activeVersion.equals(Version.valueOf(action.getVersion()))) { + throw new ActionException(ACTION_UPDATE_INVALID_VERSION, + String.format(ACTION_REQUESTED_VERSION_INVALID, action.getVersion())); + } + } + String invariantUuId = action.getActionInvariantUuId(); + Version version = Version.valueOf(action.getVersion()); + Action existingAction = getActions(invariantUuId, version); + if (existingAction == null || existingAction.getActionInvariantUuId() == null) { + throw new ActionException(ACTION_ENTITY_NOT_EXIST_CODE, ACTION_ENTITY_NOT_EXIST); + } + List<String> invalidParameters = new LinkedList<>(); + //Prevent update of name, version and id fields + if (!existingAction.getName().equals(action.getName())) { + throw new ActionException(ACTION_UPDATE_NOT_ALLOWED_CODE_NAME, + ACTION_UPDATE_NOT_ALLOWED_FOR_NAME); + } + if (!StringUtils.isEmpty(action.getActionUuId()) + && !existingAction.getActionUuId().equals(action.getActionUuId())) { + invalidParameters.add(ActionConstants.UNIQUE_ID); + } + if (action.getStatus() != null && (existingAction.getStatus() != action.getStatus())) { + invalidParameters.add(ActionConstants.STATUS); + } + + if (!invalidParameters.isEmpty()) { + throw new ActionException(ACTION_UPDATE_NOT_ALLOWED_CODE, + String.format(ACTION_UPDATE_PARAM_INVALID, StringUtils.join(invalidParameters, ", "))); + } + action.setActionUuId(existingAction.getActionUuId()); + } catch (IllegalArgumentException iae) { + String message = iae.getMessage(); + switch (message) { + case VERSION_STRING_VIOLATION_MSG: + throw new ActionException(ACTION_UPDATE_NOT_ALLOWED_CODE, message); + default: + throw iae; + } + } + } + + /** + * Get an action version entity object. + * + * @param invariantUuId Invariant UUID of the action. + * @param version Version of the action. + * @return {@link ActionEntity} object of the action version. + */ + private ActionEntity getActionsEntityByVersion(String invariantUuId, Version version) { + log.debug( + "entering getActionsEntityByVersion with invariantUUID= " + invariantUuId + " and version" + + version); + ActionEntity entity = null; + if (version != null) { + actionLogPreProcessor(ActionSubOperation.GET_ACTIONENTITY_BY_VERSION, TARGET_ENTITY_DB); + entity = actionDao.get( + new ActionEntity(invariantUuId != null ? invariantUuId.toUpperCase() : null, version)); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + } + log.debug( + "exit getActionsEntityByVersion with invariantUUID= " + invariantUuId + " and version" + + version); + return entity; + } + + /** + * Get an action version object. + * + * @param invariantUuId Invariant UUID of the action. + * @param version Version of the action. + * @return {@link Action} object of the action version. + */ + private Action getActions(String invariantUuId, Version version) { + ActionEntity actionEntity = + getActionsEntityByVersion(invariantUuId != null ? invariantUuId.toUpperCase() : null, + version); + return actionEntity != null ? actionEntity.toDto() : new Action(); + } + + /** + * Create and set the Unique ID in for an action version row. + * + * @param invariantUuId Invariant UUID of the action. + * @param version Version of the action. + * @param status Status of the action. + * @param user AT&T id of the user sending the request. + * @return {@link ActionEntity} object of the action version. + */ + private ActionEntity updateUniqueIdForVersion(String invariantUuId, Version version, + String status, String user) { + log.debug( + "entering updateUniqueIdForVersion to update action with invariantUUID= " + invariantUuId + + " with version,status and user as ::" + version + " " + status + " " + user); + //generate UUID AND update for newly created entity row + ActionEntity actionEntity = getActionsEntityByVersion(invariantUuId, version); + if (actionEntity != null) { + log.debug("Found action to be updated"); + String data = actionEntity.getData(); + String uniqueId = CommonMethods.nextUuId(); + Map<String, String> dataMap = JsonUtil.json2Object(data, LinkedHashMap.class); + dataMap.put(ActionConstants.UNIQUE_ID, uniqueId); + dataMap.put(ActionConstants.VERSION, version.toString()); + dataMap.put(ActionConstants.STATUS, status); + data = JsonUtil.object2Json(dataMap); + + actionEntity.setData(data); + actionEntity.setActionUuId(uniqueId); + actionEntity.setStatus(status); + actionEntity.setUser(user); + actionEntity.setTimestamp(getCurrentTimeStampUtc()); + actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION, TARGET_ENTITY_DB); + actionDao.update(actionEntity); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + } + log.debug( + "exit updateUniqueIdForVersion to update action with invariantUUID= " + invariantUuId); + return actionEntity; + } + + /** + * Set the status for an action version row. + * + * @param invariantUuId Invariant UUID of the action. + * @param version Version of the action. + * @param status Status of the action. + * @param user AT&T id of the user sending the request. + * @return {@link ActionEntity} object of the action version. + */ + private ActionEntity updateStatusForVersion(String invariantUuId, Version version, String status, + String user) { + log.debug( + "entering updateStatusForVersion with invariantUUID= " + invariantUuId + " and version" + + version + " for updating status " + status + " by user " + user); + ActionEntity actionEntity = getActionsEntityByVersion(invariantUuId, version); + if (actionEntity != null) { + String data = actionEntity.getData(); + Map<String, String> dataMap = JsonUtil.json2Object(data, LinkedHashMap.class); + dataMap.put(ActionConstants.STATUS, status); + data = JsonUtil.object2Json(dataMap); + actionEntity.setData(data); + actionEntity.setStatus(status); + actionEntity.setUser(user); + actionEntity.setTimestamp(getCurrentTimeStampUtc()); + actionLogPreProcessor(ActionSubOperation.UPDATE_ACTION, TARGET_ENTITY_DB); + actionDao.update(actionEntity); + actionLogPostProcessor(StatusCode.COMPLETE); + log.metrics(""); + } + log.debug("exit updateStatusForVersion with invariantUUID= " + invariantUuId + " and version" + + version + " for updating status " + status + " by user " + user); + return actionEntity; + + } + + /** + * Gets an artifact from the action artifact metadata by artifact name. + * + * @param actionArtifactList Action's existing artifact list. + * @param artifactFilterType Search criteria for artifact in action artifact metadata. + * @param artifactFilterValue Value of Search parameter. + * @return Artifact metadata object if artifact is present in action and null otherwise. + */ + private ActionArtifact getArtifactMetadataFromAction(List<ActionArtifact> actionArtifactList, + String artifactFilterType, + String artifactFilterValue) { + ActionArtifact artifact = null; + if (actionArtifactList != null && !actionArtifactList.isEmpty()) { + for (ActionArtifact entry : actionArtifactList) { + switch (artifactFilterType) { + case ActionConstants.ARTIFACT_METADATA_ATTR_UUID: + String artifactUuId = entry.getArtifactUuId(); + if (artifactUuId != null && artifactUuId.equals(artifactFilterValue)) { + artifact = entry; + break; + } + break; + case ActionConstants.ARTIFACT_METADATA_ATTR_NAME: + String existingArtifactName = entry.getArtifactName().toLowerCase(); + if (existingArtifactName.equals(artifactFilterValue.toLowerCase())) { + artifact = entry; + break; + } + break; + default: + } + } + } + return artifact; + } + + /** + * Method to update the artifact metadata in the data attribute of action table. + * + * @param action Action to which artifact is uploaded. + * @param updatedArtifact updated artifact object. + */ + private void updateArtifactMetadataInActionData(Action action, ActionArtifact updatedArtifact) { + for (ActionArtifact entry : action.getArtifacts()) { + if (entry.getArtifactUuId().equals(updatedArtifact.getArtifactUuId())) { + entry.setArtifactLabel(updatedArtifact.getArtifactLabel()); + entry.setArtifactCategory(updatedArtifact.getArtifactCategory()); + entry.setArtifactDescription(updatedArtifact.getArtifactDescription()); + entry.setArtifactProtection(updatedArtifact.getArtifactProtection()); + entry.setTimestamp(updatedArtifact.getTimestamp()); + break; + } + } + String data = action.getData(); + Map<String, Object> map = JsonUtil.json2Object(data, LinkedHashMap.class); + map.put(ActionConstants.ARTIFACTS, action.getArtifacts()); + String updatedActionData = JsonUtil.object2Json(map); + action.setData(updatedActionData); + action.setTimestamp(updatedArtifact.getTimestamp()); + actionDao.updateAction(action); + } +} |