catalog-be/src/main/java/org/openecomp/sdc/be/user/UserBusinessLogic.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.user;
  22
  23 import fj.data.Either;
  24 import org.apache.tinkerpop.gremlin.structure.Edge;
  25 import org.openecomp.sdc.be.config.BeEcompErrorManager;
  26 import org.openecomp.sdc.be.dao.api.ActionStatus;
  27 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  28 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  29 import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
  30 import org.openecomp.sdc.be.impl.ComponentsUtils;
  31 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  32 import org.openecomp.sdc.be.model.User;
  33 import org.openecomp.sdc.be.model.operations.api.IUserAdminOperation;
  34 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  35 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  36 import org.openecomp.sdc.common.api.UserRoleEnum;
  37 import org.openecomp.sdc.common.config.EcompErrorName;
  38 import org.openecomp.sdc.common.kpi.api.ASDCKpiApi;
  39 import org.openecomp.sdc.exception.ResponseFormat;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42 import org.springframework.beans.factory.annotation.Autowired;
  43 import org.springframework.stereotype.Component;
  44
  45 import javax.annotation.Resource;
  46 import javax.servlet.ServletContext;
  47 import java.util.ArrayList;
  48 import java.util.HashMap;
  49 import java.util.List;
  50 import java.util.Map;
  51
  52 @Component("userBusinessLogic")
  53 public class UserBusinessLogic implements IUserBusinessLogic {
  54
  55     private static final Logger log = LoggerFactory.getLogger(UserBusinessLogic.class);
  56     private static UserAdminValidator userAdminValidator = UserAdminValidator.getInstance();
  57
  58     @Resource
  59     private IUserAdminOperation userAdminOperation;
  60     @Resource
  61     private ComponentsUtils componentsUtils;
  62     @Autowired
  63     private TitanGenericDao titanDao;
  64
  65     @Override
  66     public Either<User, ActionStatus> getUser(String userId, boolean inTransaction) {
  67         return userAdminOperation.getUserData(userId, inTransaction);
  68     }
  69
  70     @Override
  71     public Either<User, ResponseFormat> createUser(User modifier, User newUser) {
  72
  73         ResponseFormat responseFormat;
  74         String modifierUserId = modifier.getUserId();
  75
  76         if (modifierUserId == null) {
  77             modifier.setUserId("UNKNOWN");
  78             log.debug("createUser method -  user header is missing");
  79             responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
  80             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.ADD_USER);
  81             return Either.right(responseFormat);
  82         }
  83
  84         Either<User, ActionStatus> eitherCreator = getUser(modifierUserId, false);
  85         if (eitherCreator.isRight() || eitherCreator.left().value() == null) {
  86             log.debug("createUser method - user is not listed. userId = {}", modifier.getUserId());
  87             responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
  88             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.ADD_USER);
  89             return Either.right(responseFormat);
  90         }
  91
  92         modifier = eitherCreator.left().value();
  93         if (!modifier.getRole().equals(UserRoleEnum.ADMIN.getName())) {
  94             log.debug("createUser method - user is not admin = {}", modifier.getUserId());
  95             responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
  96             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.ADD_USER);
  97             return Either.right(responseFormat);
  98         }
  99
 100         // verify user not exist
 101         User userFromDb = new User();
 102         Either<User, ActionStatus> eitherUserInDB = getUser(newUser.getUserId(), false);
 103         if (eitherUserInDB.isRight()) {
 104             ActionStatus status = eitherUserInDB.right().value();
 105             if (!ActionStatus.USER_NOT_FOUND.equals(status) && !ActionStatus.USER_INACTIVE.equals(status)) {
 106                 responseFormat = componentsUtils.getResponseFormat(eitherUserInDB.right().value(), newUser.getUserId());
 107                 handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.ADD_USER);
 108                 return Either.right(responseFormat);
 109             }
 110         } else {// User exist in DB
 111             userFromDb = eitherUserInDB.left().value();
 112             if (userFromDb.getStatus() == UserStatusEnum.ACTIVE) {
 113                 responseFormat = componentsUtils.getResponseFormatByUserId(ActionStatus.USER_ALREADY_EXIST, newUser.getUserId());
 114                 log.debug("createUser method - user with id {} already exist with id: {}", modifier.getUserId(), userFromDb.getUserId());
 115                 handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.ADD_USER);
 116                 return Either.right(responseFormat);
 117             }
 118         }
 119
 120         newUser.setStatus(UserStatusEnum.ACTIVE);
 121
 122         // validate Email
 123         if (newUser.getEmail() != null && !userAdminValidator.validateEmail(newUser.getEmail())) {
 124             log.debug("createUser method - user has invalid email = {}", modifier.getUserId());
 125             responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_EMAIL_ADDRESS, newUser.getEmail());
 126             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.ADD_USER);
 127             return Either.right(responseFormat);
 128         }
 129
 130         // validate Role
 131         if (newUser.getRole() == null || newUser.getRole().length() == 0) {
 132             newUser.setRole(Role.DESIGNER.name());
 133         } else {
 134             if (!userAdminValidator.validateRole(newUser.getRole())) {
 135                 log.debug("createUser method - user has invalid role = {}", modifier.getUserId());
 136                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_ROLE, newUser.getRole());
 137                 handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.ADD_USER);
 138                 return Either.right(responseFormat);
 139             }
 140         }
 141
 142         // handle last login if user is import
 143         if (newUser.getLastLoginTime() == null) {
 144             newUser.setLastLoginTime(0L);
 145         }
 146
 147         Either<User, StorageOperationStatus> addOrUpdateUserReq;
 148
 149         if (ActionStatus.USER_INACTIVE.equals(eitherUserInDB.right().value())) { // user
 150                                                                                     // exist
 151                                                                                     // with
 152                                                                                     // inactive
 153                                                                                     // state
 154                                                                                     // -
 155                                                                                     // update
 156                                                                                     // user
 157                                                                                     // data
 158             newUser.setLastLoginTime(0L);
 159             addOrUpdateUserReq = userAdminOperation.updateUserData(newUser);
 160
 161         } else { // user not exist - create new user
 162
 163             if (newUser.getUserId() != null && !userAdminValidator.validateUserId(newUser.getUserId())) {
 164                 log.debug("createUser method - user has invalid userId = {}", modifier.getUserId());
 165                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_USER_ID, newUser.getUserId());
 166                 handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.ADD_USER);
 167                 return Either.right(responseFormat);
 168             }
 169             addOrUpdateUserReq = userAdminOperation.saveUserData(newUser);
 170         }
 171
 172         if (addOrUpdateUserReq.isRight() || addOrUpdateUserReq.left().value() == null) {
 173             log.debug("createUser method - failed to create user");
 174             Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(addOrUpdateUserReq.right().value())));
 175         }
 176         log.debug("createUser method - user created");
 177         User createdUser = addOrUpdateUserReq.left().value();
 178         responseFormat = componentsUtils.getResponseFormat(ActionStatus.CREATED);
 179         handleAuditing(modifier, null, createdUser, responseFormat, AuditingActionEnum.ADD_USER);
 180         return Either.left(createdUser);
 181     }
 182
 183     @Override
 184     public Either<User, ResponseFormat> updateUserRole(User modifier, String userIdToUpdate, String userRole) {
 185
 186         ResponseFormat responseFormat;
 187         String modifierUserId = modifier.getUserId();
 188
 189         if (modifierUserId == null) {
 190             modifier.setUserId("UNKNOWN");
 191             log.debug("updateUserRole method -  user header is missing");
 192             responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
 193             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.UPDATE_USER);
 194             return Either.right(responseFormat);
 195         }
 196
 197         Either<User, ActionStatus> eitherCreator = getUser(modifierUserId, false);
 198         if (eitherCreator.isRight() || eitherCreator.left().value() == null) {
 199             log.debug("updateUserRole method - user is not listed. userId = {}", modifier.getUserId());
 200             responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
 201             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.UPDATE_USER);
 202             return Either.right(responseFormat);
 203         }
 204
 205         modifier = eitherCreator.left().value();
 206         if (!modifier.getRole().equals(UserRoleEnum.ADMIN.getName())) {
 207             log.debug("updateUserRole method - user is not admin. userId = {}", modifier.getUserId());
 208             responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
 209             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.UPDATE_USER);
 210             return Either.right(responseFormat);
 211         }
 212
 213         if (modifier.getUserId().equals(userIdToUpdate)) {
 214             log.debug("updateUserRole method - admin role can only be updated by other admin. userId = {}", modifier.getUserId());
 215             responseFormat = componentsUtils.getResponseFormat(ActionStatus.UPDATE_USER_ADMIN_CONFLICT);
 216             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.UPDATE_USER);
 217             return Either.right(responseFormat);
 218         }
 219
 220         Either<User, ActionStatus> userToUpdateReq = getUser(userIdToUpdate, false);
 221         if (userToUpdateReq.isRight() || userToUpdateReq.left().value() == null) {
 222             log.debug("updateUserRole method - user not found. userId = {}", modifier.getUserId());
 223             responseFormat = componentsUtils.getResponseFormat(ActionStatus.USER_NOT_FOUND, userIdToUpdate);
 224             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.UPDATE_USER);
 225             return Either.right(responseFormat);
 226         }
 227
 228         if (!userAdminValidator.validateRole(userRole)) {
 229             log.debug("updateUserRole method - user has invalid role = {}", modifier.getUserId());
 230             responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_ROLE, userRole);
 231             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.UPDATE_USER);
 232             return Either.right(responseFormat);
 233         }
 234
 235         User newUser = new User();
 236         newUser.setRole(userRole);
 237         newUser.setUserId(userIdToUpdate);
 238         User userToUpdate = userToUpdateReq.left().value();
 239         // if(!userRole.equals(UserRoleEnum.ADMIN.getName())){ //this is in
 240         // comment until admin will be able to do do check-in/check-out from the
 241         // UI
 242
 243         Either<List<Edge>, StorageOperationStatus> userPendingTasksReq = getPendingUserPendingTasksWithCommit(userToUpdate);
 244         if (userPendingTasksReq.isRight()) {
 245             log.debug("updateUserRole method - failed to get user pending tasks list userId {}", userIdToUpdate);
 246             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(userPendingTasksReq.right().value())));
 247         }
 248
 249         List<Edge> userPendingTasks = userPendingTasksReq.left().value();
 250         if (!userPendingTasks.isEmpty()) {
 251             log.debug("updateUserRole method - User canot be updated, user have pending projects userId {}", userIdToUpdate);
 252
 253             String userTasksStatusForErrorMessage = getUserPendingTaskStatusByRole(UserRoleEnum.valueOf(userToUpdate.getRole()));
 254             String userInfo = userToUpdate.getFirstName() + " " + userToUpdate.getLastName() + '(' + userToUpdate.getUserId() + ')';
 255             responseFormat = componentsUtils.getResponseFormat(ActionStatus.CANNOT_UPDATE_USER_WITH_ACTIVE_ELEMENTS, userInfo, userTasksStatusForErrorMessage);
 256             handleAuditing(modifier, userToUpdate, userToUpdate, responseFormat, AuditingActionEnum.UPDATE_USER);
 257             return Either.right(responseFormat);
 258         }
 259         // }
 260         Either<User, StorageOperationStatus> updateUserReq = userAdminOperation.updateUserData(newUser);
 261
 262         if (updateUserReq.isRight() || updateUserReq.left().value() == null) {
 263             log.debug("updateUser method - failed to update user data. userId = {}", modifier.getUserId());
 264             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(updateUserReq.right().value())));
 265         }
 266
 267         responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
 268         User updatedUser = updateUserReq.left().value();
 269         handleAuditing(modifier, userToUpdate, updatedUser, responseFormat, AuditingActionEnum.UPDATE_USER);
 270         return Either.left(updatedUser);
 271     }
 272
 273     @Override
 274     public Either<List<User>, ResponseFormat> getAllAdminUsers(ServletContext context) {
 275         Either<List<User>, ActionStatus> response = userAdminOperation.getAllUsersWithRole(Role.ADMIN.name(), null);
 276
 277         if (response.isRight()) {
 278             ResponseFormat responseFormat = componentsUtils.getResponseFormat(response.right().value());
 279             return Either.right(responseFormat);
 280         }
 281         return Either.left(response.left().value());
 282     }
 283
 284     @Override
 285     public Either<List<User>, ResponseFormat> getUsersList(String modifierAttId, List<String> roles, String rolesStr) {
 286         ResponseFormat responseFormat;
 287         User user = new User();
 288         if (modifierAttId == null) {
 289             user.setUserId("UNKNOWN");
 290             responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
 291             handleGetUsersListAuditing(user, responseFormat, rolesStr);
 292             return Either.right(responseFormat);
 293         }
 294         Either<User, ActionStatus> userResult = getUser(modifierAttId, false);
 295         if (userResult.isRight()) {
 296             user.setUserId(modifierAttId);
 297             if (userResult.right().value().equals(ActionStatus.USER_NOT_FOUND)) {
 298                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
 299             } else {
 300                 responseFormat = componentsUtils.getResponseFormat(userResult.right().value());
 301             }
 302             BeEcompErrorManager.getInstance().logBeUserMissingError("Get users per roles", modifierAttId);
 303
 304             handleGetUsersListAuditing(user, responseFormat, rolesStr);
 305             return Either.right(responseFormat);
 306         }
 307         user = userResult.left().value();
 308         Either<List<User>, ResponseFormat> getResponse = null;
 309         List<User> resultList = new ArrayList<>();
 310         if (roles != null && !roles.isEmpty()) {
 311             for (String role : roles) {
 312                 if (!userAdminValidator.validateRole(role)) {
 313                     responseFormat = componentsUtils.getResponseFormat(ActionStatus.INVALID_ROLE, role);
 314                     handleGetUsersListAuditing(user, responseFormat, rolesStr);
 315                     return Either.right(responseFormat);
 316                 }
 317                 getResponse = getUsersPerRole(role, user, rolesStr);
 318                 resultList.addAll(getResponse.left().value());
 319             }
 320         } else {
 321             rolesStr = "All";
 322             getResponse = getUsersPerRole(null, user, rolesStr);
 323             resultList.addAll(getResponse.left().value());
 324         }
 325         responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
 326         handleGetUsersListAuditing(user, responseFormat, rolesStr);
 327         return Either.left(resultList);
 328     }
 329
 330     private Either<List<User>, ResponseFormat> getUsersPerRole(String role, User user, String rolesStr) {
 331         ResponseFormat responseFormat;
 332         Either<List<User>, ActionStatus> response = userAdminOperation.getAllUsersWithRole(role, UserStatusEnum.ACTIVE.name());
 333         if (response.isRight()) {
 334             responseFormat = componentsUtils.getResponseFormat(response.right().value());
 335             handleGetUsersListAuditing(user, responseFormat, rolesStr);
 336             return Either.right(responseFormat);
 337         }
 338         return Either.left(response.left().value());
 339     }
 340
 341     private void handleGetUsersListAuditing(User user, ResponseFormat responseFormat, String details) {
 342         componentsUtils.auditGetUsersList(AuditingActionEnum.GET_USERS_LIST, user, details, responseFormat);
 343     }
 344
 345     private void handleAuditing(User modifier, User userBefor, User userAfter, ResponseFormat responseFormat, AuditingActionEnum actionName) {
 346         componentsUtils.auditAdminUserAction(actionName, modifier, userBefor, userAfter, responseFormat);
 347     }
 348
 349     private void handleUserAccessAuditing(User user, ResponseFormat responseFormat, AuditingActionEnum actionName) {
 350         componentsUtils.auditUserAccess(actionName, user, responseFormat);
 351     }
 352
 353     @Override
 354     public Either<User, ResponseFormat> deActivateUser(User modifier, String userUniuqeIdToDeactive) {
 355
 356         ResponseFormat responseFormat;
 357         String userId = modifier.getUserId();
 358
 359         if (userId == null) {
 360             modifier.setUserId("UNKNOWN");
 361             log.debug("deActivateUser method -  user header is missing");
 362             responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
 363             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.DELETE_USER);
 364             return Either.right(responseFormat);
 365         }
 366
 367         Either<User, ActionStatus> eitherCreator = getUser(userId, false);
 368         if (eitherCreator.isRight() || eitherCreator.left().value() == null) {
 369             log.debug("deActivateUser method - user is not listed. userId = {}", modifier.getUserId());
 370             responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
 371             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.DELETE_USER);
 372             return Either.right(responseFormat);
 373         }
 374
 375         modifier = eitherCreator.left().value();
 376
 377         if (!modifier.getRole().equals(UserRoleEnum.ADMIN.getName())) {
 378             log.debug("deActivateUser method - user is not admin. userId = {}", modifier.getUserId());
 379             responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_OPERATION);
 380             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.DELETE_USER);
 381             return Either.right(responseFormat);
 382         }
 383
 384         if (modifier.getUserId().equals(userUniuqeIdToDeactive)) {
 385             log.debug("deActivateUser deActivateUser - admin can only be deactivate by other admin. userId = {}", modifier.getUserId());
 386             responseFormat = componentsUtils.getResponseFormat(ActionStatus.DELETE_USER_ADMIN_CONFLICT);
 387             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.DELETE_USER);
 388             return Either.right(responseFormat);
 389         }
 390
 391         Either<User, ActionStatus> getUserToDeleteResponse = getUser(userUniuqeIdToDeactive, false);
 392         if (getUserToDeleteResponse.isRight() || getUserToDeleteResponse.left().value() == null) {
 393             log.debug("deActivateUser method - failed to get user by id {}", userUniuqeIdToDeactive);
 394             responseFormat = componentsUtils.getResponseFormat(ActionStatus.USER_NOT_FOUND, userUniuqeIdToDeactive);
 395             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.DELETE_USER);
 396             return Either.right(componentsUtils.getResponseFormat(getUserToDeleteResponse.right().value(), userUniuqeIdToDeactive));
 397         }
 398
 399         User userToDeactivate = getUserToDeleteResponse.left().value();
 400         if (userToDeactivate.getStatus().equals(UserStatusEnum.INACTIVE)) {
 401             log.debug("deActivateUser method - User already inactive", userUniuqeIdToDeactive);
 402             responseFormat = componentsUtils.getResponseFormat(ActionStatus.USER_NOT_FOUND, userUniuqeIdToDeactive);
 403             handleAuditing(modifier, null, null, responseFormat, AuditingActionEnum.DELETE_USER);
 404             return Either.right(responseFormat);
 405         }
 406
 407         Either<List<Edge>, StorageOperationStatus> userPendingTasksReq = getPendingUserPendingTasksWithCommit(userToDeactivate);
 408         if (userPendingTasksReq.isRight()) {
 409             log.debug("deActivateUser method - failed to get user pending tasks list", userUniuqeIdToDeactive);
 410             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(userPendingTasksReq.right().value())));
 411         }
 412
 413         List<Edge> userPendingTasks = userPendingTasksReq.left().value();
 414         if (userPendingTasks.size() > 0) {
 415             log.debug("deActivateUser method - User canot be deleted, user have pending projects", userUniuqeIdToDeactive);
 416
 417             String userTasksStatusForErrorMessage = getUserPendingTaskStatusByRole(UserRoleEnum.valueOf(userToDeactivate.getRole()));
 418             String userInfo = userToDeactivate.getFirstName() + " " + userToDeactivate.getLastName() + '(' + userToDeactivate.getUserId() + ')';
 419             responseFormat = componentsUtils.getResponseFormat(ActionStatus.CANNOT_DELETE_USER_WITH_ACTIVE_ELEMENTS, userInfo, userTasksStatusForErrorMessage);
 420             handleAuditing(modifier, userToDeactivate, userToDeactivate, responseFormat, AuditingActionEnum.DELETE_USER);
 421             return Either.right(responseFormat);
 422         }
 423
 424         Either<User, StorageOperationStatus> deactivateUserReq = userAdminOperation.deActivateUser(userToDeactivate);
 425         if (deactivateUserReq.isRight()) {
 426             log.debug("deActivateUser method - failed to deactivate user", userUniuqeIdToDeactive);
 427             return Either.right(componentsUtils.getResponseFormat(componentsUtils.convertFromStorageResponse(deactivateUserReq.right().value())));
 428         }
 429         User deactivateUser = deactivateUserReq.left().value();
 430         responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
 431         handleAuditing(modifier, userToDeactivate, null, responseFormat, AuditingActionEnum.DELETE_USER);
 432         return Either.left(deactivateUser);
 433     }
 434
 435     @Override
 436     public Either<User, ResponseFormat> authorize(User authUser) {
 437
 438         ResponseFormat responseFormat;
 439
 440         String userId = authUser.getUserId();
 441
 442         if (userId == null) {
 443             authUser.setUserId("UNKNOWN");
 444             log.debug("deActivateUser method -  user header is missing");
 445             responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
 446             handleUserAccessAuditing(authUser, responseFormat, AuditingActionEnum.USER_ACCESS);
 447             return Either.right(responseFormat);
 448         }
 449
 450         Either<User, ActionStatus> eitherCreator = getUser(userId, false);
 451         if (eitherCreator.isRight()) {
 452             if (eitherCreator.right().value() == ActionStatus.USER_NOT_FOUND || eitherCreator.right().value() == ActionStatus.USER_INACTIVE) {
 453                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_ACCESS);
 454                 handleUserAccessAuditing(authUser, responseFormat, AuditingActionEnum.USER_ACCESS);
 455                 return Either.right(responseFormat);
 456             } else {
 457                 return Either.right(componentsUtils.getResponseFormatByUser(eitherCreator.right().value(), authUser));
 458             }
 459         } else {
 460             if (eitherCreator.left().value() == null) {
 461                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 462                 return Either.right(responseFormat);
 463             }
 464         }
 465
 466         User user = eitherCreator.left().value();
 467
 468         String firstName = authUser.getFirstName();
 469         if (firstName != null && firstName.isEmpty() == false && !firstName.equals(user.getFirstName())) {
 470             user.setFirstName(firstName);
 471         }
 472
 473         String lastName = authUser.getLastName();
 474         if (lastName != null && lastName.isEmpty() == false && !lastName.equals(user.getLastName())) {
 475             user.setLastName(lastName);
 476         }
 477
 478         String email = authUser.getEmail();
 479         if (email != null && false == email.isEmpty() && !email.equals(user.getEmail())) {
 480             user.setEmail(email);
 481         }
 482
 483         // last login time stamp handle
 484         user.setLastLoginTime();
 485
 486         Either<User, StorageOperationStatus> updateUserReq = userAdminOperation.updateUserData(user);
 487
 488         if (updateUserReq.isRight()) {
 489             responseFormat = componentsUtils.getResponseFormatByUser(eitherCreator.right().value(), user);
 490             handleUserAccessAuditing(user, responseFormat, AuditingActionEnum.USER_ACCESS);
 491             return Either.right(componentsUtils.getResponseFormatByUser(eitherCreator.right().value(), user));
 492         }
 493
 494         User updatedUser = updateUserReq.left().value();
 495
 496         Long lastLoginTime = user.getLastLoginTime();
 497         if (lastLoginTime != null) {
 498             updatedUser.setLastLoginTime(lastLoginTime);
 499         } else {
 500             updatedUser.setLastLoginTime(new Long(0));
 501         }
 502
 503         responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
 504         handleUserAccessAuditing(updatedUser, responseFormat, AuditingActionEnum.USER_ACCESS);
 505         ASDCKpiApi.countUsersAuthorizations();
 506         return Either.left(updatedUser);
 507     }
 508
 509     /*
 510      * The method updates user credentials only, the role is neglected The role updated through updateRole method
 511      */
 512     public Either<User, ResponseFormat> updateUserCredentials(User updatedUserCred) {
 513
 514         ResponseFormat responseFormat;
 515
 516         String userId = updatedUserCred.getUserId();
 517
 518         if (userId == null) {
 519             updatedUserCred.setUserId("UNKNOWN");
 520             log.debug("updateUserCredentials method - user header is missing");
 521             responseFormat = componentsUtils.getResponseFormat(ActionStatus.MISSING_INFORMATION);
 522             handleUserAccessAuditing(updatedUserCred, responseFormat, AuditingActionEnum.USER_ACCESS);
 523             return Either.right(responseFormat);
 524         }
 525
 526         Either<User, ActionStatus> eitherCreator = getUser(userId, false);
 527         if (eitherCreator.isRight()) {
 528             ActionStatus status = eitherCreator.right().value();
 529             if (status == ActionStatus.USER_NOT_FOUND || status == ActionStatus.USER_INACTIVE) {
 530                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.RESTRICTED_ACCESS);
 531                 handleUserAccessAuditing(updatedUserCred, responseFormat, AuditingActionEnum.USER_ACCESS);
 532                 return Either.right(responseFormat);
 533             } else {
 534                 return Either.right(componentsUtils.getResponseFormatByUser(status, updatedUserCred));
 535             }
 536         } else {
 537             if (eitherCreator.left().value() == null) {
 538                 responseFormat = componentsUtils.getResponseFormat(ActionStatus.GENERAL_ERROR);
 539                 return Either.right(responseFormat);
 540             }
 541         }
 542
 543         User user = eitherCreator.left().value();
 544
 545         String firstName = updatedUserCred.getFirstName();
 546         if (firstName != null && firstName.isEmpty() == false && !firstName.equals(user.getFirstName())) {
 547             user.setFirstName(firstName);
 548         }
 549
 550         String lastName = updatedUserCred.getLastName();
 551         if (lastName != null && lastName.isEmpty() == false && !lastName.equals(user.getLastName())) {
 552             user.setLastName(lastName);
 553         }
 554
 555         String email = updatedUserCred.getEmail();
 556         if (email != null && false == email.isEmpty() && !email.equals(user.getEmail())) {
 557             user.setEmail(email);
 558         }
 559
 560         if (updatedUserCred.getLastLoginTime() != null && user.getLastLoginTime() != null) {
 561             if (updatedUserCred.getLastLoginTime() > user.getLastLoginTime()) {
 562                 user.setLastLoginTime(updatedUserCred.getLastLoginTime());
 563             }
 564         } else if (updatedUserCred.getLastLoginTime() != null && user.getLastLoginTime() == null) {
 565             user.setLastLoginTime(updatedUserCred.getLastLoginTime());
 566         }
 567
 568         Either<User, StorageOperationStatus> updateUserReq = userAdminOperation.updateUserData(user);
 569
 570         if (updateUserReq.isRight()) {
 571             responseFormat = componentsUtils.getResponseFormatByUser(eitherCreator.right().value(), user);
 572             handleUserAccessAuditing(user, responseFormat, AuditingActionEnum.USER_ACCESS);
 573             return Either.right(componentsUtils.getResponseFormatByUser(eitherCreator.right().value(), user));
 574         }
 575
 576         User updatedUser = updateUserReq.left().value();
 577
 578         responseFormat = componentsUtils.getResponseFormat(ActionStatus.OK);
 579         handleUserAccessAuditing(updatedUser, responseFormat, AuditingActionEnum.USER_ACCESS);
 580         return Either.left(updatedUser);
 581     }
 582
 583     private Either<List<Edge>, StorageOperationStatus> getPendingUserPendingTasksWithCommit(User user) {
 584
 585         Either<List<Edge>, StorageOperationStatus> result = null;
 586
 587         try {
 588             UserRoleEnum userRole = UserRoleEnum.valueOf(user.getRole());
 589             Map<String, Object> properties = new HashMap<String, Object>();
 590             switch (userRole) {
 591             case DESIGNER:
 592             case PRODUCT_STRATEGIST:
 593             case PRODUCT_MANAGER:
 594                 properties.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
 595                 return userAdminOperation.getUserPendingTasksList(user, properties);
 596             case TESTER:
 597                 properties.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.name());
 598                 return userAdminOperation.getUserPendingTasksList(user, properties);
 599             case ADMIN:
 600                 properties.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.name());
 601                 properties.put(GraphPropertiesDictionary.STATE.getProperty(), LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
 602                 return userAdminOperation.getUserPendingTasksList(user, properties);
 603             default:
 604                 return Either.left(new ArrayList<>());
 605             }
 606         } finally {
 607             // commit will be perform outside!!!
 608             if (result == null || result.isRight()) {
 609                 log.debug("getUserPendingTasksList failed to perform fetching");
 610                 titanDao.rollback();
 611             } else {
 612                 titanDao.commit();
 613             }
 614         }
 615     }
 616
 617     private String getUserPendingTaskStatusByRole(UserRoleEnum role) {
 618
 619         switch (role) {
 620         case DESIGNER:
 621         case PRODUCT_STRATEGIST:
 622         case PRODUCT_MANAGER:
 623             return "checked-out";
 624
 625         case TESTER:
 626             return "in-certification";
 627         case ADMIN:
 628             return "in-certification/checked-out";
 629         default:
 630             return "";
 631         }
 632     }
 633 }