DMC/scipro
7
0
Fork 0
Code Issues28 Pull Requests2 Actions Projects1 Releases Wiki Activity

Merge branch 'lookupRefactoring' into develop

Browse Source
This commit is contained in:
Robin Eklund 2011-08-08 15:39:27 +02:00
commit 996100644a
35 changed files with 498 additions and 1504 deletions

221
src/main/java/se/su/dsv/scipro/DataInitialiser.java

@ -2,36 +2,18 @@ package se.su.dsv.scipro;
import org.springframework.beans.factory.annotation.Autowired;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectClassDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectFollowerDao;
import se.su.dsv.scipro.data.dao.interfaces.RoleDao;
import se.su.dsv.scipro.data.dao.interfaces.StringResourceDao;
import se.su.dsv.scipro.data.dao.interfaces.UserDao;
import se.su.dsv.scipro.data.dao.interfaces.UsernameDao;
import se.su.dsv.scipro.data.dataobjects.Employee;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectClass;
import se.su.dsv.scipro.data.dataobjects.ProjectFollower;
import se.su.dsv.scipro.data.dataobjects.StringResource;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.dataobjects.Username;
import se.su.dsv.scipro.data.enums.ProjectStatus;
import se.su.dsv.scipro.data.enums.ProjectTeamMemberRoles;
/**
* @author Richard Wilkinson - richard.wilkinson@jweekend.com
*
* Class defines default data to be pumped into database via dao-access.
*/
public class DataInitialiser {
//private static String[] dummyTitles = {"Wicket Event", "Party", "Breakfast At Tiffany's", "Holiday"};
//private static String[] dummyLocations = {"London", "Paris", "Pub", "New York"};
@Autowired
private EventDao eventDao;
public class DataInitialiser {
@Autowired
private UserDao userDao;
@Autowired
@ -39,152 +21,71 @@ public class DataInitialiser {
@Autowired
private RoleDao roleDao;
@Autowired
private ProjectDao projectDao;
@Autowired
private StringResourceDao stringResourceDao;
@Autowired
private ProjectClassDao projectClassDao;
@Autowired
private ProjectFollowerDao projectFollowerDao;
/**
* Creates some default table entries for empty installations.
*/
public void dataInit() {
ProjectClass masterClass;
ProjectClass bachelorClass;
createDefaultProjectClasses();
createDefaultUsers();
}
private void createDefaultProjectClasses(){
if(projectClassDao.countAll() < 3){
ProjectClass unknownClass = new ProjectClass(ProjectClass.UNKNOWN,"Unknown","Project class is unknown or could not be determined");
unknownClass = projectClassDao.save(unknownClass);
bachelorClass = new ProjectClass(ProjectClass.BACHELOR,"Bachelor","Bachelor degree thesis project");
bachelorClass = projectClassDao.save(bachelorClass);
masterClass = new ProjectClass(ProjectClass.MASTER,"Master","Master degree thesis project");
masterClass = projectClassDao.save(masterClass);
final ProjectClass masterClass = new ProjectClass(ProjectClass.MASTER,"Master","Master degree thesis project");;
final ProjectClass bachelorClass = new ProjectClass(ProjectClass.BACHELOR,"Bachelor","Bachelor degree thesis project");;
final ProjectClass unknownClass = new ProjectClass(ProjectClass.UNKNOWN,"Unknown","Project class is unknown or could not be determined");
projectClassDao.save(unknownClass);
projectClassDao.save(bachelorClass);
projectClassDao.save(masterClass);
}
User user = null;
Student studentRole = null;
User teacher = null;
Employee employeeRole = null;
Employee employeeRole2 = null;
}
private void createDefaultUsers(){;
if(userDao.countAll() == 0 ){
user = new User();
user.setFirstName("Martin");
user.setLastName("Peters");
user.setIdentifier(666L);
user.setEmailAddress("martin@peters.tf");
user = userDao.save(user);
Username un = new Username();
un.setRealm("DSV.SU.SE");
un.setUserName("mpeters");
un.setUser(user);
un = usernameDao.save(un);
studentRole = roleDao.makeStudent(user);
roleDao.makeSysAdmin(user);
teacher = new User();
teacher.setFirstName("Hugo");
teacher.setLastName("Lärare");
teacher.setIdentifier(99999999L);
teacher.setEmailAddress("lärare@dsv.su.se");
teacher = userDao.save(teacher);
Username un2 = new Username();
un2.setRealm("DSV.SU.SE");
un2.setUserName("superman");
un2.setUser(teacher);
un2 = usernameDao.save(un2);
employeeRole = roleDao.makeEmployee(teacher);
User extraStudent = new User();
extraStudent.setFirstName("Stefan");
extraStudent.setLastName("Student");
extraStudent = userDao.save(extraStudent);
Username eu = new Username();
eu.setUser(extraStudent);
eu.setRealm("DSV.SU.SE");
eu.setUserName("extra");
un2 = usernameDao.save(eu);
roleDao.makeStudent(extraStudent);
User teacher2 = new User();
teacher2.setFirstName("Hans");
teacher2.setLastName("Handledare");
teacher2.setIdentifier(439065363L);
teacher2.setEmailAddress("hand@dsv.su.se");
teacher2 = userDao.save(teacher2);
Username t2u = new Username();
t2u.setRealm("DSV.SU.SE");
t2u.setUserName("hand");
t2u.setUser(teacher2);
t2u = usernameDao.save(t2u);
employeeRole2 = roleDao.makeEmployee(teacher2);
}
if(projectDao.countAll() == 0 && false){
Project project = new Project();
project.addProjectParticipant(studentRole);
project.setHeadSupervisor(employeeRole);
project.setTitle("The superduper project about peer portals awesomeness");
project.setProjectClass(projectClassDao.getProjectClass(ProjectClass.BACHELOR));
project = projectDao.save(project);
project = new Project();
project.addProjectParticipant(studentRole);
project.setHeadSupervisor(employeeRole);
project.setTitle("The crappy project");
project.setProjectClass(projectClassDao.getProjectClass(ProjectClass.MASTER));
project.setProjectStatus(ProjectStatus.COMPLETED);
project = projectDao.save(project);
project = new Project();
project.addProjectParticipant(studentRole);
project.setHeadSupervisor(employeeRole2);
project.setTitle("The third project");
project.setProjectClass(projectClassDao.getProjectClass(ProjectClass.MASTER));
project.setProjectStatus(ProjectStatus.ACTIVE);
project = projectDao.save(project);
ProjectFollower pf = new ProjectFollower();
pf.setProject(project);
pf.setFollower(employeeRole);
pf.setProjectRole(ProjectTeamMemberRoles.REVIEWER);
pf = projectFollowerDao.save(pf);
project.getProjectFollowers().add(pf);
}
//doStringDefinitions();
}
private void doStringDefinitions(){
final String english = "en";
final String swedish = "sv";
String[][] en = {
//Key followed by definition
{"testKey","TestDefinitionInEnglish"},
{"button.submit", "Submit"}
};
String[][] sv = {
{"testKey","TestDefinitionInSwedish"},
{"button.submit", "Skicka"}
};
for(String[] arr : en){
String key = arr[0];
String value = arr[1];
if(!stringResourceDao.isDefined(key, english))
stringResourceDao.define(key, english, value);
}
for(String[] arr : sv){
String key = arr[0];
String value = arr[1];
if(!stringResourceDao.isDefined(key, swedish)){
StringResource sr = stringResourceDao.define(key, swedish, value);
//System.out.println(sr);
//Make a regular student
{
User user = new User();
user.setFirstName("Default");
user.setLastName("Student");
user.setIdentifier(null);
user.setEmailAddress("default.student@dsv.su.se");
user = userDao.save(user);
Username un = new Username();
un.setRealm("DSV.SU.SE");
un.setUserName("default.student");
un.setUser(user);
un = usernameDao.save(un);
roleDao.makeStudent(user);
}
//Make an employee
{
User teacher = new User();
teacher.setFirstName("Default");
teacher.setLastName("Teacher");
teacher.setIdentifier(null);
teacher.setEmailAddress("default.teacher@dsv.su.se");
teacher = userDao.save(teacher);
Username un = new Username();
un.setRealm("DSV.SU.SE");
un.setUserName("default.teacher");
un.setUser(teacher);
un = usernameDao.save(un);
roleDao.makeEmployee(teacher);
}
//Make a sysadm
{
User sysadm = new User();
sysadm.setFirstName("Default");
sysadm.setLastName("Sysadm");
sysadm.setIdentifier(null);
sysadm.setEmailAddress("default.sysadm@dsv.su.se");
sysadm = userDao.save(sysadm);
Username un = new Username();
un.setRealm("DSV.SU.SE");
un.setUserName("default.sysadm");
un.setUser(sysadm);
un = usernameDao.save(un);
roleDao.makeSysAdmin(sysadm);
}
}
}
}

49
src/main/java/se/su/dsv/scipro/SciProSession.java

@ -1,6 +1,5 @@
package se.su.dsv.scipro;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@ -8,7 +7,6 @@ import java.util.List;
import javax.security.auth.login.FailedLoginException;
import javax.security.auth.login.LoginException;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.wicket.Request;
import org.apache.wicket.Session;
@ -23,7 +21,9 @@ import se.su.dsv.scipro.data.dao.interfaces.UserSettingsDao;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.dataobjects.UserSettings;
import se.su.dsv.scipro.json.IUserLookup;
import se.su.dsv.scipro.json.IUserLookupFromUsername;
import se.su.dsv.scipro.json.RemoteLookupOptions;
import se.su.dsv.scipro.json.RemoteLookupOptions.LOOKUP_DEPTH;
import se.su.dsv.scipro.security.auth.Authenticator;
import se.su.dsv.scipro.security.auth.roles.Admin;
import se.su.dsv.scipro.security.auth.roles.DefaultRole;
@ -33,6 +33,7 @@ import se.su.dsv.scipro.security.auth.roles.IRole;
import se.su.dsv.scipro.security.auth.roles.Roles;
import se.su.dsv.scipro.security.auth.roles.Student;
import se.su.dsv.scipro.security.auth.roles.SysAdmin;
import se.su.dsv.scipro.util.KeyValuePair;
public class SciProSession extends WebSession {
@ -49,8 +50,8 @@ public class SciProSession extends WebSession {
@SpringBean
private UserSettingsDao userSettingsDao;
@SpringBean(name="userFullLookup")
private IUserLookup userLookup;
@SpringBean
private IUserLookupFromUsername userLookupFromUsername;
private List<IRole> iRoles = new ArrayList<IRole>();
private User user = null;
@ -146,14 +147,10 @@ public class SciProSession extends WebSession {
//Query for the user
user = userDao.getUserByUsername(username,realm);
if(user == null){
try{
user = doUserLookup(username);
if(user == null){
throw new NullPointerException("No user with username "+username+" found in the database or in daisy.");
}
} catch (NullPointerException e) {
throw e;
}
user = doUserLookup(username,realm);
if(user == null){
return false;
}
}
//Set mail-address session attributes
setLoggedInIdentity(username+"@"+realm);
@ -162,6 +159,7 @@ public class SciProSession extends WebSession {
user = userDao.save(user);
}
//Assign roles
iRoles.clear();
if(roleDao.isStudent(user)){
iRoles.add(new Student());
}
@ -195,7 +193,6 @@ public class SciProSession extends WebSession {
// With this userSettings.created() will return a users first login date and userSettings.modified() will return last login
userSettings.setLastModified(new Date());
userSettings = userSettingsDao.save(userSettings);
logger.info("User: "+getLoggedInIdentity()+ " logged in to "+this.getApplication().getClass().getSimpleName()+
" as: "+user.getFirstName()+" "+user.getLastName()+" "+user.getUserNames()+ " at: "+new Date());
loggedIn = true;
@ -213,7 +210,6 @@ public class SciProSession extends WebSession {
return false;
logger.info("Currently logged in user: '"+user.getEmailAddress()+"' attempting switch to '"+suUser+"@"+suRealm+"'");
if(suUser != null && roleDao.isSysadmin(user)){
iRoles.clear();
return signInAuthenticatedUser(suUser, suRealm);
}else{
logger.error("User does not have the privilege to switch user");
@ -269,23 +265,10 @@ public class SciProSession extends WebSession {
return true;
return false;
}
private User doUserLookup(String username) throws NullPointerException {
try{
User u = userLookup.lookup(username);
if(u != null){
return u;
}
Logger.getLogger("Application").log(Level.WARN, "" + username + " authenticated successfully, but the user was not found from daisy");
return null;
} catch (IOException ioe){
//TODO: Log exception
//ioe.printStackTrace();
throw new NullPointerException("Could not communicate with daisy");
} catch (Exception e) {
//TODO: Log exception
//e.printStackTrace();
throw new NullPointerException(e.getMessage());
}
private User doUserLookup(final String username, final String realm) {
final User u = userLookupFromUsername.lookup(new KeyValuePair<String>(username,realm), new RemoteLookupOptions(LOOKUP_DEPTH.PROJECT_AND_PARTICIPANTS));
if(u == null)
logger.warn(username + " authenticated successfully, but the user was not available from remote system.");
return u;
}
}

10
src/main/java/se/su/dsv/scipro/data/dao/interfaces/Dao.java

@ -3,14 +3,6 @@ package se.su.dsv.scipro.data.dao.interfaces;
import java.io.Serializable;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import javax.persistence.TypedQuery;
import org.hibernate.ejb.QueryHints;
import org.springframework.orm.jpa.JpaCallback;
import org.springframework.transaction.annotation.Transactional;
import se.su.dsv.scipro.data.dataobjects.DomainObject;
/**
* @author Richard Wilkinson - richard.wilkinson@jweekend.com
@ -30,6 +22,8 @@ public interface Dao<T extends DomainObject>
public T reLoad(T object);
public void refresh(T object);
public List<T> findAll(int first, int count);
public List<T> findAll(int first, int count, String orderBy);

6
src/main/java/se/su/dsv/scipro/data/dao/interfaces/UserDao.java

@ -2,19 +2,13 @@ package se.su.dsv.scipro.data.dao.interfaces;
import java.util.List;
import se.su.dsv.scipro.data.dataobjects.MessageBoard;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.Role;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.enums.ProjectStatus;
import se.su.dsv.scipro.data.enums.ProjectTeamMemberRoles;
public interface UserDao extends LazyDeleteDao<User> {
User getUserByIdentifier(Long identifier);
User getUserByUsername(String userName);
User getUserByUsername(String userName, String realm);
User getUserByEmail(String emailAddress);

5
src/main/java/se/su/dsv/scipro/data/dao/jpa/AbstractDaoJPAImp.java

@ -56,6 +56,11 @@ public abstract class AbstractDaoJPAImp<T extends DomainObject> extends JpaDaoSu
else
return null;
}
@Transactional(readOnly=true)
public void refresh(T object){
if(object != null)
getJpaTemplate().refresh(object);
}
@Transactional( readOnly=false )
public T save(T object){

6
src/main/java/se/su/dsv/scipro/data/dao/jpa/UserDaoJPAImp.java

@ -62,12 +62,6 @@ public class UserDaoJPAImp extends LazyDeleteAbstractDaoJPAImp<User> implements
});
}
@Transactional
@Deprecated
public User getUserByUsername(final String username) {
return this.getUserByUsername(username, "DSV.SU.SE");
}
@Transactional(readOnly = true)
public User getUserByUsername(final String username, final String realm) {
return getJpaTemplate().execute(new JpaCallback<User>() {

4
src/main/java/se/su/dsv/scipro/data/dataobjects/User.java

@ -8,7 +8,6 @@ import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Lob;
import javax.persistence.OneToMany;
import javax.persistence.Table;
@ -102,6 +101,9 @@ public class User extends LazyDeletableDomainObject implements Comparable<User>,
return emailAddress;
}
public void addUserName(Username username){
this.usernames.add(username);
}
public void setUserNames(Set<Username> usernames) {
this.usernames = usernames;

2
src/main/java/se/su/dsv/scipro/data/dataobjects/Username.java

@ -73,6 +73,8 @@ public class Username extends DomainObject {
public void setUser(User user) {
this.user = user;
if(user!=null)
user.addUserName(this);
}
@Override

382
src/main/java/se/su/dsv/scipro/datainitializers/EventDataInitializer.java

@ -1,382 +0,0 @@
package se.su.dsv.scipro.datainitializers;
import java.util.Date;
import java.util.Set;
import java.util.TreeSet;
import org.joda.time.DateMidnight;
import org.springframework.beans.factory.annotation.Autowired;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.GroupEventDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectClassDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectEventDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectScheduleDao;
import se.su.dsv.scipro.data.dao.interfaces.RoleDao;
import se.su.dsv.scipro.data.dao.interfaces.UserDao;
import se.su.dsv.scipro.data.dao.interfaces.UsernameDao;
import se.su.dsv.scipro.data.dataobjects.Employee;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectClass;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.SysAdmin;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.dataobjects.Username;
/**
* @author Richard Wilkinson - richard.wilkinson@jweekend.com
*
*/
public class EventDataInitializer {
@Autowired
private EventDao eventDao;
@Autowired
private ProjectEventDao projectEventDao;
@Autowired
private GroupEventDao groupEventDao;
@Autowired
private ProjectScheduleDao projectScheduleDao;
@Autowired
private ProjectDao projectDao;
@Autowired
private RoleDao roleDao;
@Autowired
private UserDao userDao;
@Autowired
private ProjectClassDao projectClassDao;
@Autowired
private UsernameDao usernameDao;
private User adam;
private User groupEventCreatorUser;
private User projectUser1;
private User projectUser2;
private Project project1;
private Project project2;
protected ProjectEvent indEvent;
protected ProjectEvent deletedIndEvent;
private ProjectClass prClass;
private GroupEvent groupEvent;
private GroupEvent deletedGroupEvent;
public void dataInit() {
User dan = new User();
dan.setFirstName("Dan");
dan.setLastName("Kjellman");
dan = userDao.save(dan);
dan = userDao.save(dan);
Username un = new Username();
un.setRealm("DSV.SU.SE");
un.setUserName("dan-kjel");
un.setUser(dan);
un = usernameDao.save(un);
prClass = new ProjectClass(ProjectClass.MASTER, "Master",null);
prClass = projectClassDao.save(prClass);
Student danStudent = new Student();
danStudent.setUser(dan);
danStudent = (Student) roleDao.save(danStudent);
Employee danEmployee = new Employee();
danEmployee.setUser(dan);
danEmployee = (Employee) roleDao.save(danEmployee);
SysAdmin danSysAdmin = new SysAdmin();
danSysAdmin.setUser(dan);
danSysAdmin = (SysAdmin) roleDao.save(danSysAdmin);
adam = new User();
adam.setFirstName("Adam");
adam.setLastName("Student");
adam = userDao.save(adam);
Student adamStudent = new Student();
adamStudent.setUser(adam);
adamStudent = (Student) roleDao.save(adamStudent);
Project noScheduleProject = new Project();
noScheduleProject.setTitle("No schedule project");
noScheduleProject.addProjectParticipant(danStudent);
noScheduleProject.addProjectParticipant(adamStudent);
noScheduleProject.setProjectClass(prClass);
noScheduleProject = projectDao.save(noScheduleProject);
groupEventCreatorUser = new User();
groupEventCreatorUser.setFirstName("eventCreatorUser");
groupEventCreatorUser = userDao.save(groupEventCreatorUser);
Employee groupEventCreatorUserRole = new Employee();
groupEventCreatorUserRole.setUser(groupEventCreatorUser);
groupEventCreatorUserRole = (Employee) roleDao.save(groupEventCreatorUserRole);
projectUser1 = new User();
projectUser1.setFirstName("Nisse");
projectUser1.setLastName("Student");
projectUser1 = userDao.save(projectUser1);
Student projectUser1Role = new Student();
projectUser1Role.setUser(projectUser1);
projectUser1Role = (Student) roleDao.save(projectUser1Role);
projectUser2 = new User();
projectUser2.setFirstName("Kalle");
projectUser2.setLastName("Student");
projectUser2 = userDao.save(projectUser2);
Student projectUser2Role = new Student();
projectUser2Role.setUser(projectUser2);
projectUser2Role = (Student) roleDao.save(projectUser2Role);
project1 = new Project();
project1.setTitle("Project 1");
project1.addProjectParticipant(adamStudent);
project1.addProjectParticipant(danStudent);
project1.setProjectClass(prClass);
project1 = projectDao.save(project1);
ProjectSchedule schedule1 = new ProjectSchedule();
schedule1.setProject(project1);
schedule1 = projectScheduleDao.save(schedule1);
project2 = new Project();
project2.setTitle("Project 2");
project2.addProjectParticipant(adamStudent);
project2.addProjectParticipant(projectUser2Role);
project2.setProjectClass(prClass);
project2 = projectDao.save(project2);
ProjectSchedule schedule2 = new ProjectSchedule();
schedule2.setProject(project2);
schedule2 = projectScheduleDao.save(schedule2);
indEvent = new ProjectEvent();
indEvent.setTitle("Individual event title");
indEvent.setDescription("Individual Event Description");
indEvent.setDueDate(new Date(System.currentTimeMillis() + 100000));
Set<Student> indEventStudents = new TreeSet<Student>();
indEventStudents.add(adamStudent);
indEvent.setParticipants(indEventStudents);
indEvent.setProjectSchedule(schedule1);
indEvent.setCreator(groupEventCreatorUser);
indEvent = projectEventDao.save(indEvent);
deletedIndEvent = new ProjectEvent();
deletedIndEvent.setTitle("Deleted Individual Event title");
deletedIndEvent.setDescription("Deleted Individual Event description");
deletedIndEvent.setDueDate(new Date(System.currentTimeMillis() + 100000));
deletedIndEvent.setDeleted(true);
Set<Student> indDeletedEventStudents = new TreeSet<Student>();
indDeletedEventStudents.add(adamStudent);
indEvent.setParticipants(indDeletedEventStudents);
deletedIndEvent.setProjectSchedule(schedule1);
deletedIndEvent.setCreator(groupEventCreatorUser);
deletedIndEvent = projectEventDao.save(deletedIndEvent);
groupEvent = new GroupEvent();
groupEvent.setTitle("Group event title");
groupEvent.setDescription("Group Event Description");
groupEvent.setDueDate(new Date(System.currentTimeMillis() + 500000000));
groupEvent.addProjectSchedule(schedule1);
groupEvent.addProjectSchedule(schedule2);
groupEvent.setCreator(groupEventCreatorUser);
groupEvent = groupEventDao.save(groupEvent);
deletedGroupEvent = new GroupEvent();
deletedGroupEvent.setTitle("Deleted group Event title");
deletedGroupEvent.setDescription("Deleted group Event description");
deletedGroupEvent.setDueDate(new Date(System.currentTimeMillis() + 100000));
deletedGroupEvent.setDeleted(true);
deletedGroupEvent.addProjectSchedule(schedule1);
deletedGroupEvent.addProjectSchedule(schedule2);
deletedGroupEvent.setCreator(groupEventCreatorUser);
deletedGroupEvent = groupEventDao.save(deletedGroupEvent);
DateMidnight date1 = new DateMidnight();
int count = 0;
for(int i = 1; i < 6; i++){
date1 = date1.plusWeeks(i);
indEvent = new ProjectEvent();
indEvent.setTitle("Project event " + count++);
indEvent.setDescription("Project event description");
indEvent.setDueDate(date1.toDate());
Set<Student> students = new TreeSet<Student>();
students.add(adamStudent);
if(count % 2 == 0){
students.add(projectUser1Role);
}
indEvent.setParticipants(students);
indEvent.setProjectSchedule(schedule1);
indEvent.setCreator(groupEventCreatorUser);
indEvent = projectEventDao.save(indEvent);
}
date1 = new DateMidnight();
for(int i = 1; i < 6; i++){
date1 = date1.minusWeeks(i);
indEvent = new ProjectEvent();
indEvent.setTitle("Project event " + count++);
indEvent.setDescription("Duis quis faucibus odio. Ut ullamcorper elit eu lacus gravida pharetra. Nunc fermentum tincidunt purus, nec dignissim massa feugiat a. Quisque vestibulum, elit in convallis commodo, metus ipsum accumsan lorem, vitae pulvinar odio odio ac dolor. Donec arcu quam, consectetur scelerisque interdum eget, tempus non odio. Vestibulum pellentesque viverra diam vitae bibendum. In congue fringilla suscipit. Sed semper tortor nec ligula mollis a tempus mauris interdum. Phasellus sit amet mauris leo, ut mollis velit.");
indEvent.setDueDate(date1.toDate());
Set<Student> students = new TreeSet<Student>();
students.add(adamStudent);
if(count % 2 == 0){
students.add(projectUser1Role);
}
indEvent.setParticipants(students);
indEvent.setProjectSchedule(schedule1);
indEvent.setCreator(groupEventCreatorUser);
indEvent = projectEventDao.save(indEvent);
}
date1 = new DateMidnight();
for(int i = 1; i < 6; i++){
date1 = date1.minusWeeks(i).minusDays(1);
groupEvent = new GroupEvent();
groupEvent.setTitle("Group event " + count++);
groupEvent.setDescription("Duis quis faucibus odio. Ut ullamcorper elit eu lacus gravida pharetra. Nunc fermentum tincidunt purus, nec dignissim massa feugiat a. Quisque vestibulum, elit in convallis commodo, metus ipsum accumsan lorem, vitae pulvinar odio odio ac dolor. Donec arcu quam, consectetur scelerisque interdum eget, tempus non odio. Vestibulum pellentesque viverra diam vitae bibendum. In congue fringilla suscipit. Sed semper tortor nec ligula mollis a tempus mauris interdum. Phasellus sit amet mauris leo, ut mollis velit.");
groupEvent.setDueDate(date1.toDate());
groupEvent.addProjectSchedule(schedule1);
groupEvent.addProjectSchedule(schedule2);
groupEvent.setCreator(groupEventCreatorUser);
groupEvent = groupEventDao.save(groupEvent);
}
date1 = new DateMidnight();
for(int i = 1; i < 6; i++){
date1 = date1.plusWeeks(i).plusDays(1);
groupEvent = new GroupEvent();
groupEvent.setTitle("Group event " + count++);
groupEvent.setDescription("Group Event Description");
groupEvent.setDueDate(date1.toDate());
groupEvent.addProjectSchedule(schedule1);
groupEvent.addProjectSchedule(schedule2);
groupEvent.setCreator(groupEventCreatorUser);
groupEvent = groupEventDao.save(groupEvent);
}
date1 = new DateMidnight();
for(int i = 1; i < 6; i++){
date1 = date1.plusDays(i).plus(60 * 60 * 1000);
groupEvent = new GroupEvent();
groupEvent.setTitle("Group event " + count++);
groupEvent.setDescription("Group Event Description");
groupEvent.setDueDate(date1.toDate());
groupEvent.addProjectSchedule(schedule1);
groupEvent.addProjectSchedule(schedule2);
groupEvent.setCreator(groupEventCreatorUser);
groupEvent = groupEventDao.save(groupEvent);
date1 = new DateMidnight();
date1 = date1.plusDays(i);
indEvent = new ProjectEvent();
indEvent.setTitle("Project event " + count++);
indEvent.setDescription("Project event description");
indEvent.setDueDate(date1.toDate());
Set<Student> students = new TreeSet<Student>();
students.add(adamStudent);
if(count % 2 == 0){
students.add(projectUser1Role);
}
indEvent.setParticipants(students);
indEvent.setProjectSchedule(schedule1);
indEvent.setCreator(groupEventCreatorUser);
indEvent = projectEventDao.save(indEvent);
}
System.out.println("DONE");
}
public EventDao getEventDao() {
return eventDao;
}
public void setEventDao(EventDao eventDao) {
this.eventDao = eventDao;
}
public GroupEventDao getGroupEventDao() {
return groupEventDao;
}
public void setGroupEventDao(GroupEventDao groupEventDao) {
this.groupEventDao = groupEventDao;
}
public ProjectScheduleDao getProjectScheduleDao() {
return projectScheduleDao;
}
public void setProjectScheduleDao(ProjectScheduleDao projectScheduleDao) {
this.projectScheduleDao = projectScheduleDao;
}
public ProjectDao getProjectDao() {
return projectDao;
}
public void setProjectDao(ProjectDao projectDao) {
this.projectDao = projectDao;
}
public RoleDao getRoleDao() {
return roleDao;
}
public void setRoleDao(RoleDao roleDao) {
this.roleDao = roleDao;
}
public UserDao getUserDao() {
return userDao;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public ProjectEventDao getProjectEventDao() {
return projectEventDao;
}
public void setProjectEventDao(ProjectEventDao projectEventDao) {
this.projectEventDao = projectEventDao;
}
}

69
src/main/java/se/su/dsv/scipro/datainitializers/EventTemplatesInitializer.java

@ -1,69 +0,0 @@
package se.su.dsv.scipro.datainitializers;
import org.springframework.beans.factory.annotation.Autowired;
import se.su.dsv.scipro.data.dao.interfaces.ProjectEventTemplateDao;
import se.su.dsv.scipro.data.dao.interfaces.RoleDao;
import se.su.dsv.scipro.data.dao.interfaces.UserDao;
import se.su.dsv.scipro.data.dataobjects.Employee;
import se.su.dsv.scipro.data.dataobjects.ProjectEventTemplate;
import se.su.dsv.scipro.data.dataobjects.SysAdmin;
import se.su.dsv.scipro.data.dataobjects.User;
public class EventTemplatesInitializer {
@Autowired
private UserDao userDao;
@Autowired
private RoleDao roleDao;
@Autowired
private ProjectEventTemplateDao eventTemplateDao;
public void dataInit(){
User supervisorUser = new User();
supervisorUser = userDao.save(supervisorUser);
Employee supervisorRole = new Employee();
supervisorRole.setUser(supervisorUser);
supervisorRole = (Employee) roleDao.save(supervisorRole);
User sysAdminUser = new User();
sysAdminUser = userDao.save(sysAdminUser);
SysAdmin sysAdminRole = new SysAdmin();
sysAdminRole.setUser(sysAdminUser);
sysAdminRole = (SysAdmin) roleDao.save(sysAdminRole);
ProjectEventTemplate projectEventTemplate = new ProjectEventTemplate();
projectEventTemplate.setTitle("projectEventTemplate title");
projectEventTemplate.setDescription("Project event template description");
projectEventTemplate.setTemplateCreator(supervisorUser);
projectEventTemplate = (ProjectEventTemplate) eventTemplateDao.save(projectEventTemplate);
ProjectEventTemplate projectEventTemplateSysAdmin = new ProjectEventTemplate();
projectEventTemplateSysAdmin.setTitle("projectEventTemplateSysAdmin title");
projectEventTemplateSysAdmin.setDescription("projectEventTemplateSysAdmin description");
projectEventTemplateSysAdmin.setTemplateCreator(sysAdminUser);
projectEventTemplateSysAdmin = (ProjectEventTemplate) eventTemplateDao.save(projectEventTemplateSysAdmin);
User employeeAndSysAdminUser = new User();
employeeAndSysAdminUser = userDao.save(employeeAndSysAdminUser);
SysAdmin employeeAndSysAdminUserSysAdminRole = new SysAdmin();
employeeAndSysAdminUserSysAdminRole.setUser(employeeAndSysAdminUser);
employeeAndSysAdminUserSysAdminRole = (SysAdmin) roleDao.save(employeeAndSysAdminUserSysAdminRole);
Employee employeeAndSysAdminUserEmpRole = new Employee();
employeeAndSysAdminUserEmpRole.setUser(employeeAndSysAdminUser);
employeeAndSysAdminUserEmpRole = (Employee) roleDao.save(employeeAndSysAdminUserEmpRole);
ProjectEventTemplate pr1 = new ProjectEventTemplate();
pr1.setTitle("pr1 title");
pr1.setDescription("pr1 description");
pr1.setTemplateCreator(employeeAndSysAdminUser);
pr1 = (ProjectEventTemplate) eventTemplateDao.save(pr1);
}
}

125
src/main/java/se/su/dsv/scipro/datainitializers/ScheduleTemplateInitializer.java

@ -1,125 +0,0 @@
package se.su.dsv.scipro.datainitializers;
import org.springframework.beans.factory.annotation.Autowired;
import se.su.dsv.scipro.data.dao.interfaces.ProjectClassDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectEventTemplateDao;
import se.su.dsv.scipro.data.dao.interfaces.RoleDao;
import se.su.dsv.scipro.data.dao.interfaces.ScheduleTemplateDao;
import se.su.dsv.scipro.data.dao.interfaces.UserDao;
import se.su.dsv.scipro.data.dataobjects.Employee;
import se.su.dsv.scipro.data.dataobjects.ProjectClass;
import se.su.dsv.scipro.data.dataobjects.ProjectEventTemplate;
import se.su.dsv.scipro.data.dataobjects.ScheduleTemplate;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.SysAdmin;
import se.su.dsv.scipro.data.dataobjects.User;
public class ScheduleTemplateInitializer {
@Autowired
private UserDao userDao;
@Autowired
private RoleDao roleDao;
@Autowired
private ScheduleTemplateDao scheduleTemplateDao;
@Autowired
private ProjectEventTemplateDao eventTemplateDao;
@Autowired
private ProjectClassDao projectClassDao;
private User supervisorUser;
private Employee supervisorRole;
private User sysAdminUser;
private SysAdmin sysAdminRole;
private ScheduleTemplate sysAdminTemplate;
private ScheduleTemplate employeeTemplate;
private ProjectEventTemplate projectEventTemplateSysAdmin;
private ProjectEventTemplate projectEventTemplate;
public void dataInit(){
supervisorUser = new User();
supervisorUser.setFirstName("Adam");
supervisorUser.setLastName("Supervisor");
supervisorUser = userDao.save(supervisorUser);
supervisorRole = new Employee();
supervisorRole.setUser(supervisorUser);
supervisorRole = (Employee) roleDao.save(supervisorRole);
sysAdminUser = new User();
sysAdminUser.setFirstName("Eva");
sysAdminUser.setLastName("SysAdmin");
sysAdminUser = userDao.save(sysAdminUser);
sysAdminRole = new SysAdmin();
sysAdminRole.setUser(sysAdminUser);
sysAdminRole = (SysAdmin) roleDao.save(sysAdminRole);
ProjectClass masterClass = new ProjectClass(ProjectClass.MASTER, "Master",null);
ProjectClass bachelorClass = new ProjectClass(ProjectClass.BACHELOR,"Bachelor",null);
masterClass = projectClassDao.save(masterClass);
bachelorClass = projectClassDao.save(bachelorClass);
for(int i = 0; i < 20; i++){
ScheduleTemplate s = new ScheduleTemplate();
s.setActive(true);
s.setTemplateName("ScheduleTemplate no " + i);
if(i % 2 == 0){
s.setCreator(supervisorUser);
s.setProjectClass(bachelorClass);
} else {
s.setCreator(sysAdminUser);
s.setSysAdminTemplate(true);
s.setProjectClass(masterClass);
}
s = scheduleTemplateDao.save(s);
}
ScheduleTemplate s = new ScheduleTemplate();
s.setActive(true);
s.setTemplateName("A test template");
s.setTemplateDescription("Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque et magna in nulla rutrum dictum. Nunc at dolor nunc. Morbi quis augue vel urna posuere pharetra at non quam. Nunc elit mauris, commodo sed gravida sed, tempus in tortor. \nPellentesque accumsan nulla ante, in pulvinar velit. Mauris in nisi mi, fermentum porttitor turpis. Vivamus non nunc ipsum. Phasellus ultricies malesuada nibh eget dapibus. Duis id ipsum at tellus bibendum eleifend id sed augue. Nunc ornare vehicula dapibus. Praesent eget arcu ut elit tempus hendrerit. Aliquam imperdiet, quam at convallis volutpat, diam orci elementum ante, at luctus nunc leo sed elit.");
s.setCreator(supervisorUser);
s.setProjectClass(bachelorClass);
s = scheduleTemplateDao.save(s);
for(int i = 0; i < 10; i++){
ProjectEventTemplate e = new ProjectEventTemplate();
e.setTemplateCreator(supervisorUser);
e.setDescription("Duis quis faucibus odio. Ut ullamcorper elit eu lacus gravida pharetra. Nunc fermentum tincidunt purus, nec dignissim massa feugiat a. Quisque vestibulum, elit in convallis commodo, metus ipsum accumsan lorem, vitae pulvinar odio odio ac dolor. Donec arcu quam, consectetur scelerisque interdum eget, tempus non odio. Vestibulum pellentesque viverra diam vitae bibendum. In congue fringilla suscipit. Sed semper tortor nec ligula mollis a tempus mauris interdum. Phasellus sit amet mauris leo, ut mollis velit.");
e.setEstimatedTimeConsumption(10);
e.setNumberInOrder(i);
e.setTitle("Event tempalte no: " + i);
s.addProjectEventTemplate(e);
}
s = scheduleTemplateDao.save(s);
User u = new User();
u.setFirstName("Dan");
u.setLastName("Allaroller");
u = userDao.save(u);
Employee us = new Employee();
us.setUser(u);
us = (Employee) roleDao.save(us);
SysAdmin usa = new SysAdmin();
usa.setUser(u);
usa = (SysAdmin) roleDao.save(usa);
Student st = new Student();
st.setUser(u);
st = (Student) roleDao.save(st);
}
}

82
src/main/java/se/su/dsv/scipro/json/DefaultUserFullLookup.java

@ -1,82 +0,0 @@
package se.su.dsv.scipro.json;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import se.su.dsv.scipro.ApplicationSettings;
import se.su.dsv.scipro.data.dao.interfaces.UserDao;
import se.su.dsv.scipro.data.dataobjects.User;
/**
* This class does a lookup on a username against the remote remoteLookupUrl specified in
* the applicationContext, under ApplicationSettings.
*
* This class does NOT handle Daisys merging of users and is not maintained.
*
* @author Dan Kjellman <dan-kjel@dsv.su.se>
*/
@Deprecated
@Component("userFullLookup")
public class DefaultUserFullLookup implements IUserLookup {
/*
* References populated by spring
*/
@Autowired
private UserDao userDao;
@Autowired
private JsonUserFullResponseHandler userResponseHandler;
@Autowired
private ApplicationSettings settings;
private Logger logger;
public DefaultUserFullLookup(){
logger = Logger.getLogger(this.getClass());
}
/**
* Perform lookup against remote server
*
* @param username the username to lookup
* @throws IOException if there was an error in the connection
*/
public User lookup(String username) throws IOException {
if(username == null){
logger.log(Level.ERROR, "Trying to pass null instead of a username to the userlookup");
throw new IllegalStateException("You cannot pass null as the lookup parameter");
}
logger.log(Level.INFO,"Starting lookup for username: " + username);
Map<String, String> params = new HashMap<String, String>();
//For now you can only log in with dsv.su.se accounts...
params.put("username", username);
RequestSender request = new RequestSender(userResponseHandler, settings.getRemoteLookupUrl(), params, RequestSender.REQUEST_TYPE_POST);
try{
request.processRequest();
} catch (IOException e) {
//Gets logged by the requestsender....
throw e;
}
/*
* Lookup the user and return
*/
User u = userDao.getUserByUsername(username);
if(u != null){
logger.log(Level.INFO, "Imported user/username from remote system: " + u.getFirstName() + " " + u.getLastName() + "("+username+") id: " + u.getId());
}
return u;
}
}

80
src/main/java/se/su/dsv/scipro/json/DefaultUserLookup.java

@ -1,80 +0,0 @@
package se.su.dsv.scipro.json;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import se.su.dsv.scipro.ApplicationSettings;
import se.su.dsv.scipro.data.dao.interfaces.UserDao;
import se.su.dsv.scipro.data.dataobjects.User;
/**
* This class does a lookup on a username against the remote remoteLookupUrl specified in
* the applicationContext, under ApplicationSettings.
*
* This class does NOT handle Daisys merging of users and is not maintained.
*
* @author Dan Kjellman <dan-kjel@dsv.su.se>
*/
@Component("userLookup")
public class DefaultUserLookup implements IUserLookup {
/*
* References populated by spring
*/
@Autowired
private UserDao userDao;
@Autowired
private JsonUserResponseHandler userResponseHandler;
@Autowired
private ApplicationSettings settings;
private Logger logger;
public DefaultUserLookup(){
logger = Logger.getLogger(this.getClass());
}
/**
* Perform lookup against remote server
*
* @param username the username to lookup
* @throws IOException if there was an error in the connection
*/
public User lookup(String username) throws IOException {
if(username == null){
logger.log(Level.ERROR, "Trying to pass null instead of a username to the userlookup");
throw new IllegalStateException("You cannot pass null as the lookup parameter");
}
logger.log(Level.INFO,"Starting lookup for userid: " + username);
Map<String, String> params = new HashMap<String, String>();
//For now you can only log in with dsv.su.se accounts...
params.put("userid", username);
RequestSender request = new RequestSender(userResponseHandler, settings.getRemoteLookupUrl(), params, RequestSender.REQUEST_TYPE_POST);
try{
request.processRequest();
} catch (IOException e) {
//Gets logged by the requestsender....
throw e;
}
/*
* Lookup the user and return
*/
User u = userDao.getUserByUsername(username);
if(u != null){
logger.log(Level.INFO, "Imported user/username from remote system: " + u.getFirstName() + " " + u.getLastName() + "("+username+") id: " + u.getId());
}
return u;
}
}

32
src/main/java/se/su/dsv/scipro/json/DefaultUserLookupBase.java Normal file

@ -0,0 +1,32 @@
package se.su.dsv.scipro.json;
import java.io.IOException;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import se.su.dsv.scipro.ApplicationSettings;
import se.su.dsv.scipro.data.dao.interfaces.UserDao;
/**
* Package-private Abstract base for the public UserLookups.
* This is not an ideal pattern under most circumstances, but class is package private and thus not part of exported API.
*/
abstract class DefaultUserLookupBase{
@Autowired
protected UserDao userDao;
@Autowired
private JsonUserResponseHandler userResponseHandler;
@Autowired
private ApplicationSettings settings;
protected boolean doRemoteRequest(final Map<String,String> params, final RemoteLookupOptions options){
RequestSender request = new RequestSender(userResponseHandler, settings.getRemoteLookupUrl(), params, options, RequestSender.REQUEST_TYPE.POST);
try{
request.processRequest();
} catch (final IOException e){
return false;
}
return true;
}
}

36
src/main/java/se/su/dsv/scipro/json/DefaultUserLookupFromIdentifier.java Normal file

@ -0,0 +1,36 @@
package se.su.dsv.scipro.json;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import se.su.dsv.scipro.data.dataobjects.User;
/**
* Default implementation of IUserLookupFromIdentifier queries remote defined by ApplicationSettings via JSon requests.
*/
@Component("userLookupFromIdentifier")
public class DefaultUserLookupFromIdentifier extends DefaultUserLookupBase implements IUserLookupFromIdentifier {
private Logger logger = Logger.getLogger(DefaultUserLookupFromIdentifier.class);
public User lookup(final Long identifier, final RemoteLookupOptions options){
if(identifier == null){
throw new IllegalStateException("null values for user parameter not allowed");
}
logger.debug("Starting remote lookup for: " + identifier);
final Map<String, String> params = new HashMap<String, String>();
params.put("userid", identifier.toString());
if(!doRemoteRequest(params,options)){
logger.warn("Remote lookup failed for identifier: "+identifier);
return null;
}
final User u = userDao.getUserByIdentifier(identifier);
if(u != null)
logger.info("Successfully imported user/username from remote system: " + u.getId() + " " +u.getUserNames());
else
logger.warn("Failed to import a valid user from remote system: "+identifier);
return u;
}
}

38
src/main/java/se/su/dsv/scipro/json/DefaultUserLookupFromUsername.java Normal file

@ -0,0 +1,38 @@
package se.su.dsv.scipro.json;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.util.KeyValuePair;
/**
* Default implementation of IUserLookupFromUsername, queries remote defined by ApplicationSettings via JSon requests.
*/
@Component("userLookupFromUsername")
public class DefaultUserLookupFromUsername extends DefaultUserLookupBase implements IUserLookupFromUsername {
private Logger logger = Logger.getLogger(DefaultUserLookupFromUsername.class);
public User lookup(final KeyValuePair<String> userAtRealm, final RemoteLookupOptions options){
if(userAtRealm == null || userAtRealm.getKey() == null){
throw new IllegalStateException("null values for user parameter not allowed");
}
final String user = userAtRealm.getKey();
final String realm = (userAtRealm.getValue()!=null?userAtRealm.getValue().toUpperCase():"DSV.SU.SE");
logger.debug("Starting remote lookup for: " + user + "@"+realm);
final Map<String, String> params = new HashMap<String, String>();
params.put("username", user);
params.put("realm", realm);
if(!doRemoteRequest(params,options))
return null;
final User u = userDao.getUserByUsername(user,realm);
if(u != null)
logger.info("Successfully imported user/username from remote system: " + user+"@"+realm+ " (id: " + u.getId()+") "+u.getUserNames());
else
logger.warn("Failed to import a valid user from remote system: "+userAtRealm);
return u;
}
}

9
src/main/java/se/su/dsv/scipro/json/ILookup.java

@ -1,6 +1,13 @@
package se.su.dsv.scipro.json;
/**
* Generic interface for Remote lookups.
* The recommended way of using this interface is to create specializations
* (see IUserLookupFromIdentifier for an example) that defines the actual parameterized types used, and implement those interfaces in concrete classes.
* @param <T> The return type specifier, implementations are urged to return a null value when a lookup fails.
* @param <E> The lookup parameter, use compound types to support querying on multiple parameters.
*/
public interface ILookup<T, E> {
public T lookup(E lookupParam) throws Exception;
public T lookup(final E lookupParam, final RemoteLookupOptions options);
}

5
src/main/java/se/su/dsv/scipro/json/IResponseHandler.java

@ -1,5 +1,8 @@
package se.su.dsv.scipro.json;
/**
* Interface for delegated callback handling of response-strings.
*/
public interface IResponseHandler {
public void handleResponse(String response);
public void handleResponse(final String response,final RemoteLookupOptions options);
}

7
src/main/java/se/su/dsv/scipro/json/IUserLookup.java

@ -1,7 +0,0 @@
package se.su.dsv.scipro.json;
import se.su.dsv.scipro.data.dataobjects.User;
public interface IUserLookup extends ILookup<User, String>{
public User lookup(String username) throws Exception;
}

11
src/main/java/se/su/dsv/scipro/json/IUserLookupFromIdentifier.java Normal file

@ -0,0 +1,11 @@
package se.su.dsv.scipro.json;
import se.su.dsv.scipro.data.dataobjects.User;
/**
* Lookup interface specification for remotely querying for User data.
* See ILookup for more information on the implicit contract of this interface.
*/
public interface IUserLookupFromIdentifier extends ILookup<User,Long>{
public User lookup(final Long identifier, final RemoteLookupOptions options);
}

13
src/main/java/se/su/dsv/scipro/json/IUserLookupFromUsername.java Normal file

@ -0,0 +1,13 @@
package se.su.dsv.scipro.json;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.util.KeyValuePair;
/**
* Lookup interface specification for remotely querying for User data.
* The supplied parameter is a KeyValuePair<String> where the key-field is the users username and the value-field is the users realm.
* See ILookup for more information on the implicit contract of this interface.
*/
public interface IUserLookupFromUsername extends ILookup<User,KeyValuePair<String>>{
public User lookup(final KeyValuePair<String> userAtRealm, final RemoteLookupOptions options);
}

38
src/main/java/se/su/dsv/scipro/json/ImportUpdateStatsResponseHandler.java

@ -3,6 +3,8 @@ package se.su.dsv.scipro.json;
import java.lang.reflect.Type;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import se.su.dsv.scipro.jsonobjects.JsonUpdateStatsContainer;
import se.su.dsv.scipro.workerthreads.UserAndProjectImportWorker;
@ -12,20 +14,11 @@ import com.google.gson.reflect.TypeToken;
/**
* Handler for json responses regarding users (creating and updating)
*
* @author Dan Kjellman <dan-kjel@dsv.su.se>
*
*/
@Component
public class ImportUpdateStatsResponseHandler extends JsonResponseHandler {
private boolean logResult = false;
public ImportUpdateStatsResponseHandler(){
super();
}
private Logger logger = Logger.getLogger(ImportUpdateStatsResponseHandler.class);
/**
* Handles a json string
*
@ -34,7 +27,7 @@ public class ImportUpdateStatsResponseHandler extends JsonResponseHandler {
*
* @param response the json string
*/
public void handleResponse(String response) {
public void handleResponse(final String response, final RemoteLookupOptions options) {
JsonUpdateStatsContainer statsContainer = null;
try{
Gson gson = new Gson();
@ -49,26 +42,5 @@ public class ImportUpdateStatsResponseHandler extends JsonResponseHandler {
UserAndProjectImportWorker.updatedUsers = statsContainer.updatedUsers.intValue();
UserAndProjectImportWorker.updatedTheses = statsContainer.updatedTheses.intValue();
}
/*
if(logResult){
logger.log(Level.INFO, "\nResult from userimport/update:\nChecked: " + completeContainer.theses.size() + " users\n" +
"Changed users: " + changedUsers + "\n" +
"Created users: " + createdUsers + "\n" +
"Number of errors when creating users: " + userCreationErrors + "\n" +
"Num First name changes: " + getNumFirstNameChanges() + "\n" +
"Num last name changes: " + getNumLastNameChanges() + "\n" +
"Num Email changes: " + getNumEmailChanges() + "\n" +
"Num Usernames added: " + getNumUsernamesAdded() + "\n" +
"Num Supervisors created: " + getNumFirstNameChanges() + "\n");
}
*/
}
public void setLogResult(boolean logResult) {
this.logResult = logResult;
}
public boolean isLogResult() {
return logResult;
}
}

63
src/main/java/se/su/dsv/scipro/json/ImportWorkerLookup.java

@ -5,36 +5,29 @@ import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import se.su.dsv.scipro.ApplicationSettings;
/**
* This class does a lookup on a username against the remote remoteLookupUrl specified in
* the applicationContext, under ApplicationSettings.
*
*
*
* @author Dan Kjellman <dan-kjel@dsv.su.se>
*/
//TODO Make sure this worker successfully fails when it should
@Component
public class ImportWorkerLookup {
public static final String USERS = "users";
public static final String THESES = "theses";
/*
* References populated by spring (from applicationContext)
*/
private ImportWorkerResponseHandler thesesResponseHandler;
private ImportUpdateStatsResponseHandler statsResonseHandler;
private ApplicationSettings settings;
private Logger logger;
public ImportWorkerLookup(){
logger = Logger.getLogger(this.getClass());
}
@Autowired
private ImportWorkerResponseHandler importWorkerResponseHandler;
@Autowired
private ImportUpdateStatsResponseHandler importUpdateStatsResponseHandler;
@Autowired
private ApplicationSettings applicationSettings;
public void lookup(Date updatedAfter, String type) throws IOException{
lookup(-1,-1, updatedAfter, type);
@ -60,7 +53,7 @@ public class ImportWorkerLookup {
}else{
//logger.log(Level.INFO,"Starting lookup for completeGet=true & type="+type+" & updatedAfter=" + updatedAfter);
}
RequestSender request = new RequestSender(thesesResponseHandler, settings.getRemoteLookupUrl(), params, RequestSender.REQUEST_TYPE_POST);
RequestSender request = new RequestSender(importWorkerResponseHandler, applicationSettings.getRemoteLookupUrl(), params, new RemoteLookupOptions(), RequestSender.REQUEST_TYPE.POST);
try{
request.processRequest();
} catch (IOException e) {
@ -74,7 +67,7 @@ public class ImportWorkerLookup {
params.put("updateStats", "true");
params.put("updatedAfter",""+updatedAfter.getTime());
RequestSender request = new RequestSender(statsResonseHandler, settings.getRemoteLookupUrl(), params, RequestSender.REQUEST_TYPE_POST);
RequestSender request = new RequestSender(importUpdateStatsResponseHandler, applicationSettings.getRemoteLookupUrl(), params, new RemoteLookupOptions(), RequestSender.REQUEST_TYPE.POST);
try{
request.processRequest();
} catch (IOException e) {
@ -82,34 +75,4 @@ public class ImportWorkerLookup {
throw e;
}
}
/*
* Getters and setters (for spring)
*/
public ImportWorkerResponseHandler getUserResponseHandler() {
return thesesResponseHandler;
}
public void setUserResponseHandler(ImportWorkerResponseHandler thesesResponseHandler) {
this.thesesResponseHandler = thesesResponseHandler;
}
public ApplicationSettings getSettings() {
return settings;
}
public void setSettings(ApplicationSettings settings) {
this.settings = settings;
}
public ImportUpdateStatsResponseHandler getStatsResonseHandler() {
return statsResonseHandler;
}
public void setStatsResonseHandler(
ImportUpdateStatsResponseHandler statsResonseHandler) {
this.statsResonseHandler = statsResonseHandler;
}
}

31
src/main/java/se/su/dsv/scipro/json/ImportWorkerResponseHandler.java

@ -3,6 +3,8 @@ package se.su.dsv.scipro.json;
import java.lang.reflect.Type;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
@ -21,16 +23,9 @@ import com.google.gson.reflect.TypeToken;
* @author Dan Kjellman <dan-kjel@dsv.su.se>
*
*/
@Component
public class ImportWorkerResponseHandler extends JsonResponseHandler {
private boolean logResult = false;
public ImportWorkerResponseHandler(){
super();
}
private Logger logger = Logger.getLogger(ImportWorkerResponseHandler.class);
/**
* Handles a json string
*
@ -39,7 +34,7 @@ public class ImportWorkerResponseHandler extends JsonResponseHandler {
*
* @param response the json string
*/
public void handleResponse(String response) {
public void handleResponse(final String response, final RemoteLookupOptions options) {
JsonCompleteGetContainer completeContainer = null;
try{
Gson gson = new Gson();
@ -106,7 +101,7 @@ public class ImportWorkerResponseHandler extends JsonResponseHandler {
if(user == null){
createThesisUser(jsonUser, false);
createThesisUser(jsonUser, new RemoteLookupOptions());
}else{
lookForChangesInUserAndSave(jsonUser);
}
@ -117,7 +112,7 @@ public class ImportWorkerResponseHandler extends JsonResponseHandler {
if(project == null){
//System.out.println("User does not exist... trying to create");
if(null == checkAndCreateProject(jsonThesis)){
if(null == checkAndCreateProject(jsonThesis,options)){
thesesCreationsErrors++;
} else {
thesesCreations++;
@ -129,8 +124,8 @@ public class ImportWorkerResponseHandler extends JsonResponseHandler {
}
}
if(logResult){
logger.log(Level.INFO, "\nResult from userimport/update:\nChecked: " + completeContainer.users.size() + " users\n" +
if(isLogResult()){
logger.info("\nResult from userimport/update:\nChecked: " + completeContainer.users.size() + " users\n" +
"Changed users: " + changedUsers + "\n" +
"Created users: " + createdUsers + "\n" +
"Number of errors when creating users: " + userCreationErrors + "\n" +
@ -147,12 +142,4 @@ public class ImportWorkerResponseHandler extends JsonResponseHandler {
"Number of errors when creating theses: " + thesesCreationsErrors + "\n" );
}
}
public void setLogResult(boolean logResult) {
this.logResult = logResult;
}
public boolean isLogResult() {
return logResult;
}
}

371
src/main/java/se/su/dsv/scipro/json/JsonResponseHandler.java

@ -1,16 +1,16 @@
package se.su.dsv.scipro.json;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.TransactionStatus;
import org.springframework.dao.DataAccessException;
import org.springframework.transaction.annotation.Transactional;
import se.su.dsv.scipro.ApplicationSettings;
import se.su.dsv.scipro.data.dao.interfaces.ProjectClassDao;
@ -33,13 +33,11 @@ import se.su.dsv.scipro.jsonobjects.JsonThesisParticipant;
import se.su.dsv.scipro.jsonobjects.JsonUser;
import se.su.dsv.scipro.jsonobjects.JsonUserRole;
import se.su.dsv.scipro.jsonobjects.JsonUsername;
@Component
public abstract class JsonResponseHandler implements IResponseHandler {
/*
* References populated by spring
*/
/**
* Package-private base class for JsonResponseHandlers.
* Contains a number of utility methods to lessen boilerplate code inside implementations.
*/
abstract class JsonResponseHandler implements IResponseHandler {
@Autowired
protected UserDao userDao;
@Autowired
@ -52,12 +50,12 @@ public abstract class JsonResponseHandler implements IResponseHandler {
protected ProjectFollowerDao projectFollowerDao;
@Autowired
protected RoleDao roleDao;
@SpringBean(name="userLookup")
protected IUserLookup userLookup;
protected ApplicationSettings settings;
@Autowired
protected IUserLookupFromIdentifier userLookupFromIdentifier;
@Autowired
protected ApplicationSettings applicationSettings;
protected Logger logger;
private Logger logger = Logger.getLogger(JsonResponseHandler.class);
private int numUsersCreated = 0;
private int numEmailChanges = 0;
@ -67,169 +65,137 @@ public abstract class JsonResponseHandler implements IResponseHandler {
private int numSupervisorsCreated = 0;
private int numThesesCreated = 0;
private int numThesesChanged = 0;
public JsonResponseHandler(){
super();
logger = Logger.getLogger(this.getClass());
}
private boolean logResult = false;
/**
* Creates a thesis user from a json user
*
* @param jsonUser the json user to use for creation
* @return User the create thesisuser
* Creates and persists a User from a JsonUser
* @param jsonUser the JsonUser to use for creation
* @param doFullCheck If true, checkAndCreateProject will be called on each project included in the query response.
* @return The created User or null if it cannot be persisted.
*/
protected User createThesisUser(JsonUser jsonUser, boolean doFullCheck){
TransactionStatus status = null;
User thesisUser = null;
try {
thesisUser = new User();
thesisUser.setFirstName(jsonUser.firstName);
thesisUser.setLastName(jsonUser.lastName);
thesisUser.setIdentifier(jsonUser.id);
thesisUser.setEmailAddress(jsonUser.email);
//System.out.println("Trying to save " + thesisUser.getIdentifier());
thesisUser = userDao.save(thesisUser);
/*
* Check against daisy if the user is a supervisor - if so, create a supervisor role
*/
for(JsonUserRole jur : jsonUser.roles){
if(jur.role.equals("AUTHOR")){
roleDao.makeStudent(thesisUser);
}
if(jur.role.equals("SUPERVISOR")){
roleDao.makeEmployee(thesisUser);
}
if(jur.role.equals("ADMIN")){
// roleDao.makeAdmin(thesisUser);
}
}
for(JsonUsername jsonUsername : jsonUser.usernames){
Username thesisUserName = new Username();
thesisUserName.setUserName(jsonUsername.username.toLowerCase().trim());
thesisUserName.setRealm(jsonUsername.realm.toUpperCase().trim());
thesisUserName.setUser(thesisUser);
thesisUserName = userNameDao.save(thesisUserName);
}
if(doFullCheck){
for(JsonThesis jThesis : jsonUser.theses){
checkAndCreateProject(jThesis);
}
}
numUsersCreated++;
protected User createThesisUser(final JsonUser jsonUser, final RemoteLookupOptions options){
User user = new User();
user.setFirstName(jsonUser.firstName);
user.setLastName(jsonUser.lastName);
user.setIdentifier(jsonUser.id);
user.setEmailAddress(jsonUser.email);
try{
user = userDao.save(user);
}catch(final DataAccessException dae){
logger.error("Cannot save User with jsonuserid: " + jsonUser.id);
return null;
}
catch (Exception e){
logger.log(Level.ERROR, "Cannot save jsonuser with jsonuserid: " + jsonUser.id + " - Rolling back...\n" + e.getMessage());
throw new RuntimeException(e);
/*
* Check against remote system data if the user is a supervisor - if so, create a supervisor role
*/
for(JsonUserRole jur : jsonUser.roles){
if(jur.role.equals("AUTHOR")){
roleDao.makeStudent(user);
}
if(jur.role.equals("SUPERVISOR")){
roleDao.makeEmployee(user);
}
if(jur.role.equals("ADMIN")){
// roleDao.makeAdmin(thesisUser);
}
}
return thesisUser;
/*
* Create and set the user's usernames
*/
for(JsonUsername jsonUsername : jsonUser.usernames){
Username userName = new Username();
userName.setUserName(jsonUsername.username.toLowerCase().trim());
userName.setRealm(jsonUsername.realm.toUpperCase().trim());
userName.setUser(user);
userName = userNameDao.save(userName);
if(userName == null)
logger.error("Cannot save Username '"+jsonUsername.username+"' for User '"+user.getIdentifier()+"'");
}
/*
* Create any projects of which the user is a member of
*/
if(options.getLookupDepth().equals(RemoteLookupOptions.LOOKUP_DEPTH.PROJECT_AND_PARTICIPANTS)){
for(JsonThesis jThesis : jsonUser.theses){
checkAndCreateProject(jThesis, options);
}
}
numUsersCreated++;
return user;
}
protected Project checkAndCreateProject(JsonThesis jThesis) {
Project project = null;
//System.out.println("Creating project:" + jThesis.thesisID);
project = projectDao.getProjectByIdentifier(jThesis.thesisID);
if(project == null){
project = new Project();
project.setIdentifier(jThesis.thesisID);
project.setTitle(jThesis.title);
if(jThesis.status.equals("STARTED") || jThesis.status.equals("LATE")){
project.setProjectStatus(ProjectStatus.ACTIVE);
}else if(jThesis.status.equals("FINISHED")){
project.setProjectStatus(ProjectStatus.COMPLETED);
}else{
project.setProjectStatus(ProjectStatus.INACTIVE);
}
ProjectClass pc = getProjectClass(jThesis.type);
project.setProjectClass(pc);
if(jThesis.daisyStartDate > 0){
Date daisyStartDate = new Date(jThesis.daisyStartDate);
project.setDaisyStartDate(daisyStartDate);
}
project = projectDao.save(project);
/**
* Retrieve a Project matching the given JsonThesis ID, and create a project matching the supplied JsonThesis in full if it does not already exists.
* @param jThesis
* @return The retrieved (or newly created) project.
*/
protected Project checkAndCreateProject(JsonThesis jThesis, final RemoteLookupOptions options) {
Project project = null;
project = projectDao.getProjectByIdentifier(jThesis.thesisID);
if(project == null){
project = new Project();
project.setIdentifier(jThesis.thesisID);
project.setTitle(jThesis.title);
if(jThesis.status.equals("STARTED") || jThesis.status.equals("LATE")){
project.setProjectStatus(ProjectStatus.ACTIVE);
}else if(jThesis.status.equals("FINISHED")){
project.setProjectStatus(ProjectStatus.COMPLETED);
}else{
project.setProjectStatus(ProjectStatus.INACTIVE);
}
ProjectClass pc = getProjectClass(jThesis.type);
project.setProjectClass(pc);
if(jThesis.daisyStartDate > 0){
Date daisyStartDate = new Date(jThesis.daisyStartDate);
project.setDaisyStartDate(daisyStartDate);
}
project = projectDao.save(project);
//Synch participants
if(options.getLookupDepth().equals(RemoteLookupOptions.LOOKUP_DEPTH.PROJECT_AND_PARTICIPANTS)){
for(JsonThesisParticipant jtp : jThesis.participants){
User u = userDao.getUserByIdentifier(jtp.id);
//Attempt remote lookup if no user is found
if(u == null){
String id = String.valueOf(jtp.id);
try {
u = userLookup.lookup(id);
} catch (Exception e) {
logger.log(Level.ERROR, "Cannot save jsonuser with jsonuserid: " + jtp.id + " - Rolling back...\n" + e.getMessage());
throw new RuntimeException(e);
final Long id = Long.valueOf(jtp.id);
if( (u = userLookupFromIdentifier.lookup(id, new RemoteLookupOptions(RemoteLookupOptions.LOOKUP_DEPTH.NONE))) == null){
logger.warn("Cannot create jsonuser with jsonuserid: " + jtp.id+" while adding participants for the project: "+project.getIdentifier());
continue;
}
u = userDao.getUserByIdentifier(jtp.id);
}
if(u != null){
if(jtp.role.equals("SUPERVISOR")){
Employee e = roleDao.makeEmployee(u);
project.setHeadSupervisor(e);
}else if(jtp.role.equals("PARTICIPANT")){
Student s = roleDao.makeStudent(u);
project.getProjectParticipants().add(s);
//Move on, set participant roles
if(jtp.role.equals("SUPERVISOR")){
Employee e = roleDao.makeEmployee(u);
project.setHeadSupervisor(e);
}else if(jtp.role.equals("PARTICIPANT")){
Student s = roleDao.makeStudent(u);
project.getProjectParticipants().add(s);
}else{
ProjectFollower pf = new ProjectFollower();
if(jtp.role.equals("ASSISTANT_SUPERVISOR")){
pf.setProjectRole(ProjectTeamMemberRoles.CO_SUPERVISOR);
pf.setFollower((Employee)roleDao.makeEmployee(u));
}else if(jtp.role.equals("OPPONENT")){
//TODO: OPPONENT
}else if (jtp.role.equals("EXAMINER")){
pf.setProjectRole(ProjectTeamMemberRoles.REVIEWER);
pf.setFollower(roleDao.makeEmployee(u));
}
else{
ProjectFollower pf = new ProjectFollower();
if(jtp.role.equals("ASSISTANT_SUPERVISOR")){
pf.setProjectRole(ProjectTeamMemberRoles.CO_SUPERVISOR);
pf.setFollower((Employee)roleDao.makeEmployee(u));
}else if(jtp.role.equals("OPPONENT")){
//TODO: OPPONENT
}else if (jtp.role.equals("EXAMINER")){
pf.setProjectRole(ProjectTeamMemberRoles.REVIEWER);
pf.setFollower(roleDao.makeEmployee(u));
}
if(pf.getFollower() != null && pf.getProjectRole() != null){
pf.setProject(project);
pf = projectFollowerDao.save(pf);
project.getProjectFollowers().add(pf);
}
if(pf.getFollower() != null && pf.getProjectRole() != null){
pf.setProject(project);
pf = projectFollowerDao.save(pf);
project.getProjectFollowers().add(pf);
}
}
}
project = projectDao.save(project);
/*
try{
txManager.commit(status);
}catch(TransactionException e){
logger.log(Level.ERROR, "Cannot commit transaction with projectid:"+project.getId() + " - Rolling back...\n" + e.getMessage());
txManager.rollback(status);
throw e;
}
*/
}
project = null;
project = projectDao.getProjectByIdentifier(jThesis.thesisID);
return project;
}
project = projectDao.getProjectByIdentifier(jThesis.thesisID);
return project;
}
/**
* Look for changes in a jsonuser against a thesisuser. BEWARE: you need to be sure that
* a corresponding thesisuser exists, or an exception will be thrown
*
* @param daisyUser
* Look for changes in a jsonuser against a User.
* @note you need to be sure that a corresponding User exists, or a (potentially wrapped) Runtime exception will be thrown
* @param jsonUser
* @return
*/
protected boolean lookForChangesInUserAndSave(JsonUser jsonUser){
@ -277,16 +243,16 @@ public abstract class JsonResponseHandler implements IResponseHandler {
try {
checkAndChangeProject(current, jThesis);
} catch (Exception e) {
logger.log(Level.FATAL, "Error when checking project:" + current.getId()+ "when looking up user:"
logger.error("Error when checking project:" + current.getId()+ "when looking up user:"
+jsonUser.firstName+ " "+jsonUser.lastName+" \n" + e.getMessage());
throw new RuntimeException(e);
}
}else{
try {
checkAndCreateProject(jThesis);
checkAndCreateProject(jThesis,new RemoteLookupOptions());
} catch (Exception e) {
logger.log(Level.FATAL, "Error when creating project: daisyId=" + jThesis.thesisID + "when looking up user:"
logger.error("Error when creating project: daisyId=" + jThesis.thesisID + "when looking up user:"
+jsonUser.firstName+ " "+jsonUser.lastName+" \n" + e.getMessage());
throw new RuntimeException(e);
}
@ -328,7 +294,7 @@ public abstract class JsonResponseHandler implements IResponseHandler {
return true;
} catch (Exception e){
logger.log(Level.FATAL, "Failed to save changes for user:" + thesisUser.getIdentifier() + " - Rolling back...\n" + e.getMessage());
logger.error("Failed to save changes for user:" + thesisUser.getIdentifier() + " - Rolling back...\n" + e.getMessage());
throw new RuntimeException(e);
}
}
@ -415,11 +381,11 @@ public abstract class JsonResponseHandler implements IResponseHandler {
for(JsonThesisParticipant jtp : jThesis.participants){
User u = userDao.getUserByIdentifier(jtp.id);
if(u == null){
String id = String.valueOf(jtp.id);
final Long id = Long.valueOf(jtp.id);
try {
u = userLookup.lookup(id);
u = userLookupFromIdentifier.lookup(id, new RemoteLookupOptions(RemoteLookupOptions.LOOKUP_DEPTH.NONE));
} catch (Exception e) {
logger.log(Level.FATAL, "Failed to save changes for project:" + current.getIdentifier() + " when looking up user whith idetifier:"+jtp.id+
logger.error("Failed to save changes for project:" + current.getIdentifier() + " when looking up user with identifier:"+jtp.id+
" Rolling back...\n" + e.getMessage());
throw new RuntimeException(e);
}
@ -442,7 +408,7 @@ public abstract class JsonResponseHandler implements IResponseHandler {
followers.add(pf);
}
}else{
logger.log(Level.FATAL, "Failed to save changes for project:" + current.getIdentifier() + "u = null when looking up user whith idetifier:"+jtp.id+
logger.error("Failed to save changes for project:" + current.getIdentifier() + "u = null when looking up user whith idetifier:"+jtp.id+
"- \n Rolling back...\n");
}
}
@ -491,17 +457,15 @@ public abstract class JsonResponseHandler implements IResponseHandler {
projectDao.save(current);
}
}catch (Exception e){
logger.log(Level.FATAL, "Failed to save changes for project:" + current.getIdentifier() + " - Rolling back...\n" + e.getMessage());
logger.error("Failed to save changes for project:" + current.getIdentifier() + " - Rolling back...\n" + e.getMessage());
throw new RuntimeException(e);
}
return changed;
}
/*
* Force subclasses to handle the response
*/
public abstract void handleResponse(String response);
public abstract void handleResponse(final String response, final RemoteLookupOptions options);
/*
* Getters for logging
@ -510,27 +474,22 @@ public abstract class JsonResponseHandler implements IResponseHandler {
return numUsersCreated;
}
public int getNumEmailChanges() {
return numEmailChanges;
}
public int getNumFirstNameChanges() {
return numFirstNameChanges;
}
public int getNumLastNameChanges() {
return numLastNameChanges;
}
public int getNumUsernamesAdded() {
return numUsernamesAdded;
}
public int getNumSupervisorsCreated() {
return numSupervisorsCreated;
}
@ -539,56 +498,20 @@ public abstract class JsonResponseHandler implements IResponseHandler {
return numThesesCreated;
}
public void setNumThesesCreated(int numThesesCreated) {
this.numThesesCreated = numThesesCreated;
}
public int getNumThesesChanged() {
return numThesesChanged;
}
public void setNumThesesChanged(int numThesesChanged) {
this.numThesesChanged = numThesesChanged;
}
/*
* Getters and setters (for spring)
/**
* Sets parameter to increase logging output.
* @param logResult
*/
public UserDao getUserDao() {
return userDao;
public void setLogResult(boolean logResult) {
this.logResult = logResult;
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public UsernameDao getUsernameDao() {
return userNameDao;
}
public void setUserNameDao(UsernameDao usernameDao) {
this.userNameDao = usernameDao;
}
public ApplicationSettings getSettings() {
return settings;
}
public void setSettings(ApplicationSettings settings) {
this.settings = settings;
}
public IUserLookup getUserLookup() {
return userLookup;
}
public void setUserLookup(IUserLookup userLookup) {
this.userLookup = userLookup;
/**
* Getter for increased logging output.
*/
public boolean isLogResult() {
return logResult;
}
}

33
src/main/java/se/su/dsv/scipro/json/JsonUserFullResponseHandler.java

@ -3,6 +3,8 @@ package se.su.dsv.scipro.json;
import java.lang.reflect.Type;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.dataobjects.Username;
@ -19,15 +21,9 @@ import com.google.gson.reflect.TypeToken;
* @author Dan Kjellman <dan-kjel@dsv.su.se>
*
*/
//@Component
@Component
public class JsonUserFullResponseHandler extends JsonResponseHandler {
private boolean logResult = false;
public JsonUserFullResponseHandler(){
super();
}
private Logger logger = Logger.getLogger(JsonUserFullResponseHandler.class);
/**
* Handles a json string
*
@ -36,7 +32,7 @@ public class JsonUserFullResponseHandler extends JsonResponseHandler {
*
* @param response the json string
*/
public void handleResponse(String response) {
public void handleResponse(final String response, final RemoteLookupOptions options) {
JsonUserContainer userContainer = null;
try{
@ -56,13 +52,11 @@ public class JsonUserFullResponseHandler extends JsonResponseHandler {
//Loop all users in the response and look for changes...
for(JsonUser jsonUser : userContainer.users){
System.out.println("Checking: " + " id: " + jsonUser.id + " firstName: "+ jsonUser.firstName);
logger.debug("Checking: " + jsonUser);
User thesisUser = userDao.getUserByIdentifier(new Long(jsonUser.id));
for(JsonUsername jsonUsername : jsonUser.usernames){
System.out.println(jsonUsername.username);
logger.debug("\t"+jsonUsername.username);
String usernameString = jsonUsername.username.toLowerCase().trim();
String userRealmString = jsonUsername.realm.toUpperCase().trim();
User potentialDuplicateUser = userDao.getUserByUsername(usernameString, userRealmString);
@ -112,7 +106,7 @@ public class JsonUserFullResponseHandler extends JsonResponseHandler {
if(thesisUser == null){
//System.out.println("User does not exist... trying to create");
if(null == createThesisUser(jsonUser,true)){
if(null == createThesisUser(jsonUser,options)){
userCreationErrors++;
} else {
createdUsers++;
@ -124,8 +118,7 @@ public class JsonUserFullResponseHandler extends JsonResponseHandler {
}
}
}
if(logResult){
if(isLogResult()){
logger.log(Level.INFO, "\nResult from userimport/update:\nChecked: " + userContainer.users.size() + " users\n" +
"Changed users: " + changedUsers + "\n" +
"Created users: " + createdUsers + "\n" +
@ -137,12 +130,4 @@ public class JsonUserFullResponseHandler extends JsonResponseHandler {
"Num Supervisors created: " + getNumFirstNameChanges() + "\n");
}
}
public void setLogResult(boolean logResult) {
this.logResult = logResult;
}
public boolean isLogResult() {
return logResult;
}
}

41
src/main/java/se/su/dsv/scipro/json/JsonUserResponseHandler.java

@ -2,7 +2,7 @@ package se.su.dsv.scipro.json;
import java.lang.reflect.Type;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Component;
import se.su.dsv.scipro.data.dataobjects.User;
@ -20,13 +20,7 @@ import com.google.gson.reflect.TypeToken;
*/
@Component
public class JsonUserResponseHandler extends JsonResponseHandler {
private boolean logResult = false;
public JsonUserResponseHandler(){
super();
}
private Logger logger = Logger.getLogger(JsonUserResponseHandler.class);
/**
* Handles a json string
*
@ -35,16 +29,16 @@ public class JsonUserResponseHandler extends JsonResponseHandler {
*
* @param response the json string
*/
public void handleResponse(String response) {
public void handleResponse(final String response, final RemoteLookupOptions options) {
JsonUserContainer userContainer = null;
logger.debug(response);
try{
Gson gson = new Gson();
Type type = new TypeToken<JsonUserContainer>(){}.getType();
userContainer = gson.fromJson(response, type);
} catch (Exception e) {
logger.log(Level.FATAL, "Gson error when creating objects from json \n" + e.getMessage());
logger.error("Gson error when creating objects from json response" + e.getMessage());
logger.error("Full response from remote:" + response);
return;
}
int createdUsers = 0;
@ -53,26 +47,25 @@ public class JsonUserResponseHandler extends JsonResponseHandler {
//Loop all users in the response and look for changes...
for(JsonUser jsonUser : userContainer.users){
//System.out.println("Checking: " + " id: " + daisyUser.id + " firstName: "+ daisyUser.firstName);
User thesisUser = userDao.getUserByIdentifier(new Long(jsonUser.id));
logger.debug("Checking " + jsonUser.id);
User thesisUser = userDao.getUserByIdentifier(Long.valueOf(jsonUser.id));
if(thesisUser == null){
//System.out.println("User does not exist... trying to create");
if(null == createThesisUser(jsonUser,false)){
logger.debug("User '"+jsonUser.id+ "' does not exist locally, trying to create");
if(null == createThesisUser(jsonUser,options)){
userCreationErrors++;
} else {
createdUsers++;
}
} else {
//System.out.println("User found, looking for changes...");
logger.debug("User found, looking for changes...");
if(lookForChangesInUserAndSave(jsonUser)){
changedUsers++;
}
}
}
if(logResult){
logger.log(Level.INFO, "\nResult from userimport/update:\nChecked: " + userContainer.users.size() + " users\n" +
if(isLogResult()){
logger.info("Result from userimport/update:\nChecked: " + userContainer.users.size() + " users\n" +
"Changed users: " + changedUsers + "\n" +
"Created users: " + createdUsers + "\n" +
"Number of errors when creating users: " + userCreationErrors + "\n" +
@ -83,12 +76,4 @@ public class JsonUserResponseHandler extends JsonResponseHandler {
"Num Supervisors created: " + getNumFirstNameChanges() + "\n");
}
}
public void setLogResult(boolean logResult) {
this.logResult = logResult;
}
public boolean isLogResult() {
return logResult;
}
}

19
src/main/java/se/su/dsv/scipro/json/RemoteLookupOptions.java Normal file

@ -0,0 +1,19 @@
package se.su.dsv.scipro.json;
/**
* Option object for controlling remote requests, considered an anti-pattern at this point and
* needs re-design.
*/
public final class RemoteLookupOptions {
public enum LOOKUP_DEPTH{NONE,PROJECT_AND_PARTICIPANTS};
private final LOOKUP_DEPTH depth;
public RemoteLookupOptions(){
this(LOOKUP_DEPTH.NONE);
}
public RemoteLookupOptions(final LOOKUP_DEPTH depth){
this.depth = depth;
}
public LOOKUP_DEPTH getLookupDepth(){
return depth;
}
}

62
src/main/java/se/su/dsv/scipro/json/RequestSender.java

@ -9,8 +9,6 @@ import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import javax.net.ssl.HttpsURLConnection;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
@ -20,66 +18,40 @@ import org.apache.log4j.Logger;
* @author Dan Kjellman
*
*/
public class RequestSender {
public final class RequestSender {
public static final int REQUEST_TYPE_POST = 0;
public static final int REQUEST_TYPE_GET = 1;
public static final String[] REQUEST_METHODS = new String[]{
"POST", "GET"
};
private Logger logger;
public enum REQUEST_TYPE{POST,GET};
private final REQUEST_TYPE requestType;
private Logger logger = Logger.getLogger(RequestSender.class);
/*
* The Handler for the response
*/
protected IResponseHandler responseHandler;
private IResponseHandler responseHandler;
/*
* The params
*/
protected Map<String, String> parameters;
private Map<String, String> parameters;
/*
* The url to call
*/
protected String url;
private String url;
//Options for performed lookups
private final RemoteLookupOptions remoteLookupOptions;
/*
* Type of request, use the static variables REQUEST_TYPE_POST or REQUEST_TYPE_GET
*/
protected int requestType;
public RequestSender(IResponseHandler responseHandler, String url, Map<String, String> parameters, int requestType){
logger = Logger.getLogger(this.getClass());
if(requestType != REQUEST_TYPE_GET && requestType != REQUEST_TYPE_POST){
logger.log(Level.ERROR, "Could not send request, no request type specified");
throw new IllegalArgumentException("Bad request type");
}
public RequestSender(final IResponseHandler responseHandler, final String url, final Map<String, String> parameters, final RemoteLookupOptions options, final REQUEST_TYPE requestType){
if(responseHandler == null){
logger.log(Level.ERROR, "Could not send request, no response handler was provided");
throw new IllegalArgumentException("You need no provide a handler for the response");
}
remoteLookupOptions = (options==null?new RemoteLookupOptions():options);
this.responseHandler = responseHandler;
this.url = url;
this.parameters = parameters;
this.requestType = requestType;
}
public RequestSender(IResponseHandler responseHandler, String url){
if(responseHandler == null){
throw new IllegalArgumentException("You need no provide a handler for the response");
}
this.responseHandler = responseHandler;
this.url = url;
this.parameters = new HashMap<String, String>();
this.requestType = REQUEST_TYPE_GET;
this(responseHandler,url,new HashMap<String,String>(),null,REQUEST_TYPE.GET);
}
/**
@ -100,7 +72,7 @@ public class RequestSender {
count++;
}
if(requestType == REQUEST_TYPE_GET && parameters.size() > 0){
if(requestType == REQUEST_TYPE.GET && parameters.size() > 0){
url += "?" + parameterData;
}
@ -112,7 +84,7 @@ public class RequestSender {
URL u = new URL(url);
conn = (HttpURLConnection) u.openConnection();
conn.setRequestMethod(REQUEST_METHODS[requestType]);
conn.setRequestMethod(requestType.name());
/*
* Set connect timeout to 60 seconds and read timeout to 120 sec
@ -122,7 +94,7 @@ public class RequestSender {
conn.setConnectTimeout(1000 * 60);
conn.setReadTimeout(1000 * 120);
if(requestType == REQUEST_TYPE_POST){
if(requestType == REQUEST_TYPE.POST){
conn.setDoOutput(true);
osr = new OutputStreamWriter(conn.getOutputStream());
osr.write(parameterData);
@ -136,7 +108,7 @@ public class RequestSender {
while((line = br.readLine()) != null){
response += line;
}
responseHandler.handleResponse(response);
responseHandler.handleResponse(response, remoteLookupOptions);
} catch (IOException e){
/*
@ -152,11 +124,9 @@ public class RequestSender {
if(conn != null){
conn.disconnect();
}
if(osr != null){
osr.close();
}
if(br != null){
br.close();
}

3
src/main/java/se/su/dsv/scipro/json/pages/JsonKeyAuthPage.java

@ -34,7 +34,8 @@ public class JsonKeyAuthPage extends WebPage {
if (jsonLogin != null) {
String loginUsername = jsonLogin.username;
User user = userDao.getUserByUsername(loginUsername);
//@ToDo Fix the apple-app to support non hard-coded realm
User user = userDao.getUserByUsername(loginUsername,"DSV.SU.SE");
if (user == null) {
jsonOutput.addProperty("authenticated", false);

4
src/main/java/se/su/dsv/scipro/json/pages/JsonLoginPage.java

@ -69,9 +69,9 @@ public class JsonLoginPage extends WebPage {
}
if (loginUsername != null) {
String username = jsonLogin.username;
User user = userDao.getUserByUsername(username);
//@ToDo Fix the apple-app to support non hard-coded realm
User user = userDao.getUserByUsername(username,"DSV.SU.SE");
if (roleDao.isEmployee(user)) {
jsonOutput.addProperty("authenticated", true);
UserSettings userSettings = userSettingsDao.getUserSettings(user);

10
src/main/java/se/su/dsv/scipro/workerthreads/UserAndProjectImportWorker.java

@ -11,10 +11,8 @@ import org.springframework.stereotype.Component;
import se.su.dsv.scipro.json.ImportWorkerLookup;
@Component
public class UserAndProjectImportWorker extends AbstractWorker{
@Autowired
private ImportWorkerLookup importLookup;
private ImportWorkerLookup importWorkerLookup;
public static int updatedUsers;
public static int updatedTheses;
//The amount of theses or uses asked for
@ -34,7 +32,7 @@ public class UserAndProjectImportWorker extends AbstractWorker{
//Sets static params updatedUsers/updatedTheses
try{
beginTransaction();
importLookup.lookupUpdateStats(this.getLastRun());
importWorkerLookup.lookupUpdateStats(this.getLastRun());
commitTransaction();
} catch(Exception e){
rollbackTransaction();
@ -60,7 +58,7 @@ public class UserAndProjectImportWorker extends AbstractWorker{
try{
beginTransaction();
if(endIndex > 0){
importLookup.lookup(startIndex, endIndex,(this.getLastRun()),ImportWorkerLookup.USERS);
importWorkerLookup.lookup(startIndex, endIndex,(this.getLastRun()),ImportWorkerLookup.USERS);
}
commitTransaction();
@ -90,7 +88,7 @@ public class UserAndProjectImportWorker extends AbstractWorker{
try{
beginTransaction();
if(endIndex > 0)
importLookup.lookup(startIndex, endIndex,(this.getLastRun()),
importWorkerLookup.lookup(startIndex, endIndex,(this.getLastRun()),
ImportWorkerLookup.THESES);
commitTransaction();

96
src/main/resources/applicationContext.xml

@ -22,112 +22,20 @@
annotations
-->
<tx:annotation-driven transaction-manager="transactionManager" />
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<!-- Autowired
"eventDao"
"projectEventDao"
"groupEventDao"
"userDao"
"roleDao"
"projectDao"
"projectClassDao"
"projectScheduleDao"
"projectFollowerDao"
"checkListDao"
"checkListQuestion"
"checkListTemplate"
"checkListAnswer"
"stringResourceDao"
"fileDescriptionDao"
"projectEventTemplateDao"
"scheduleTemplateDao"
"commmentDao"
"boardMessageDao"
"messageBoardDao"
"ratingDao"
"privateMessageDao"
"recipientDao"
"resourceDao"
"supervisorBoardMessageDao"
"supervisorMessageBoardDao"
"tagDao"
"commentThreadDao"
"fileResourceDao"
"linkResourceDao"
"embedResourceDao"
-->
<!-- Peer-related beans, autowired-->
<!--
"answerDao"
"peerQueueDao"
"peerRequestDao"
"peerReviewDao"
"questionDao"
"questionOptionDao"
"reviewRatingDao"
"reviewTemplateDao"
-->
<!-- End of Peer-stuff -->
<!-- Load data initializer for default table-data -->
<bean class="se.su.dsv.scipro.DataInitialiser" init-method="dataInit" />
<!-- Defines global settings for the application -->
<bean id="applicationSettings" class="se.su.dsv.scipro.ApplicationSettings">
<!-- Set this line to true if you want to do lookup against daisy if username was not found in db
By default it's turned off since we don't have access to the daisy search yet
-->
<property name="enableRemoteUserLookup" value="true"></property>
<!-- This property points to the location of the daisy json search -->
<!-- This property points to the location of the remote system used for json requests -->
<property name="remoteLookupUrl" value="https://thesis.dsv.su.se/match/json" />
<!-- External auth support (via J2EE standard mechanism REMOTE_USER), if true: other authentication mechanics will be bypassed.-->
<property name="acceptExternalAuthentication" value="true"/>
</bean>
<!-- Defines the class used for lookup in username against a remote server NOW AUTOWIRED AND DEPRECATED, NOT MAINTAINED-->
<!-- <bean id="userFullLookup" class="se.su.dsv.scipro.json.DefaultUserFullLookup">-->
<!-- <property name="userDao" ref="userDao" />-->
<!-- <property name="settings" ref="applicationSettings" />-->
<!-- <property name="userResponseHandler" ref="jsonUserFullResponseHandler" />-->
<!-- </bean> -->
<!-- Defines the class used for lookup in username against a remote server -->
<bean id="importWorkerLookup" class="se.su.dsv.scipro.json.ImportWorkerLookup">
<property name="settings" ref="applicationSettings" />
<property name="userResponseHandler" ref="importWorkerResponseHandler" />
<property name="statsResonseHandler" ref="importStatsResponseHandler" />
</bean>
<!-- The abstract handler for json responses -->
<bean id="jsonResponseHandler" abstract="true" class="se.su.dsv.scipro.json.JsonResponseHandler">
<property name="settings" ref="applicationSettings" />
<property name="userLookup" ref="userLookup" />
</bean>
<!-- Defines the class used for lookup in username against a remote server NOW AUTOWIRED AND DEPRECATED, NOT MAINTAINED -->
<!-- <bean id="userLookup" class="se.su.dsv.scipro.json.DefaultUserLookup">-->
<!-- <property name="userDao" ref="userDao" />-->
<!-- <property name="settings" ref="applicationSettings" />-->
<!-- <property name="userResponseHandler" ref="jsonUserResponseHandler" />-->
<!-- </bean> -->
<!-- Handler for json responses regarding users -->
<bean id="jsonUserResponseHandler" parent="jsonResponseHandler" class="se.su.dsv.scipro.json.JsonUserResponseHandler" />
<bean id="jsonUserFullResponseHandler" parent="jsonResponseHandler" class="se.su.dsv.scipro.json.JsonUserFullResponseHandler" />
<bean id="importWorkerResponseHandler" parent="jsonResponseHandler" class="se.su.dsv.scipro.json.ImportWorkerResponseHandler" />
<bean id="importStatsResponseHandler" parent="jsonResponseHandler" class="se.su.dsv.scipro.json.ImportUpdateStatsResponseHandler" />
<!-- <bean class="se.su.dsv.scipro.datainitializers.EventTemplatesInitializer" init-method="dataInit" /> -->
<!-- <bean class="se.su.dsv.scipro.datainitializers.ScheduleTemplateInitializer" init-method="dataInit" />-->
<!-- <bean class="se.su.dsv.scipro.datainitializers.EventDataInitializer" init-method="dataInit" />-->
</beans>

36
src/test/java/se/su/dsv/scipro/security/auth/TestAuthRoutines.java

@ -32,15 +32,19 @@ import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.SysAdmin;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.dataobjects.Username;
import se.su.dsv.scipro.json.IUserLookup;
import se.su.dsv.scipro.json.IUserLookupFromIdentifier;
import se.su.dsv.scipro.json.IUserLookupFromUsername;
import se.su.dsv.scipro.json.RemoteLookupOptions;
import se.su.dsv.scipro.repository.util.RepositoryManager;
import se.su.dsv.scipro.util.KeyValuePair;
public class TestAuthRoutines {
private SciProSession session;
private WicketTester wt;
private User user;
private Role sysAdm;
private IUserLookup fixedLookup;
private IUserLookupFromIdentifier fixedLookupFromIdentifier;
private IUserLookupFromUsername fixedLookupFromUsername;
private ApplicationSettings appSettings;
@Before
public void init(){
@ -49,10 +53,19 @@ public class TestAuthRoutines {
appSettings = new ApplicationSettings();
appSettings.setAcceptExternalAuthentication(true);
//Fake a lookup mechanism
fixedLookup = new IUserLookup(){
fixedLookupFromUsername = new IUserLookupFromUsername(){
@Override
public User lookup(String username) throws Exception{
if(username.equals("kalle-kula"))
public User lookup(final KeyValuePair<String> userAtRealm, final RemoteLookupOptions options){
if(userAtRealm.getKey().equals("kalle-kula"))
return user;
else
return null;
}
};
fixedLookupFromIdentifier = new IUserLookupFromIdentifier(){
@Override
public User lookup(final Long identifier, final RemoteLookupOptions options){
if(identifier.equals(666))
return user;
else
return null;
@ -98,7 +111,8 @@ public class TestAuthRoutines {
ac.putBean("roleDao",mockedRoleDao);
ac.putBean("projectDao",Mockito.mock(ProjectDao.class));
ac.putBean("userSettingsDao",Mockito.mock(UserSettingsDao.class));
ac.putBean("userFullLookup",fixedLookup);
ac.putBean("userLookupFromUsername",fixedLookupFromUsername);
ac.putBean("userLookupFromIdentifier",fixedLookupFromIdentifier);
//Create tester
wt = new WicketTester(new SciProApplication(){
@Override
@ -147,7 +161,7 @@ public class TestAuthRoutines {
//At this point, an exception should be thrown
new ExternalAuthenticationRequestHelper(null);
}
@Test(expected=NullPointerException.class)
@Test
public void testSessionSignInAndSu(){
ExternalAuthenticationRequestHelper helper = new ExternalAuthenticationRequestHelper(new HttpServletRequestWrapper(wt.getServletRequest()){
@Override
@ -169,10 +183,9 @@ public class TestAuthRoutines {
user.setRoles(roles);
Assert.assertTrue(session.switchAuthenticatedUser("kalle-kula", "dsv.su.se"));
Assert.assertTrue(session.getUser().getIdentifier().equals(user.getIdentifier()));
//This should fail with an exception, there is no such user
session.switchAuthenticatedUser("somebody","somewhere.se");
Assert.assertFalse(session.switchAuthenticatedUser("somebody","somewhere.se"));
}
@Test(expected=NullPointerException.class)
@Test
public void testFailedAuthenticatedSignIn(){
ExternalAuthenticationRequestHelper helper = new ExternalAuthenticationRequestHelper(new HttpServletRequestWrapper(wt.getServletRequest()){
@Override
@ -180,8 +193,7 @@ public class TestAuthRoutines {
return "some-dude@ki.se";
}
});
//This should throw exceptions, not sure about this interface (throwing exceptions when authentication passes but no user can be located).
helper.signIn(session);
Assert.assertFalse(helper.signIn(session));
}
@Test
public void testFailedSwitchAuthentitedUser(){

3
src/test/java/se/su/dsv/scipro/wicket/BaseWicketTest.java

@ -8,7 +8,6 @@ import org.apache.wicket.Session;
import org.apache.wicket.spring.injection.annot.SpringComponentInjector;
import org.apache.wicket.spring.test.ApplicationContextMock;
import org.apache.wicket.util.tester.WicketTester;
import org.junit.Before;
import org.junit.Ignore;
import org.mockito.Mock;
import org.mockito.Mockito;
@ -50,6 +49,7 @@ import se.su.dsv.scipro.data.dao.interfaces.WorkerDataDao;
import se.su.dsv.scipro.data.dataobjects.GeneralSystemSettings;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.json.DefaultUserLookupFromUsername;
import se.su.dsv.scipro.peer.data.dao.controllers.PeerPortalController;
import se.su.dsv.scipro.peer.data.dao.interfaces.PeerRequestDao;
import se.su.dsv.scipro.peer.data.dao.interfaces.PeerReviewDao;
@ -104,6 +104,7 @@ public abstract class BaseWicketTest {
@Mock ProjectPartnerDao projectPartnerDao;
@Mock WebNotificationDao webNotificationDao;
@Mock NotificationController notificationController;
@Mock DefaultUserLookupFromUsername userLookupFromUsername;
@Mock ApplicationSettings applicationSettings;