diff options
Diffstat (limited to 'catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperation.java')
| -rw-r--r-- | catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperation.java | 501 |
1 files changed, 501 insertions, 0 deletions
diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperation.java new file mode 100644 index 0000000000..85bb56f39f --- /dev/null +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperation.java @@ -0,0 +1,501 @@ +/*- + * ============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.be.model.operations.impl; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.tinkerpop.gremlin.structure.Direction; +import org.apache.tinkerpop.gremlin.structure.Edge; +import org.apache.tinkerpop.gremlin.structure.Vertex; +import org.apache.tinkerpop.gremlin.structure.VertexProperty; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; +import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary; +import org.openecomp.sdc.be.dao.titan.TitanGenericDao; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; +import org.openecomp.sdc.be.dao.utils.UserStatusEnum; +import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; +import org.openecomp.sdc.be.model.FunctionalMenuInfo; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.model.operations.api.IUserAdminOperation; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.resources.data.UserData; +import org.openecomp.sdc.be.resources.data.UserFunctionalMenuData; +import org.openecomp.sdc.common.datastructure.Wrapper; +import org.openecomp.sdc.common.util.MethodActivationStatusEnum; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.stereotype.Component; + +import com.thinkaurelius.titan.core.TitanVertex; + +import fj.data.Either; + +@Component("user-operation") +public class UserAdminOperation implements IUserAdminOperation { + + @javax.annotation.Resource + private TitanGenericDao titanGenericDao; + + public UserAdminOperation() { + super(); + } + + private static Logger log = LoggerFactory.getLogger(UserAdminOperation.class.getName()); + + @Override + public Either<User, ActionStatus> getInactiveUserData(String id) { + return getUserData(id, false, false); + } + + @Override + public Either<User, ActionStatus> getUserData(String id, boolean inTransaction) { + return getUserData(id, true, inTransaction); + } + + private Either<User, ActionStatus> getUserData(String id, boolean isActive, boolean inTransaction) { + log.debug("getUserData - start"); + Wrapper<Either<User, ActionStatus>> resultWrapper = new Wrapper<>(); + Wrapper<UserData> userWrapper = new Wrapper<>(); + try { + validateUserExists(resultWrapper, userWrapper, id); + + if (resultWrapper.isEmpty()) { + validateUserData(resultWrapper, userWrapper.getInnerElement(), id); + + } + if (resultWrapper.isEmpty()) { + if (isActive) { + validateActiveUser(resultWrapper, userWrapper.getInnerElement()); + } else { + validateInActiveUser(resultWrapper, userWrapper.getInnerElement()); + } + } + + if (resultWrapper.isEmpty()) { + Either<User, ActionStatus> result = Either.left(convertToUser(userWrapper.getInnerElement())); + resultWrapper.setInnerElement(result); + } + + return resultWrapper.getInnerElement(); + } finally { + if (false == inTransaction) { + titanGenericDao.commit(); + } + log.debug("getUserData - end"); + } + } + + private void validateInActiveUser(Wrapper<Either<User, ActionStatus>> resultWrapper, UserData userData) { + User user = convertToUser(userData); + if (user.getStatus() == UserStatusEnum.ACTIVE) { + Either<User, ActionStatus> result = Either.right(ActionStatus.USER_NOT_FOUND); + resultWrapper.setInnerElement(result); + } + } + + private void validateActiveUser(Wrapper<Either<User, ActionStatus>> resultWrapper, UserData userData) { + User user = convertToUser(userData); + if (user.getStatus() == UserStatusEnum.INACTIVE) { + Either<User, ActionStatus> result = Either.right(ActionStatus.USER_INACTIVE); + resultWrapper.setInnerElement(result); + } + } + + private void validateUserData(Wrapper<Either<User, ActionStatus>> resultWrapper, UserData userData, String id) { + if (userData == null) { + log.debug("Problem get User with userId {}. Reason - either.left().value() = null", id); + Either<User, ActionStatus> result = Either.right(ActionStatus.GENERAL_ERROR); + resultWrapper.setInnerElement(result); + } + } + + private void validateUserExists(Wrapper<Either<User, ActionStatus>> resultWrapper, Wrapper<UserData> userWrapper, + String id) { + Either<User, ActionStatus> result; + if (id == null) { + log.info("User userId is empty"); + result = Either.right(ActionStatus.MISSING_INFORMATION); + resultWrapper.setInnerElement(result); + return; + } + id = id.toLowerCase(); + Either<UserData, TitanOperationStatus> either = titanGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), id, UserData.class); + + if (either.isRight()) { + if (either.right().value() == TitanOperationStatus.NOT_FOUND) { + log.debug("User with userId {} not found", id); + result = Either.right(ActionStatus.USER_NOT_FOUND); + resultWrapper.setInnerElement(result); + } else { + log.debug("Problem get User with userId {}. Reason - {}", id, either.right().value().name()); + result = Either.right(ActionStatus.GENERAL_ERROR); + resultWrapper.setInnerElement(result); + } + } else { + userWrapper.setInnerElement(either.left().value()); + } + } + + @Override + public Either<User, StorageOperationStatus> saveUserData(User user) { + + Either<UserData, TitanOperationStatus> result = null; + try { + UserData userData = convertToUserData(user); + result = titanGenericDao.createNode(userData, UserData.class); + if (result.isRight()) { + log.debug("Problem while saving User {}. Reason - {}", userData.toString(), result.right().value().name()); + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + log.debug("User {} saved successfully", userData.toString()); + return Either.left(convertToUser(result.left().value())); + + } finally { + + if (result == null || result.isRight()) { + log.error("saveUserData - Failed"); + titanGenericDao.rollback(); + } else { + log.debug("saveUserData - end"); + titanGenericDao.commit(); + } + } + } + + @Override + public Either<User, StorageOperationStatus> updateUserData(User user) { + Either<UserData, TitanOperationStatus> result = null; + try { + log.debug("updateUserData - start"); + UserData userData = convertToUserData(user); + result = titanGenericDao.updateNode(userData, UserData.class); + if (result.isRight()) { + log.debug("Problem while updating User {}. Reason - {}", userData.toString(), result.right().value().name()); + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + log.debug("User {} updated successfully", userData.toString()); + return Either.left(convertToUser(result.left().value())); + + } finally { + + if (result == null || result.isRight()) { + log.error("updateUserData - Failed"); + titanGenericDao.rollback(); + } else { + log.debug("updateUserData - end"); + titanGenericDao.commit(); + } + + } + } + + @Override + public Either<User, StorageOperationStatus> deActivateUser(User user) { + Either<User, StorageOperationStatus> result; + user.setStatus(UserStatusEnum.INACTIVE); + Either<User, StorageOperationStatus> status = updateUserData(user); + if (status.isRight()) { + result = Either.right(status.right().value()); + } else { + result = Either.left(user); + } + return result; + } + + @Override + public Either<User, ActionStatus> deleteUserData(String id) { + Either<User, ActionStatus> result; + Either<UserData, TitanOperationStatus> eitherGet = titanGenericDao + .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), id, UserData.class); + if (eitherGet.isRight()) { + log.debug("Problem while retriving user with userId {}", id); + if (eitherGet.right().value() == TitanOperationStatus.NOT_FOUND) { + result = Either.right(ActionStatus.USER_NOT_FOUND); + } else { + result = Either.right(ActionStatus.GENERAL_ERROR); + } + + } else { + result = deleteUserLogic(eitherGet.left().value()); + } + return result; + } + + private Either<User, ActionStatus> deleteUserLogic(UserData userData) { + Wrapper<Either<User, ActionStatus>> resultWrapper = new Wrapper<>(); + try { + validateUserHasNoConnections(resultWrapper, userData); + + if (resultWrapper.isEmpty()) { + deleteUser(resultWrapper, userData); + } + + } finally { + titanGenericDao.commit(); + } + + return resultWrapper.getInnerElement(); + } + + private void deleteUser(Wrapper<Either<User, ActionStatus>> resultWrapper, UserData userData) { + Either<UserData, TitanOperationStatus> eitherDelete = titanGenericDao.deleteNode(userData, UserData.class); + if (eitherDelete.isRight()) { + log.debug("Problem while deleting User {}. Reason - {}", userData.toString(), eitherDelete.right().value().name()); + Either<User, ActionStatus> result = Either.right(ActionStatus.GENERAL_ERROR); + resultWrapper.setInnerElement(result); + } else { + log.debug("User {} deleted successfully", userData.toString()); + Either<User, ActionStatus> result = Either.left(convertToUser(eitherDelete.left().value())); + resultWrapper.setInnerElement(result); + } + } + + private void validateUserHasNoConnections(Wrapper<Either<User, ActionStatus>> resultWrapper, UserData userData) { + if (resultWrapper.isEmpty()) { + + Either<List<Edge>, TitanOperationStatus> edgesForNode = titanGenericDao.getEdgesForNode(userData, + Direction.BOTH); + if (edgesForNode.isRight()) { + log.debug("Problem while deleting User {}. Reason - {}", userData.toString(), edgesForNode.right().value().name()); + Either<User, ActionStatus> result = Either.right(ActionStatus.GENERAL_ERROR); + resultWrapper.setInnerElement(result); + } else { + List<Edge> vertexEdges = edgesForNode.left().value(); + if (vertexEdges.size() > 0) { + Either<User, ActionStatus> result = Either.right(ActionStatus.USER_HAS_ACTIVE_ELEMENTS); + resultWrapper.setInnerElement(result); + } + } + } + } + + public Either<List<Edge>, StorageOperationStatus> getUserPandingTasksList(User user, + Map<String, Object> properties) { + + UserData userData = convertToUserData(user); + + Either<TitanVertex, TitanOperationStatus> vertexUser = titanGenericDao + .getVertexByProperty(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), user.getUserId()); + if (vertexUser.isRight()) { + log.debug("Problem while deleting User {}. Reason - {}", userData.toString(), vertexUser.right().value().name()); + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + + List<Edge> pandingTasks = new ArrayList<>(); + Either<List<Edge>, TitanOperationStatus> edges = titanGenericDao + .getOutgoingEdgesByCriteria(vertexUser.left().value(), GraphEdgeLabels.STATE, properties); + + if (edges.isRight() || edges.left().value() == null) { + if (edges.right().value() == TitanOperationStatus.NOT_FOUND) { + return Either.left(pandingTasks); + } else { + log.debug("Problem while deleting User {}", userData.toString(), edges.right().value().name()); + return Either.right(StorageOperationStatus.GENERAL_ERROR); + } + } + + for (Edge edge : edges.left().value()) { + Vertex componentVertex = edge.inVertex(); + VertexProperty<Object> property = componentVertex + .property(GraphPropertiesDictionary.IS_DELETED.getProperty()); + if (!property.isPresent()) { + pandingTasks.add(edge); + } else { + Boolean isDeletedValue = (java.lang.Boolean) property.value(); + if (isDeletedValue == null || isDeletedValue == false) { + pandingTasks.add(edge); + } + } + } + + return Either.left(pandingTasks); + } + + @Override + public Either<List<User>, ActionStatus> getAllUsersWithRole(String role, String status) { + try { + List<User> result = new ArrayList<>(); + Map<String, Object> propertiesToMatch = new HashMap<>(); + if (role != null && !role.trim().isEmpty()) { + propertiesToMatch.put(GraphPropertiesDictionary.ROLE.getProperty(), role); + } + if (status != null && !status.isEmpty()) { + propertiesToMatch.put(GraphPropertiesDictionary.USER_STATUS.getProperty(), status); + } + + Either<List<UserData>, TitanOperationStatus> userNodes = titanGenericDao.getByCriteria(NodeTypeEnum.User, + propertiesToMatch, UserData.class); + + titanGenericDao.commit(); + if (userNodes.isRight()) { + // in case of NOT_FOUND from Titan return empty list + if (userNodes.right().value().equals(TitanOperationStatus.NOT_FOUND)) { + return Either.left(result); + } else { + log.error("Problem while getting all users with role {}. Reason - {}", role, userNodes.right().value().name()); + return Either.right(ActionStatus.GENERAL_ERROR); + } + } else { + List<UserData> userDataList = userNodes.left().value(); + if (userDataList != null) { + for (UserData userData : userDataList) { + User user = convertToUser(userData); + result.add(user); + } + return Either.left(result); + } + log.debug("No users were found with role {}", role); + return Either.left(result); + } + } finally { + titanGenericDao.commit(); + } + } + + protected User convertToUser(UserData userData) { + User user = new User(); + user.setUserId(userData.getUserId()); + user.setEmail(userData.getEmail()); + user.setFirstName(userData.getFirstName()); + user.setLastName(userData.getLastName()); + user.setRole(userData.getRole()); + user.setLastLoginTime(userData.getLastLoginTime()); + // Support backward compatibility - user status may not exist in old + // users + Either<UserStatusEnum, MethodActivationStatusEnum> either = UserStatusEnum.findByName(userData.getStatus()); + user.setStatus(either.isLeft() ? either.left().value() : UserStatusEnum.ACTIVE); + return user; + } + + protected UserData convertToUserData(User user) { + UserData userData = new UserData(); + userData.setUserId(user.getUserId().toLowerCase()); + userData.setEmail(user.getEmail()); + userData.setFirstName(user.getFirstName()); + userData.setLastName(user.getLastName()); + userData.setRole(user.getRole()); + userData.setStatus(user.getStatus().name()); + userData.setLastLoginTime(user.getLastLoginTime()); + return userData; + } + + public Either<ImmutablePair<User, FunctionalMenuInfo>, ActionStatus> getUserDataWithFunctionalMenu(String userId) { + + Either<User, ActionStatus> userData = getUserData(userId, true, true); + + if (userData.isRight()) { + return Either.right(userData.right().value()); + } + User user = userData.left().value(); + Either<UserFunctionalMenuData, TitanOperationStatus> functionalMenu = getFunctionalMenu(userId); + + FunctionalMenuInfo functionalMenuInfo = new FunctionalMenuInfo(); + if (functionalMenu.isRight()) { + TitanOperationStatus status = functionalMenu.right().value(); + if (status != TitanOperationStatus.NOT_FOUND) { + return Either.right(ActionStatus.GENERAL_ERROR); + } + } else { + UserFunctionalMenuData userFunctionalMenuData = functionalMenu.left().value(); + functionalMenuInfo.setFunctionalMenu(userFunctionalMenuData.getFunctionalMenu()); + } + + ImmutablePair<User, FunctionalMenuInfo> result = new ImmutablePair<User, FunctionalMenuInfo>(user, + functionalMenuInfo); + + return Either.left(result); + } + + public Either<UserFunctionalMenuData, TitanOperationStatus> getFunctionalMenu(String userId) { + + Either<UserFunctionalMenuData, TitanOperationStatus> result; + if (userId == null) { + log.info("User userId is empty"); + result = Either.right(TitanOperationStatus.NOT_FOUND); + return result; + } + userId = userId.toLowerCase(); + String uid = UniqueIdBuilder.buildUserFunctionalMenuUid(userId); + + Either<UserFunctionalMenuData, TitanOperationStatus> either = titanGenericDao.getNode( + UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.UserFunctionalMenu), uid, UserFunctionalMenuData.class); + + return either; + } + + public Either<FunctionalMenuInfo, TitanOperationStatus> createOrUpdateFunctionalMenu(String userId, String newFunctionalMenu) { + + Either<UserFunctionalMenuData, TitanOperationStatus> functionalMenu = getFunctionalMenu(userId); + + if (functionalMenu.isRight()) { + TitanOperationStatus status = functionalMenu.right().value(); + if (status == TitanOperationStatus.NOT_FOUND) { + String uid = UniqueIdBuilder.buildUserFunctionalMenuUid(userId); + UserFunctionalMenuData functionalMenuData = new UserFunctionalMenuData(newFunctionalMenu, uid); + + Either<UserFunctionalMenuData, TitanOperationStatus> createNode = titanGenericDao + .createNode(functionalMenuData, UserFunctionalMenuData.class); + + if (createNode.isRight()) { + return Either.right(createNode.right().value()); + } else { + return Either.left(convert(createNode.left().value())); + } + + } else { + return Either.right(status); + } + + } else { + UserFunctionalMenuData userFunctionalMenuData = functionalMenu.left().value(); + userFunctionalMenuData.setFunctionalMenu(newFunctionalMenu); + Either<UserFunctionalMenuData, TitanOperationStatus> updateNode = titanGenericDao + .updateNode(userFunctionalMenuData, UserFunctionalMenuData.class); + + if (updateNode.isRight()) { + return Either.right(updateNode.right().value()); + } else { + return Either.left(convert(updateNode.left().value())); + } + } + + } + + private FunctionalMenuInfo convert(UserFunctionalMenuData functionalMenuData) { + + if (functionalMenuData == null) { + return null; + } + + FunctionalMenuInfo functionalMenuInfo = new FunctionalMenuInfo(); + functionalMenuInfo.setFunctionalMenu(functionalMenuData.getFunctionalMenu()); + + return functionalMenuInfo; + + } + +} |