Summary Table

Categories Total Count
PII 0
URL 0
DNS 0
EKL 0
IP 0
PORT 0
VsID 0
CF 0
AI 0
VPD 0
PL 0
Other 0

File Content

package gov.va.med.ars.service.impl;

import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.collections.CollectionUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import gov.va.med.ars.constants.ErrorMessages;
import gov.va.med.ars.dao.ars.IArsRole;
import gov.va.med.ars.dao.ars.IArsUserRepository;
import gov.va.med.ars.dao.ars.IArsUserRoleUsages;
import gov.va.med.ars.dao.ars.IUserSearchViewRepository;
import gov.va.med.ars.exceptions.GenericException;
import gov.va.med.ars.model.request.UserSearchRequest;
import gov.va.med.ars.model.response.GenericResponse;
import gov.va.med.ars.model.response.UserDetailsResponse;
import gov.va.med.ars.service.IUserAdministrationService;
import gov.va.med.ars.util.RoleModificationLists;
import gov.va.med.domain.ars.ArsRole;
import gov.va.med.domain.ars.ArsUser;
import gov.va.med.domain.ars.ArsUserRoleUsages;
import gov.va.med.domain.ars.ArsUserRoleUsagesId;
import gov.va.med.domain.ars.UserSearchView;

@Transactional
@Service
public class UserAdministrationServiceImpl implements IUserAdministrationService {

private static final Logger logger = LogManager.getLogger(UserAdministrationServiceImpl.class);

public static final String EWV_SYSTEM_IDENTIFIER = "EWV";
public static final String ARS_SYSTEM_IDENTIFIER = "ARS";

@Autowired
IArsUserRepository arsUserRepo;
@Autowired
IArsUserRoleUsages arsUserRoleUsagesRepo;
@Autowired
IArsRole arsRoleRepo;
@Autowired
IUserSearchViewRepository userSearchViewRepo;


@Override
public UserDetailsResponse getUserDetails(String userName, String system) throws GenericException {
UserDetailsResponse response = null;
if(CollectionUtils.isNotEmpty(arsRoleRepo.findBySystem(system))) {
ArsUser userDetail = arsUserRepo.findByUserNameAndSystem(userName, system);
if (userDetail != null) {
response = new UserDetailsResponse();
response.setUserId(userDetail.getArsUserId());
response.setUserName(userDetail.getUserName());
response.setDomain(userDetail.getDomain());
response.setFirstName(userDetail.getFirstName());
response.setLastName(userDetail.getLastName());
response.setEmail(userDetail.getEmailAddress());
response.setPhone(userDetail.getPhoneNumber());
response.setCreatedBy(userDetail.getCreatedBy());
response.setModifiedBy(userDetail.getModifiedBy());
response.setUserRoles(assignUserRolesToAList(userDetail));
return response;
} else {
logger.info("Please enter a valid System name");
throw new GenericException(ErrorMessages.BAD_REQUEST, "The username searched doesn't exist in the system", HttpStatus.BAD_REQUEST);
}
} else {
throw new GenericException(ErrorMessages.BAD_REQUEST, "send an valid system name", HttpStatus.BAD_REQUEST);
}
}

private List<String> assignUserRolesToAList(ArsUser userDetail) {
List<String> userRoles = null;
if(CollectionUtils.isNotEmpty(userDetail.getArsUserRoleUsageses())) {
userRoles = new ArrayList<>();
for(ArsUserRoleUsages arsUserRoleUsages: userDetail.getArsUserRoleUsageses()) {
userRoles.add(arsUserRoleUsages.getArsRole().getRoleName());
}
return userRoles;
}
return userRoles;
}

@Override
public GenericResponse getAllUserDetails(UserSearchRequest userSearchRequest) throws GenericException {
GenericResponse searchResponse = null;
if(CollectionUtils.isNotEmpty(arsRoleRepo.findBySystem(userSearchRequest.getSystem()))) {
PageRequest pageable = generatePagination(userSearchRequest);
Page<UserSearchView> UserData = null;
try {
if(!userSearchRequest.isInActiveUsers()) {
UserData = userSearchViewRepo.findUsersWithRoleIdWithOutInActiveUsers("%"+userSearchRequest.getSystem()+"_INACTIVE%", "%"+userSearchRequest.getSystem()+"%", pageable);
} else {
UserData = userSearchViewRepo.findUsersWithRoleIdWithInActiveUsers("%"+userSearchRequest.getSystem()+"%", pageable);
}

logger.info("The result count is " + UserData.getTotalElements());
Long countElements = (long) UserData.getSize();
if (countElements > 0) {
int pageNumber = userSearchRequest.getPageNumber(); // recalculate pageNumber
pageNumber = resetPageNumbersOnCountElements(userSearchRequest, countElements, pageNumber);
searchResponse = setGenericJsonResponse(userSearchRequest, pageable, countElements, pageNumber, UserData);
} else {
searchResponse = new GenericResponse(//
userSearchRequest.getPageNumber(), //
userSearchRequest.getPageSize(), //
userSearchRequest.getSortColumn(), //
countElements);
}
return searchResponse;
} catch (Exception e) {
throw new GenericException(ErrorMessages.DATA_ACCESS_ERROR, e.getMessage(),
HttpStatus.INTERNAL_SERVER_ERROR);
}
} else {
throw new GenericException(ErrorMessages.BAD_REQUEST, "send an valid system name", HttpStatus.BAD_REQUEST);
}
}

private GenericResponse setGenericJsonResponse(//
UserSearchRequest userSearchRequest, //
PageRequest pageable, //
Long countElements, //
int pageNumber, Page<UserSearchView> arsUserData) {
GenericResponse searchResponse;
searchResponse = new GenericResponse(//
userSearchRequest.getPageNumber(), // .intValue() is implicit!
userSearchRequest.getPageSize(), //
userSearchRequest.getSortColumn(), //
arsUserData.getTotalElements());

List<UserDetailsResponse> responseList = assignData(arsUserData, userSearchRequest.getSystem());
searchResponse.setResponse(responseList);
return searchResponse;
}

private PageRequest generatePagination(UserSearchRequest userSearchRequest) {
PageRequest pageable;
String sortColumn = validateSort(userSearchRequest.getSortColumn(), userSearchRequest.getSystem());
logger.info("getAll275SearchResult(): The sort column is " + sortColumn);
boolean descending = userSearchRequest.getDescending();
int pidx = userSearchRequest.getPageNumber().intValue() - 1; // change from 1-based to 0-based index
Sort.Direction direction = descending ? Sort.Direction.DESC : Sort.Direction.ASC;
Sort.Order order = new Sort.Order(direction, sortColumn).ignoreCase();
pageable = new PageRequest(pidx, userSearchRequest.getPageSize(), new Sort(order));
return pageable;
}

private String validateSort(String sortColumn, String system) {
// sortColumn.toUpperCase(); // WHAT?? This does nothing!! Returned string is discarded.
// Except that it throws an exception if sortColumn is null.
logger.info("The requested Sort Column is " + sortColumn);
if (sortColumn != null && !(sortColumn.isEmpty())) {
switch (sortColumn) {
case "userName":
return "userName";
case "domain":
return "domain";
case "status":
if(system.equalsIgnoreCase("ARS")) {
return "arsInactive";
} else if(system.equalsIgnoreCase("EWV")){
return "ewvInactive";
} else {
return "userName";
}
case "export":
if(system.equalsIgnoreCase("ARS")) {
return "arsExportAttachmentUser";
} else {
return "userName";
}
case "edit":
if(system.equalsIgnoreCase("ARS")) {
return "arsEditAtttachmentUser";
} else {
return "userName";
}
case "admin":
if(system.equalsIgnoreCase("ARS")) {
return "arsAdmin";
} else if(system.equalsIgnoreCase("EWV")){
return "ewvAdmin";
} else {
return "userName";
}
case "firstName":
return "firstName";
case "lastName":
return "lastName";
case "email":
return "emailAddress";
case "phone":
return "phoneNumber";
default:
return "userName";
}
} else {
return "userName";
}
}

private int resetPageNumbersOnCountElements(UserSearchRequest userSearchRequest, Long countElements,
int pageNumber) {
if (countElements <= (userSearchRequest.getPageSize() * userSearchRequest.getPageNumber())) {
Integer resultCountIntVal = countElements.intValue();
float pageNumberFloat = (float) resultCountIntVal / (float) userSearchRequest.getPageSize();
pageNumber = (int) Math.ceil(pageNumberFloat);

logger.debug("getAllUserDetails() : pageNumber is :" + pageNumber + " and pageSize is :"
+ userSearchRequest.getPageSize());
}
return pageNumber;
}

private List<UserDetailsResponse> assignData(Page<UserSearchView> arsUserObjectWithPagination, String system) {
List<UserDetailsResponse> responseList = new ArrayList<>();
for (UserSearchView arsUserSearchResponseObjectFromdb : arsUserObjectWithPagination) {
UserDetailsResponse arsUserSearchResponse = new UserDetailsResponse();
arsUserSearchResponse.setUserId(arsUserSearchResponseObjectFromdb.getArsUserId());
arsUserSearchResponse.setUserName(arsUserSearchResponseObjectFromdb.getUserName());
arsUserSearchResponse.setFirstName(arsUserSearchResponseObjectFromdb.getFirstName());
arsUserSearchResponse.setLastName(arsUserSearchResponseObjectFromdb.getLastName());
arsUserSearchResponse.setEmail(arsUserSearchResponseObjectFromdb.getEmailAddress());
arsUserSearchResponse.setPhone(arsUserSearchResponseObjectFromdb.getPhoneNumber());
arsUserSearchResponse.setDomain(arsUserSearchResponseObjectFromdb.getDomain());
arsUserSearchResponse.setCreatedBy(arsUserSearchResponseObjectFromdb.getCreatedBy());
arsUserSearchResponse.setModifiedBy(arsUserSearchResponseObjectFromdb.getModifiedBy());
arsUserSearchResponse.setUserRoles(cleanUpRolesAccordingToSystem(arsUserSearchResponseObjectFromdb.getRoleNamesList(), system));
responseList.add(arsUserSearchResponse);
}
return responseList;
}

private List<String> cleanUpRolesAccordingToSystem(String roleNamesList, String system) {
List<String> rolesToBeReturned = new ArrayList<>();
List<String> rolesList = Arrays.asList(roleNamesList.split("\\s*,\\s*"));
for(String role : rolesList) {
if(role.startsWith(system)) {
rolesToBeReturned.add(role);
}
}
return rolesToBeReturned;
}

@Override
public SimpleEntry<String, Boolean> editUserByUserName(UserSearchRequest userSearchRequest) throws GenericException {

if(CollectionUtils.isNotEmpty(arsRoleRepo.findBySystem(userSearchRequest.getSystem()))) {
ArsUser arsUser = arsUserRepo.findByUserNameAndSystem(userSearchRequest.getUserName(), userSearchRequest.getSystem());
if(arsUser != null) {
arsUser.setLastName(userSearchRequest.getLastName());
arsUser.setFirstName(userSearchRequest.getFirstName());
arsUser.setPhoneNumber(userSearchRequest.getPhone());
arsUser.setEmailAddress(userSearchRequest.getEmail());
arsUser.setDomain(userSearchRequest.getDomain());
RoleModificationLists roleModificationLists = checkExisitngRolesAgainstRequestedRoles(arsUser, userSearchRequest);
List<ArsRole> arsRolesToBeAdded = arsRoleRepo.findByRoleNameIn(roleModificationLists.getRolesToBeAdded());
List<ArsRole> arsRolesToBeDeleted = arsRoleRepo.findByRoleNameIn(roleModificationLists.getRolesToBeDeleted());
try {
if(CollectionUtils.isNotEmpty(arsRolesToBeDeleted)) {
arsUserRoleUsagesRepo.deleteInValidUserRolesFromUserRolesUsages(arsUser.getArsUserId(), arsRolesToBeDeleted, userSearchRequest.getSystem());
}
} catch (Exception e) {
throw new GenericException(ErrorMessages.BAD_REQUEST, "the role has already been deleted", HttpStatus.BAD_REQUEST);
}

Set<ArsUserRoleUsages> arsRoleUsagesSet = new HashSet<>();
for(ArsRole arsRole : arsRolesToBeAdded) {
ArsUserRoleUsages arsRoleUsages = new ArsUserRoleUsages();
arsRoleUsages.setArsRole(arsRole);
arsRoleUsages.setArsUser(arsUser);
arsRoleUsages.setCreatedBy(userSearchRequest.getCreatedBy());
arsRoleUsages.setDateCreated(new Date());
arsRoleUsages.setId(new ArsUserRoleUsagesId(arsRole.getArsRoleId(), arsUser.getArsUserId()));
arsRoleUsagesSet.add(arsRoleUsages);
}
arsRoleUsagesSet = new HashSet<>(arsUserRoleUsagesRepo.save(arsRoleUsagesSet));
arsUser.setArsUserRoleUsageses(arsRoleUsagesSet);
arsUserRepo.save(arsUser);
} else {
throw new GenericException(ErrorMessages.BAD_REQUEST, "the username searched doesn't exist in the system", HttpStatus.BAD_REQUEST);
}

} else {
throw new GenericException(ErrorMessages.BAD_REQUEST, "given system doesn't exist", HttpStatus.BAD_REQUEST);
}
return new SimpleEntry<>("success", true);
}

private RoleModificationLists checkExisitngRolesAgainstRequestedRoles(ArsUser arsUser, UserSearchRequest userSearchRequest) {
List<String> existingUserRoleNames = arsUser.getArsUserRoleUsageses().stream().map(ArsUserRoleUsages :: getArsRole).map(ArsRole :: getRoleName).collect(Collectors.toList());
List<String> existingRoles = new ArrayList<>(existingUserRoleNames);
List<String> newRoles = new ArrayList<>(userSearchRequest.getUserRoles());
existingRoles.removeAll(userSearchRequest.getUserRoles());
newRoles.removeAll(existingUserRoleNames);
RoleModificationLists roleModificationLists = new RoleModificationLists(newRoles, existingRoles);
return roleModificationLists;
}

@Override
public boolean deleteUserByUserName(Long userId) throws GenericException {
logger.info("Delete Service layer hit" + userId);
ArsUser userDetail = arsUserRepo.findByArsUserId(userId);
if (userDetail != null) {
logger.info("User found, deleting the user");
arsUserRepo.delete(userDetail);
logger.info("User deleted");
} else {
logger.info("Exception User not present");
throw new GenericException("User not available to delete, Please delete a valid user");
}
return true;
}

public List<Long> getAllRoleIds(UserSearchRequest userSearchRequest) {
List<ArsRole> arsRoleList = arsRoleRepo.findAllByRoleNameLike(userSearchRequest.getSystem()+"%");
List<Long> roleIds = arsRoleList.stream().map(ArsRole :: getArsRoleId).collect(Collectors.toList());
return roleIds;
}

public List<ArsRole> getAllRolesBySystem(String system) {
List<ArsRole> arsRoleList = arsRoleRepo.findAllByRoleNameLike(system+"%");
return arsRoleList;

}
}