public static User createUser(UserDepartment department) { User user = new User(); user.setUserId(1); user.setActive(true); user.setEmail("thies@te-con.nl"); user.setUsername("testmetoo"); user.setFirstName("Dummy"); user.setLastName("TestUser"); user.setPassword("abc"); user.addUserDepartment(department); Set<UserRole> userRoles = new HashSet<>(); userRoles.add(UserRole.ADMIN); user.setUserRoles(userRoles); return user; }
@Transactional public User persistEditedUser(User user) throws ObjectNotUniqueException { // check username uniqueness User dbUser = userDAO.findByUsername(user.getUsername()); if (dbUser != null && !dbUser.getUserId().equals(user.getUserId())) { throw new ObjectNotUniqueException("Username already in use"); } else if (dbUser == null) { dbUser = findUserOnId(user); } dbUser.setActive(user.isActive()); dbUser.setEmail(user.getEmail()); dbUser.setFirstName(user.getFirstName()); dbUser.setLastName(user.getLastName()); dbUser.getUserDepartments().clear(); dbUser.getUserDepartments().addAll(user.getUserDepartments()); dbUser.setUsername(user.getUsername()); boolean reAddPm = dbUser.getUserRoles().contains(UserRole.PROJECTMANAGER); dbUser.setUserRoles(user.getUserRoles()); if (reAddPm && !user.getUserRoles().contains(UserRole.PROJECTMANAGER)) { dbUser.addUserRole(UserRole.PROJECTMANAGER); } userDAO.persist(dbUser); return dbUser; }
@Override public String toString() { return new ToStringBuilder(this).append("userId", getUserId()) .append("username", getUsername()) .append("lastName", getLastName()) .append("firstName", getFirstName()) .toString(); }
/** * @see java.lang.Comparable#compareTo(Object) */ public int compareTo(User object) { return new CompareToBuilder() .append(this.getLastName(), object.getLastName()) .append(this.getFirstName(), object.getFirstName()) .append(this.getUserId(), object.getUserId()) .toComparison(); }
@Test public void shouldUpdatePassword() throws ObjectNotUniqueException { User user = new User(1); user.setPassword("aa"); user.setUsername("user"); when(userDAO.findByUsername("user")).thenReturn(user); when(userDAO.persist(any(User.class))).thenReturn(user); userService.changePassword("user", "pwd"); assertFalse(user.getPassword().equals("pwd")); }
@Override @Transactional public void persistNewUser(User user, String password) throws ObjectNotUniqueException { // check username uniqueness User dbUser = userDAO.findByUsername(user.getUsername()); if (dbUser != null && !dbUser.getUserId().equals(user.getUserId())) { throw new ObjectNotUniqueException("Username already in use"); } // encrypt password user.setSalt((int) (Math.random() * 10000)); user.setPassword(encryptPassword(password, user.getSalt())); userDAO.persist(user); // assign new users to default projects projectAssignmentManagementService.assignUserToDefaultProjects(user); }
@Test public void shouldParseUserAndStoreNewKeyInCacheMap() throws XMLStreamException, InstantiationException, IllegalAccessException, ImportException { UserDepartment department = UserDepartmentObjectMother.createUserDepartment(); EntityParser parser = createParser("<USERLIST>\n <USERS>\n <USER_ID>1</USER_ID>\n <USERNAME>admin</USERNAME>\n <PASSWORD>1d798ca9dba7df61bf399a02695f9f50034bad66</PASSWORD>\n <FIRST_NAME>eHour</FIRST_NAME>\n <LAST_NAME>Admin</LAST_NAME>\n <EMAIL>t@t.net</EMAIL>\n <ACTIVE>Y</ACTIVE>\n </USERS>\n <USERS>\n <USER_ID>3</USER_ID>\n <USERNAME>thies</USERNAME>\n <PASSWORD>e2e90187007d55ae40678e11e0c9581cb7bb9928</PASSWORD>\n <FIRST_NAME>Thies</FIRST_NAME>\n <LAST_NAME>Edeling</LAST_NAME>\n <EMAIL>thies@te-con.nl</EMAIL>\n <ACTIVE>Y</ACTIVE>\n <SALT>6367</SALT>\n </USERS>\n </USERLIST>\n", department, 1); keyCache.putKey(UserDepartment.class, 1, 1); List<User> result = parser.parse(User.class, new JoinTables(), status); assertEquals(2, result.size()); User user = result.get(0); assertEquals("admin", user.getUsername()); assertEquals("1d798ca9dba7df61bf399a02695f9f50034bad66", user.getPassword()); assertEquals("eHour", user.getFirstName()); assertEquals("Admin", user.getLastName()); assertEquals("t@t.net", user.getEmail()); assertTrue(user.isActive()); PrimaryKeyCache keyCache = parser.getKeyCache(); assertFalse(keyCache.isEmpty()); Map<Serializable, Serializable> map = keyCache.keyMap.get(User.class); assertEquals(2, map.entrySet().size()); }
user = new User("thies", "pwd"); assignments.add(assignmentB); user.setProjectAssignments(assignments); assertEquals("thies", user.getUsername()); assertEquals(1, user.getProjectAssignments().size()); assertEquals(1, user.getInactiveProjectAssignments().size());
@Override public User findUser(Integer userId) { findUserCount++; return new User(userId); }
@Test public void shouldChangeUsername() throws ObjectNotUniqueException { User user = UserObjectMother.createUser(); User persistedUser = new User(); when(userDAO.findByUsername(user.getUsername())).thenReturn(null); when(userDAO.findById(user.getUserId())).thenReturn(persistedUser); when(userDAO.persist(persistedUser)).thenReturn(persistedUser); userService.persistEditedUser(user); verify(userDAO).persist(persistedUser); } }
@Transactional(readOnly = true) public User getUserAndCheckDeletability(Integer userId) throws ObjectNotFoundException { User user = getUser(userId); if ((!user.getProjectAssignments().isEmpty()) && (!user.getInactiveProjectAssignments().isEmpty())) { user.setDeletable(true); } else { // bummer, we need to check if the user booked any hours on the assignments List<Integer> assignmentIds = new ArrayList<>(); assignmentIds.addAll(DomainUtil.getIdsFromDomainObjects(user.getProjectAssignments())); assignmentIds.addAll(DomainUtil.getIdsFromDomainObjects(user.getInactiveProjectAssignments())); List<AssignmentAggregateReportElement> aggregates = aggregateReportService.getHoursPerAssignment(assignmentIds); user.setDeletable(ReportUtil.isEmptyAggregateList(aggregates)); } LOGGER.info("Retrieved user " + user.getUsername() + ", deletable: " + user.isDeletable()); return user; }
@Test public void shouldPersist() { UserDepartment org = UserDepartmentObjectMother.createUserDepartment(); User user = UserObjectMother.createUser(); user.setUserId(5); ProjectAssignment assignment = new ProjectAssignment(); assignment.setUser(user); assignment.setAssignmentId(1); assignment.setProject(new Project(1)); assignment.setAssignmentType(new ProjectAssignmentType(EhourConstants.ASSIGNMENT_DATE)); Set<ProjectAssignment> assignments = Sets.newHashSet(assignment); user.setUserDepartment(org); user.setProjectAssignments(assignments); userDao.persist(user); assertNotNull(user.getUserId()); }
@PostConstruct @Transactional(propagation = Propagation.REQUIRES_NEW) public void init() { LOGGER.info("Finding and fixing users who are PM but don't have PM role (EHO-381)"); List<Project> projectsWithPmSet = projectDao.findAllProjectsWithPmSet(); for (Project project : projectsWithPmSet) { User pm = project.getProjectManager(); boolean hasPmRole = pm.getUserRoles().contains(UserRole.PROJECTMANAGER); if (!hasPmRole) { LOGGER.warn(String.format("%s (%s) does not have PM role but is PM for %s. Adding PM role.", pm.getFullName(), pm.getPK(), project.getFullName())); projectService.validatePMRoles(project); } } } }
/** * Assign user to default projects */ @Transactional @Auditable(actionType = AuditActionType.UPDATE) public User assignUserToDefaultProjects(User user) { List<Project> defaultProjects = projectDao.findDefaultProjects(); for (Project project : defaultProjects) { ProjectAssignment assignment = ProjectAssignment.createProjectAssignment(project, user); if (!isAlreadyAssigned(assignment, user.getProjectAssignments())) { LOGGER.debug("Assigning user " + user.getUserId() + " to default project " + project.getName()); user.addProjectAssignment(assignment); persistNewProjectAssignment(assignment); } } return user; }
@Transactional public void deleteAllTimesheetDataForUser(User user) { timesheetCommentDAO.deleteCommentsForUser(user.getUserId()); if (user.getProjectAssignments() != null && !user.getProjectAssignments().isEmpty()) { timesheetDAO.deleteTimesheetEntries(DomainUtil.getIdsFromDomainObjects(user.getProjectAssignments())); } }
public int compare(User o1, User o2) { if (firstNameFirst) { return new CompareToBuilder().append(o1.getFirstName(), o2.getFirstName()) .append(o1.getLastName(), o2.getLastName()) .toComparison(); } else { return new CompareToBuilder().append(o1.getLastName(), o2.getLastName()) .append(o1.getFirstName(), o2.getFirstName()) .toComparison(); } } }
@Test public void shouldCreateNewUser() throws ObjectNotUniqueException { User user = UserObjectMother.createUser(); when(userDAO.findByUsername(user.getUsername())).thenReturn(null); when(userDAO.persist(user)).thenReturn(user); when(assignmentService.assignUserToDefaultProjects(user)).thenReturn(user); userService.persistNewUser(user, "password"); verify(assignmentService).assignUserToDefaultProjects(user); assertNotSame("password", user.getPassword()); }
private void changePassword(User user, String newUnencryptedPassword) { int salt = (int) (Math.random() * 10000); user.setSalt(salt); user.setPassword(encryptPassword(newUnencryptedPassword, salt)); userDAO.persist(user); }
@Test public void should_assign_users_to_project_using_template_assignment() { ProjectAssignment templateAssignment = ProjectAssignmentObjectMother.createProjectAssignment(1); templateAssignment.setAllottedHours(5f); User userA = UserObjectMother.createUser(); userA.setLastName("A"); User userB = UserObjectMother.createUser(); userB.setLastName("B"); userB.setUserId(2); List<User> users = Arrays.asList(userA, userB); service.assignUsersToProjects(users, templateAssignment); ArgumentCaptor<ProjectAssignment> captor = ArgumentCaptor.forClass(ProjectAssignment.class); verify(projectAssignmentDao, times(2)).persist(captor.capture()); List<ProjectAssignment> assignments = captor.getAllValues(); ProjectAssignment assignment = assignments.get(0); assertEquals(userA, assignment.getUser()); assertEquals(5f, assignment.getAllottedHours(), 0); }