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