Cleaned up old schedule stuff.

This commit is contained in:
Robin Eklund 2011-11-08 10:49:09 +01:00
parent cd2dc7f529
commit 8c1b99b3a0
112 changed files with 7 additions and 7795 deletions
resources/db_update_scripts
src/main/java/se/su/dsv/scipro
SciProApplication.java
activityplan/facade
data
events/panels
json/pages
project
schedule
supervisor/pages

@ -0,0 +1,6 @@
DROP TABLE hand_in;
DROP TABLE hand_in_activity;
DROP TABLE hand_in_feedback;
DROP TABLE project_event;
DROP TABLE group_event;
DROP TABLE event;

@ -79,11 +79,8 @@ import se.su.dsv.scipro.project.pages.FinalSeminarProjectListPage;
import se.su.dsv.scipro.project.pages.LogPage;
import se.su.dsv.scipro.project.pages.NoActiveProjectPage;
import se.su.dsv.scipro.project.pages.ProjectChecklistPage;
import se.su.dsv.scipro.project.pages.ProjectEventPage;
import se.su.dsv.scipro.project.pages.ProjectFilePage;
import se.su.dsv.scipro.project.pages.ProjectOppositionPage;
import se.su.dsv.scipro.project.pages.ProjectScheduleGeneratorPage;
import se.su.dsv.scipro.project.pages.ProjectSchedulePlannerPage;
import se.su.dsv.scipro.project.pages.ProjectStartPage;
import se.su.dsv.scipro.project.pages.ProjectViewCheckListPage;
import se.su.dsv.scipro.repository.RepositoryApplication;
@ -97,14 +94,10 @@ import se.su.dsv.scipro.security.auth.RoleBasedAuthorizationStrategy;
import se.su.dsv.scipro.supervisor.pages.SupervisorAddCheckListToProjectPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorAntiPlagiarismLinkPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorChecklistPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorEventPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorFinalSeminarListingPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorGroupEventPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorLogPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorProjectDetailsPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorProjectsFinalSeminarPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorScheduleGeneratorPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorSchedulePlannerPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorScheduleTemplatesEditorPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorScheduleTemplatesPage;
import se.su.dsv.scipro.supervisor.pages.SupervisorStartPage;
@ -200,7 +193,7 @@ public class SciProApplication extends RepositoryApplication implements IThemabl
mountBookmarkablePage("resource/resource", BookmarkableResourcePage.class);
mountBookmarkablePage("resource/tag", BookmarkableTagResourcePage.class);
/*
/* Collections.sort(eventList);
* Admin pages
*/
mountBookmarkablePage("admin/templates", AdminScheduleTemplatesPage.class);
@ -223,10 +216,7 @@ public class SciProApplication extends RepositoryApplication implements IThemabl
*/
mountBookmarkablePage("project/conference", ProjectConferencePage.class);
mountBookmarkablePage("project/activityplan", ProjectActivityPlanPage.class);
mountBookmarkablePage("project/schedule/event", ProjectEventPage.class);
mountBookmarkablePage("project/schedule/generator", ProjectScheduleGeneratorPage.class);
mountBookmarkablePage("project/files", ProjectFilePage.class);
mountBookmarkablePage("project/schedule", ProjectSchedulePlannerPage.class);
mountBookmarkablePage("project/opposition", ProjectOppositionPage.class);
mountBookmarkablePage("project/allfinalseminars", FinalSeminarProjectListPage.class);
mountBookmarkablePage("project", ProjectStartPage.class);
@ -245,12 +235,8 @@ public class SciProApplication extends RepositoryApplication implements IThemabl
mountBookmarkablePage("supervisor/templates", SupervisorScheduleTemplatesPage.class);
mountBookmarkablePage("supervisor/project/details", SupervisorProjectDetailsPage.class);
mountBookmarkablePage("supervisor/project/details/notes", SupervisorLogPage.class);
mountBookmarkablePage("supervisor/project/details/schedule", SupervisorSchedulePlannerPage.class);
mountBookmarkablePage("supervisor/project/details/checklist", SupervisorChecklistPage.class);
mountBookmarkablePage("supervisor/project/details/addchecklist", SupervisorAddCheckListToProjectPage.class);
mountBookmarkablePage("supervisor/project/details/schedule/event", SupervisorEventPage.class);
mountBookmarkablePage("supervisor/schedule/groupevent", SupervisorGroupEventPage.class);
mountBookmarkablePage("supervisor/project/details/schedule/generator", SupervisorScheduleGeneratorPage.class);
mountBookmarkablePage("supervisor/antiplagiarism", SupervisorAntiPlagiarismLinkPage.class);
mountBookmarkablePage("supervisor/conference", SupervisorConferencePage.class);
mountBookmarkablePage("supervisor/checklist", SupervisorChecklistPage.class);

@ -1,127 +0,0 @@
package se.su.dsv.scipro.activityplan.facade;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.wicket.injection.web.InjectorHolder;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.joda.time.DateMidnight;
import org.joda.time.DateTimeConstants;
import org.joda.time.Days;
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.ScheduleTemplateDao;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.ProjectEventTemplate;
import se.su.dsv.scipro.data.dataobjects.ScheduleTemplate;
@Deprecated
public class ScheduleGenerator {
@SpringBean
private ScheduleTemplateDao scheduleTemplateDao;
@SpringBean
private ProjectDao projectDao;
@SpringBean
private ProjectEventDao projectEventDao;
private Project project;
private ScheduleTemplate template;
private List<ProjectEventTemplate> eventTemplates;
private double ratio = 0.0;
private int templateEstimatedDays = 0;
private int userTimespan = 0;
private DateMidnight startDate;
private DateMidnight endDate;
public ScheduleGenerator(Long templateId, Long projectId, Date startDate, Date endDate){
InjectorHolder.getInjector().inject(this);
this.startDate = new DateMidnight(startDate);
this.endDate = new DateMidnight(endDate);
project = projectDao.load(projectId);
if(project == null){
throw new IllegalArgumentException("The schedule generator did not find the provided project from db");
}
setScheduleTemplate(templateId);
}
public void setScheduleTemplate(Long templateId){
this.template = scheduleTemplateDao.load(templateId);
if(template == null){
throw new IllegalArgumentException("Template does not exist");
}
eventTemplates = template.getProjectEventTemplates();
setup();
}
private void setup(){
for(ProjectEventTemplate e : eventTemplates){
templateEstimatedDays += e.getEstimatedTimeConsumption();
}
userTimespan = Days.daysBetween(startDate, endDate).getDays();
ratio = (double)userTimespan / (double)templateEstimatedDays;
}
public ScheduleGeneratorResult generate(){
List<ProjectEvent> events = new ArrayList<ProjectEvent>();
DateMidnight datePointer = new DateMidnight(startDate);
DateMidnight tempPointer;
int totalDuration = 0;
for(ProjectEventTemplate e : eventTemplates){
tempPointer = new DateMidnight(datePointer);
ProjectEvent event = e.createEventFromTemplate();
event.setParticipants(project.getProjectParticipants());//might have to remove this
if(e.getEstimatedTimeConsumption() <= 1){
datePointer = new DateMidnight(startDate).plusDays(e.getDaysOffset());
}
double duration = (double) e.getEstimatedTimeConsumption() * ratio;
datePointer = datePointer.plusDays((int) duration);
totalDuration += (int)duration;
for(;;){
if(datePointer.getDayOfWeek() == DateTimeConstants.SATURDAY){
datePointer = datePointer.minusDays(1);
} else if (datePointer.getDayOfWeek() == DateTimeConstants.SUNDAY){
datePointer = datePointer.plusDays(1);
} else {
break;
}
}
event.setDueDate(datePointer.toDate());
events.add(event);
if(e.getEstimatedTimeConsumption() <= 1){
datePointer = tempPointer;
}
}
return new ScheduleGeneratorResult(template, events, totalDuration, templateEstimatedDays, startDate.toDate(), endDate.toDate());
}
public Date getStartDate() {
return startDate.toDate();
}
public void setStartDate(Date startDate) {
this.startDate = new DateMidnight(startDate);
setup();
}
public Date getEndDate() {
return endDate.toDate();
}
public void setEndDate(Date endDate) {
this.endDate = new DateMidnight(endDate);
setup();
}
}

@ -1,71 +0,0 @@
package se.su.dsv.scipro.activityplan.facade;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import org.apache.wicket.IClusterable;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.ScheduleTemplate;
@Deprecated
public class ScheduleGeneratorResult implements IClusterable {
private static final long serialVersionUID = 1L;
private ScheduleTemplate template;
private int totalDuration = 0;
private int templateDuration = 0;
private Date startDate;
private Date endDate;
private List<ProjectEvent> eventList;
public ScheduleGeneratorResult(ScheduleTemplate template, List<ProjectEvent> eventList,
int totalDuration, int templateDuration, Date startDate, Date endDate){
this.template = template;
this.eventList = eventList;
this.totalDuration = totalDuration;
this.templateDuration = templateDuration;
this.startDate = startDate;
this.endDate = endDate;
Collections.sort(eventList);
}
public int getTotalDuration() {
return totalDuration;
}
public int getTemplateDuration() {
return templateDuration;
}
public Date getStartDate() {
return startDate;
}
public Date getEndDate() {
return endDate;
}
public void setTemplate(ScheduleTemplate template) {
this.template = template;
}
public ScheduleTemplate getTemplate() {
return template;
}
public List<ProjectEvent> getEventList() {
return eventList;
}
public void setEventList(List<ProjectEvent> eventList) {
this.eventList = eventList;
}
public Date getLastEventDate(){
return eventList.get(eventList.size() - 1).getDueDate();
}
}

@ -1,178 +0,0 @@
package se.su.dsv.scipro.activityplan.facade;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.TreeSet;
import org.apache.wicket.injection.web.InjectorHolder;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.joda.time.DateMidnight;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dao.interfaces.ScheduleTemplateDao;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.ProjectEventTemplate;
import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
import se.su.dsv.scipro.data.dataobjects.ScheduleTemplate;
@Deprecated
public class TemplateGenerator { //based on ScheduleGenerator
/*@SpringBean
private ProjectScheduleDao projectscheduleDao;*/
@SpringBean
private ScheduleTemplateDao scheduleTemplateDao;
@SpringBean
private ProjectDao projectDao;
private Project project;
private ProjectSchedule schedule;
private TreeSet<ProjectEvent> projectEvents;
private List<ProjectEventTemplate> projectEventTemplate;
private int templateEstimatedDays = 0;
private int durationInDays = 0;
private int daysOffset;
private DateMidnight startDate;
public TemplateGenerator(Long projectId){
InjectorHolder.getInjector().inject(this);
project = projectDao.load(projectId);
if(project == null){
throw new IllegalArgumentException("The template generator did not find the provided project from db");
}
schedule = project.getProjectSchedule();
projectEvents = new TreeSet<ProjectEvent>(schedule.getProjectEvents());
if(schedule.getStartDate() != null){
this.startDate = new DateMidnight(schedule.getStartDate());
}else{
int days = (new DateMidnight(projectEvents.first().getDueDate()).getDayOfYear() - new DateMidnight(schedule.getStartDate()).getDayOfYear());
this.startDate = new DateMidnight(projectEvents.first().getDueDate()).minusDays(days);
}
}
public ScheduleTemplate generate(){
ScheduleTemplate template;
DateMidnight datePointer = new DateMidnight(startDate);
projectEventTemplate = new ArrayList<ProjectEventTemplate>();
int counter = 0;
template = new ScheduleTemplate();
template.setCreator(SciProSession.get().getUser());
template.setSysAdminTemplate(false);
template.setTemplateName("");
for(ProjectEvent pe : projectEvents){
counter ++;
if(isMilestone(pe)){
durationInDays = ((new DateMidnight(pe.getDueDate()).getDayOfYear() - datePointer.getDayOfYear()));
}else{
durationInDays = 0;
}
ProjectEventTemplate pet = new ProjectEventTemplate();
pet.setTitle(pe.getTitle());
pet.setDescription(pe.getDescription());
pet.setTemplateCreator(SciProSession.get().getUser());
pet.setEstimatedTimeConsumption(durationInDays);
pet.setNumberInOrder(counter);
pet.setRequireHandIn(pe.isRequireHandIn());
pet.setScheduleTemplate(template);
int daysOffset = (new DateMidnight(pe.getDueDate()).getDayOfYear() - startDate.getDayOfYear());
pet.setdaysOffset(daysOffset);
datePointer = datePointer.plusDays(durationInDays);
setTemplateEstimatedDays(getTemplateEstimatedDays() + durationInDays);
projectEventTemplate.add(pet);
}
template.setProjectEventTemplates(projectEventTemplate);
template = scheduleTemplateDao.save(template);
return template;
}
/*public ScheduleTemplate generate(){
ScheduleTemplate template;
DateMidnight datePointer = new DateMidnight(startDate);
projectEventTemplate = new ArrayList<ProjectEventTemplate>();
int counter = 0;
for(ProjectEvent pe : projectEvents){
counter ++;
if(isMilestone(pe)){
durationInDays = (startDate.getDayOfYear() - (new DateMidnight(pe.getDueDate()).getDayOfYear()));
}else{
durationInDays = 0;
}
ProjectEventTemplate pet = new ProjectEventTemplate();
pet.setTitle(pe.getTitle());
pet.setDescription(pe.getDescription());
pet.setTemplateCreator(SciProSession.get().getUser());
pet.setEstimatedTimeConsumption(durationInDays);
pet.setNumberInOrder(counter);
pet.setRequireHandIn(pe.isRequireHandIn());
datePointer = datePointer.plusDays(durationInDays);
templateEstimatedDays += durationInDays;
projectEventTemplate.add(pet);
}
template = new ScheduleTemplate();
template.setCreator(SciProSession.get().getUser());
template.setSysAdminTemplate(false);
template.setProjectEventTemplates(projectEventTemplate);
return template;
}*/
public boolean isMilestone(ProjectEvent pe){ // events from templates have no participants and such events are milestones
return pe.getParticipants().isEmpty();
}
public Date getStartDate() {
return startDate.toDate();
}
public void setStartDate(Date startDate) {
this.startDate = new DateMidnight(startDate);
}
public int getTemplateEstimatedDays() {
return templateEstimatedDays;
}
public void setTemplateEstimatedDays(int templateEstimatedDays) {
this.templateEstimatedDays = templateEstimatedDays;
}
public int getDaysOffset() {
return daysOffset;
}
public void setDaysOffset(int daysOffset) {
this.daysOffset = daysOffset;
}
}

@ -1,30 +0,0 @@
package se.su.dsv.scipro.data.controllers;
import java.util.Collection;
import org.apache.wicket.IClusterable;
import org.apache.wicket.markup.html.form.upload.FileUpload;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
public interface HandInController extends IClusterable {
/**
* Store a HandIn with the uploaded files provided as an argument. Also creates a Feedback and assignes it
* to the head supervisor for the project.
*
* @param uploads the uploads to store with the handin
* @return
*/
boolean store(Project project, Event event, Collection<FileUpload> uploads);
/**
* TODO Not tested at all
*
* @param handInActivity
*/
void delete(final HandInActivity handInActivity);
}

@ -1,15 +0,0 @@
package se.su.dsv.scipro.data.controllers;
import java.util.Collection;
import org.apache.wicket.IClusterable;
import org.apache.wicket.markup.html.form.upload.FileUpload;
import se.su.dsv.scipro.data.dataobjects.HandIn;
import se.su.dsv.scipro.data.enums.HandInStatus;
public interface HandInFeedbackController extends IClusterable {
boolean store(HandIn handIn, Collection<FileUpload> uploads, HandInStatus status);
}

@ -1,157 +0,0 @@
package se.su.dsv.scipro.data.controllers.impl;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.wicket.IClusterable;
import org.apache.wicket.markup.html.form.upload.FileUpload;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.data.controllers.HandInController;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.FileDescriptionDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInFeedbackDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.FileDescription;
import se.su.dsv.scipro.data.dataobjects.HandIn;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.HandInFeedback;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.repository.FileRepository;
@Controller("handInController")
public class HandInControllerImpl implements HandInController, IClusterable {
private static final long serialVersionUID = 1L;
@Autowired
private HandInActivityDao handInActivityDao;
@Autowired
private FileDescriptionDao fileDescriptionDao;
@Autowired
private HandInDao handInDao;
@Autowired
private HandInFeedbackDao handInFeedbackDao;
@Autowired
private FileRepository fileRepository;
@Autowired
private EventDao eventDao;
@Autowired
private ProjectDao projectDao;
public HandInControllerImpl(){}
/**
* Store a HandIn with the uploaded files provided as an argument. Also creates a Feedback and assignes it
* to the head supervisor for the project.
*
* @param uploads the uploads to store with the handin
* @return
*/
public boolean store(Project project, Event event, Collection<FileUpload> uploads){
project = projectDao.reLoad(project);
event = eventDao.reLoad(event);
if(event == null || project == null){
return false;
}
HandInActivity handInActivity = handInActivityDao.getHandInActivity(event, project);
if(handInActivity == null){
return false;
}
String projectRoot = fileRepository.getProjectRootPath(project.getId());
if(projectRoot == null){
return false;
}
HandIn hi = new HandIn();
HandInFeedback hif = new HandInFeedback();
//Wrap this i a "manual-transaction"
try {
handInActivity = handInActivityDao.reLoad(handInActivity);
hi.setFolderName("" + handInActivity.getHandIns().size() + 1);
hi.setHandedInBy(SciProSession.get().getUser());
hi.setHandInActivity(handInActivity);
for(FileUpload f : uploads){
fileRepository.storeFile(f, getHandInAbsolutePath(projectRoot, handInActivity, hi));
}
List<FileDescription> files = new ArrayList<FileDescription>();
for(FileDescription f : fileRepository.searchFiles(getHandInAbsolutePath(projectRoot, handInActivity, hi),false)){
files.add(fileDescriptionDao.save(f));
}
hi.setFiles(files);
hi = handInDao.save(hi);
//Head supervisor can be null, but the upload form is not visible without a head supervisor
hif.setAssignedTo(project.getHeadSupervisor().getUser());
hif.setHandIn(hi);
hif = handInFeedbackDao.save(hif);
return true;
} catch (Exception e) {
//Something went wrong...
Logger.getLogger(HandInControllerImpl.class).log(Level.ERROR, "An error occured while storing a handin..."+ e.getMessage());
//Delete from repository
//TODO: Possible delete the hand in activity folder for the event as well if it's empty
fileRepository.delete(getHandInAbsolutePath(projectRoot, handInActivity, hi));
//Delete the handin
if(hi.getId() != null){
handInDao.delete(handInDao.reLoad(hi));
}
}
return false;
}
/**
* TODO Not tested at all
*
* @param handInActivity
*/
public void delete(final HandInActivity handInActivity){
String projectRoot = fileRepository.getProjectRootPath(handInActivity.getProject().getId());
String absPath = getHandInActivityAbsolutePath(projectRoot, handInActivity);
if(fileRepository.existsFileByPath(absPath)){
fileRepository.delete(absPath);
}
}
/**
* Get the absolute path to the folder of the hand in passed as an argument
*/
private static String getHandInAbsolutePath(String projectRootPath, HandInActivity handInActivity, HandIn hi){
return projectRootPath + HandInActivity.DIRECTORY_PATH +
handInActivity.getFullDirectoryName() + hi.getFolderName();
}
/**
* Get the absolute path to the folder of the hand in passed as an argument
*/
private static String getHandInActivityAbsolutePath(String projectRootPath, HandInActivity handInActivity){
return projectRootPath + HandInActivity.DIRECTORY_PATH +
handInActivity.getFullDirectoryName();
}
}

@ -1,89 +0,0 @@
package se.su.dsv.scipro.data.controllers.impl;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.wicket.markup.html.form.upload.FileUpload;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.data.controllers.HandInFeedbackController;
import se.su.dsv.scipro.data.dao.interfaces.FileDescriptionDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInFeedbackDao;
import se.su.dsv.scipro.data.dataobjects.FileDescription;
import se.su.dsv.scipro.data.dataobjects.HandIn;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.enums.HandInStatus;
import se.su.dsv.scipro.repository.FileRepository;
@Controller("handInFeedbackController")
public class HandInFeedbackControllerImpl implements HandInFeedbackController {
private static final long serialVersionUID = 1L;
@Autowired
private HandInDao handInDao;
@Autowired
private HandInFeedbackDao handInFeedbackDao;
@Autowired
private FileRepository fileRepository;
@Autowired
private FileDescriptionDao fileDescriptionDao;
private static final String FEEDBACK_FOLDER_NAME = "feedback/";
public boolean store(HandIn handIn, Collection<FileUpload> uploads, HandInStatus status){
handIn = handInDao.reLoad(handIn);
handIn.setStatus(status);
HandInStatus oldStatus = handIn.getStatus();
handIn.getFeedback().setCheckedBy(SciProSession.get().getUser());
handIn.getFeedback().setCheckedDate(new Date());
Project p = handIn.getHandInActivity().getProject();
HandInActivity handInActivity = handIn.getHandInActivity();
String projectPath = fileRepository.getProjectRootPath(p.getId());
String folder = projectPath + HandInActivity.DIRECTORY_PATH +
handInActivity.getFullDirectoryName() + handIn.getFolderName() + FEEDBACK_FOLDER_NAME;
try {
for(FileUpload u : uploads){
fileRepository.storeFile(u, folder);
}
List<FileDescription> files = new ArrayList<FileDescription>();
for(FileDescription fd : fileRepository.searchFiles(folder,false)){
files.add(fileDescriptionDao.save(fd));
}
handIn.getFeedback().setFiles(files);
handInFeedbackDao.save(handIn.getFeedback());
handInDao.save(handIn);
return true;
} catch (Exception e){
fileRepository.delete(folder);
handIn.getFeedback().setCheckedBy(null);
handIn.getFeedback().setCheckedDate(null);
for(FileDescription fd : handIn.getFeedback().getFiles()){
if(fd.getId() != null){
fileDescriptionDao.delete(fd);
}
}
handIn.setStatus(oldStatus);
handInFeedbackDao.save(handIn.getFeedback());
handInDao.save(handIn);
Logger.getLogger(HandInFeedbackController.class).log(Level.ERROR, "Failed to store feedback " + e.getMessage());
return false;
}
}
}

@ -1,13 +0,0 @@
package se.su.dsv.scipro.data.dao.interfaces;
import java.util.Date;
import java.util.List;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
public interface BaseEventDao {
public List<Event> getEventsByUserAndProject(final User u, final Project p, final Date fromDate, final Date toDate,
final Integer limit);
}

@ -1,57 +0,0 @@
package se.su.dsv.scipro.data.dao.interfaces;
import java.util.Date;
import java.util.List;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
/**
* @author Martin Peters - mpeters@dsv.su.se
*
*/
public interface EventDao extends LazyDeleteDao<Event> {
/**
* Get events by user and project
*
* @param u the user
* @param p the project
* @param isDone true if event is done, false if not done or null if you don't care
* @param fromDate pass null if you don't care
* @param toDate pass null if you don't care
* @param limit pass null if you don't care
* @return
*/
public List<Event> getEventsByUserAndProject(final User u, final Project p, final Date fromDate, final Date toDate,
final Integer limit);
public List<Event> getAllEventsByUserAndProject(final User u, final Project p);
public List<Event> getUpcomingEventsByUserAndProject(final User u, final Project p);
public List<Event> getUpcomingEventsByUserAndProject(final User u, final Project p, final Integer limit);
public Event getNextEvent(final User u, final Project p, final Event event);
public boolean hasHandInsInHandInActivity(final Event event);
/**
* Method that checks whether an event is deletable or not. Subclasses of
* event can define their own behavior in this respect.
* @param event
* @return
*/
public boolean isDeletable(final Event event, final User user);
/**
* Method that checks whether an event is editable or not. Subclasses of
* event can define their own behavior in this respect.
* @param event
* @return
*/
public boolean isEditable(final Event event, final User user);
public boolean eventIsDone(final Event e, final User user, final Project project);
}

@ -1,16 +0,0 @@
package se.su.dsv.scipro.data.dao.interfaces;
import java.util.Date;
import java.util.List;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.enums.HandInStatus;
public interface GroupEventDao extends LazyDeleteDao<GroupEvent> {
public List<GroupEvent> findGroupEventsWithAssignedFeedback(final User assignedUser, final HandInStatus status);
public List<GroupEvent> findGroupEventsByCreator(final User creator, final Date fromDate, final Date toDate, final Integer limit);
}

@ -1,17 +0,0 @@
package se.su.dsv.scipro.data.dao.interfaces;
import java.util.List;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
public interface HandInActivityDao extends LazyDeleteDao<HandInActivity> {
public HandInActivity getHandInActivity(final Event event, final Project project);
public List<HandInActivity> findHandInActivitiesWithAssignedFeedback(final User user, final Project project);
public List<HandInActivity> findHandInActivitiesWithAssignedFeedback(final User user);
}

@ -1,7 +0,0 @@
package se.su.dsv.scipro.data.dao.interfaces;
import se.su.dsv.scipro.data.dataobjects.HandIn;
public interface HandInDao extends Dao<HandIn> {
}

@ -1,7 +0,0 @@
package se.su.dsv.scipro.data.dao.interfaces;
import se.su.dsv.scipro.data.dataobjects.HandInFeedback;
public interface HandInFeedbackDao extends Dao<HandInFeedback> {
}

@ -5,9 +5,6 @@ package se.su.dsv.scipro.data.dao.interfaces;
import java.util.List;
import org.springframework.stereotype.Repository;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.PrivateMessage;
import se.su.dsv.scipro.data.dataobjects.User;

@ -1,10 +0,0 @@
package se.su.dsv.scipro.data.dao.interfaces;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
public interface ProjectEventDao extends LazyDeleteDao<ProjectEvent> {
public int getProjectProgress(final Project project);
}

@ -3,9 +3,7 @@ package se.su.dsv.scipro.data.dao.jpa;
import org.springframework.stereotype.Repository;
import se.su.dsv.scipro.data.dao.interfaces.CheckListUploadDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInDao;
import se.su.dsv.scipro.data.dataobjects.CheckListUpload;
import se.su.dsv.scipro.data.dataobjects.HandIn;
@Repository("checkListUploadDao")
public class CheckListUploadDaoJPAImp extends AbstractDaoJPAImp<CheckListUpload> implements CheckListUploadDao {

@ -1,216 +0,0 @@
package se.su.dsv.scipro.data.dao.jpa;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import javax.persistence.TypedQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.jpa.JpaCallback;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import se.su.dsv.scipro.data.dao.interfaces.BaseEventDao;
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.ProjectEventDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.enums.EventStatus;
import edu.emory.mathcs.backport.java.util.Collections;
/**
* @author Martin Peters - mpeters@dsv.su.se
*
*/
@Repository("eventDao")
public class EventDaoJPAImp extends LazyDeleteAbstractDaoJPAImp<Event> implements EventDao {
@Autowired
private GroupEventDao groupEventDao;
@Autowired
private ProjectEventDao projectEventDao;
private ArrayList<BaseEventDao> subClassDaos = new ArrayList<BaseEventDao>();
public EventDaoJPAImp() {
super(Event.class);
}
@PostConstruct
public void initialize(){
subClassDaos.add((BaseEventDao)groupEventDao);
subClassDaos.add((BaseEventDao)projectEventDao);
}
@Transactional
private List<Event> getEvents(final User u, final Project p, final Date fromDate, final Date toDate,
final Integer limit) {
return getJpaTemplate().execute(new JpaCallback<List<Event>>() {
public List<Event> doInJpa(EntityManager em) throws PersistenceException {
List<Event> events = new ArrayList<Event>();
for(BaseEventDao d : subClassDaos){
events.addAll(d.getEventsByUserAndProject(u, p, fromDate, toDate, limit));
}
Collections.sort(events);
return events;
}
});
}
public List<Event> getEventsByUserAndProject(final User u, final Project p, final Date fromDate, final Date toDate,
final Integer limit){
return getEvents(u, p, fromDate, toDate, limit);
}
public List<Event> getAllEventsByUserAndProject(final User u, final Project p){
return getEvents(u, p, null, null, null);
}
public List<Event> getUpcomingEventsByUserAndProject(final User u, final Project p){
return getEvents(u, p, new Date(), null, null);
}
public List<Event> getUpcomingEventsByUserAndProject(final User u, final Project p, Integer limit){
return getEvents(u, p, new Date(), null, limit);
}
public Event getNextEvent(final User u, final Project p, final Event e) {
List<Event> list = getEvents(u, p, e.getDueDate() , null, 1);
if(list.size() == 0){
return null;
} else {
if(list.get(list.size() - 1).equals(e)){
return null;
} else {
return list.get(list.size() - 1);
}
}
}
@Transactional
public boolean hasHandInsInHandInActivity(final Event event) {
return getJpaTemplate().execute(new JpaCallback<Boolean>() {
public Boolean doInJpa(EntityManager em) throws PersistenceException {
if(event.getId() == null){
return false;
}
String q = "select case when count(hi) > 0 then true else false end " +
"from HandInActivity hia " +
"join hia.handIns hi " +
"where hia.event = :event ";
TypedQuery<Boolean> query = em.createQuery(q, Boolean.class);
query.setParameter("event", event);
return query.getSingleResult().booleanValue();
}
});
}
/**
* Method that checks whether an event is deletable or not. Subclasses of
* event can define their own behavior in this respect.
* @param event
* @param user the requesting user
* @return
*/
@Transactional
public boolean isDeletable(final Event event, final User user) {
return getJpaTemplate().execute(new JpaCallback<Boolean>() {
public Boolean doInJpa(EntityManager em) throws PersistenceException {
//First check if we need to use the query
if(!event.isDeletable(user)){
return false;
}
//If the subclass defines a query, run it, else the event is deletable
if(event.isDeletableQuery(em) == null){
return true;
}
return event.isDeletableQuery(em).getSingleResult().booleanValue();
}
});
}
/**
* Method that checks whether an event is editable or not. Subclasses of
* event can define their own behavior in this respect.
* @param event
* @param user the requesting user
* @return
*/
@Transactional
public boolean isEditable(final Event event, final User user) {
return getJpaTemplate().execute(new JpaCallback<Boolean>() {
public Boolean doInJpa(EntityManager em) throws PersistenceException {
//First check if we need to use the query
if(!event.isEditable(user)){
return false;
}
//If the subclass defines a query, run it, else the event is deletable
if(event.isEditableQuery(em) == null){
return true;
}
return event.isEditableQuery(em).getSingleResult().booleanValue();
}
});
}
/**
* Lazy delete an event. Please note that no check on whether the event is deletable is performed here,
* this need to be asserted before calling this method!
*/
@Transactional
public Event lazyDelete(final Event e){
if(e instanceof GroupEvent){
return groupEventDao.lazyDelete((GroupEvent)e);
} else if(e instanceof ProjectEvent){
return projectEventDao.lazyDelete((ProjectEvent) e);
}
return lazyDelete(e);
}
@Transactional
public boolean eventIsDone(final Event e, final User user, final Project project){
return getJpaTemplate().execute(new JpaCallback<Boolean>() {
public Boolean doInJpa(EntityManager em) throws PersistenceException {
EventStatus status = e.getEventStatus(user, project);
if(status == EventStatus.EVENT_WITHOUT_STATUS || status == EventStatus.NOT_DONE){
return false;
} else if(status == EventStatus.DETERMINE_BY_QUERY){
TypedQuery<Boolean> query = e.getEventStatusQuery(em, user, project);
if(query == null){
throw new IllegalStateException("If the status of an event is defined by a query you must provide a query");
} else {
return query.getSingleResult().booleanValue();
}
} else {
return true;
}
}
});
}
}

@ -1,179 +0,0 @@
package se.su.dsv.scipro.data.dao.jpa;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceException;
import javax.persistence.TypedQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.jpa.JpaCallback;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import se.su.dsv.scipro.data.dao.interfaces.BaseEventDao;
import se.su.dsv.scipro.data.dao.interfaces.GroupEventDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.enums.HandInStatus;
@Repository("groupEventDao")
public class GroupEventDaoJPAImp extends LazyDeleteAbstractDaoJPAImp<GroupEvent> implements GroupEventDao, BaseEventDao {
@Autowired
private HandInActivityDao handInActivityDao;
public GroupEventDaoJPAImp(){
super(GroupEvent.class);
}
@Override
@Transactional
public GroupEvent lazyDelete(GroupEvent e){
for(ProjectSchedule ps : e.getProjectSchedules()){
HandInActivity hia = handInActivityDao.getHandInActivity(e, ps.getProject());
if(hia != null){
/*
* TODO We don't actually create any folders before an actual HandIn is created,
* but we might still want to delete the path if it does exist for some reason.
* First we need to set up test environment for the file repository...
*/
handInActivityDao.delete(hia);
}
}
return super.lazyDelete(e);
}
@Transactional
public List<Event> getEventsByUserAndProject(final User u, final Project p, final Date fromDate, final Date toDate, final Integer limit) {
return getJpaTemplate().execute(new JpaCallback<List<Event>>() {
public List<Event> doInJpa(EntityManager em) throws PersistenceException {
String q = "select e " +
"from GroupEvent e " +
"join e.projectSchedules ps ";
String conditions = "where e.deleted = false " +
"and ps.project = :project ";
if(fromDate != null) {
conditions += "and e.dueDate >= :fromDate ";
}
if(toDate != null){
conditions += "and e.dueDate <= :toDate ";
}
String orderby = "order by e.dueDate asc ";
String geQueryString = q + conditions + orderby;
TypedQuery<Event> geQuery = em.createQuery(geQueryString, Event.class);
geQuery.setParameter("project", p);
if(fromDate != null) {
geQuery.setParameter("fromDate", fromDate);
}
if(toDate != null){
geQuery.setParameter("toDate", toDate);
}
try{
return geQuery.getResultList();
} catch (NoResultException e) {
return new ArrayList<Event>();
}
}
});
}
@Transactional
public List<GroupEvent> findGroupEventsByCreator(final User creator, final Date fromDate, final Date toDate, final Integer limit) {
return getJpaTemplate().execute(new JpaCallback<List<GroupEvent>>() {
public List<GroupEvent> doInJpa(EntityManager em) throws PersistenceException {
String q = "select e " +
"from GroupEvent e " +
"where e.deleted = false " +
"and e.creator = :creator ";
if(fromDate != null) {
q += "and e.dueDate >= :fromDate ";
}
if(toDate != null){
q += "and e.dueDate <= :toDate ";
}
q += "order by e.dueDate asc ";
TypedQuery<GroupEvent> query = em.createQuery(q, GroupEvent.class);
query.setParameter("creator", creator);
if(fromDate != null) {
query.setParameter("fromDate", fromDate);
}
if(toDate != null){
query.setParameter("toDate", toDate);
}
try{
return query.getResultList();
} catch (NoResultException e) {
return new ArrayList<GroupEvent>();
}
}
});
}
@Transactional
public List<GroupEvent> findGroupEventsWithAssignedFeedback(final User assignedUser, final HandInStatus status) {
return getJpaTemplate().execute(new JpaCallback<List<GroupEvent>>() {
public List<GroupEvent> doInJpa(EntityManager em) throws PersistenceException {
String q = "select e " +
"from GroupEvent e " +
"where e.deleted = false " +
"and 0 < (select count(hif) " +
"from HandInFeedback hif " +
"where hif.assignedTo = :assignedUser " +
"and hif.handIn.status = :status) ";
q += "order by e.dueDate asc ";
TypedQuery<GroupEvent> query = em.createQuery(q, GroupEvent.class);
query.setParameter("assignedUser", assignedUser);
query.setParameter("status", status);
try{
return query.getResultList();
} catch (NoResultException e) {
return new ArrayList<GroupEvent>();
}
}
});
}
public Integer getProjectProgress(final Project p){
return null;
}
}

@ -1,96 +0,0 @@
package se.su.dsv.scipro.data.dao.jpa;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceException;
import javax.persistence.TypedQuery;
import org.springframework.orm.jpa.JpaCallback;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.enums.HandInStatus;
@Repository("handInActivityDao")
public class HandInActivityDaoJPAImp extends LazyDeleteAbstractDaoJPAImp<HandInActivity>
implements HandInActivityDao {
public HandInActivityDaoJPAImp() {
super(HandInActivity.class);
}
@Transactional
public HandInActivity getHandInActivity(final Event event, final Project project) {
return getJpaTemplate().execute(new JpaCallback<HandInActivity>() {
public HandInActivity doInJpa(EntityManager em)
throws PersistenceException {
String q = "select a " +
"from HandInActivity a " +
"where a.project = :project " +
"and a.event = :event " +
"and a.deleted = false";
TypedQuery<HandInActivity> query = em.createQuery(q, HandInActivity.class);
query.setParameter("project", project);
query.setParameter("event", event);
try {
return query.getSingleResult();
} catch (NoResultException e) {
return null;
}
}
});
}
@Transactional
public List<HandInActivity> findHandInActivitiesWithAssignedFeedback(final User user, final Project project) {
return getJpaTemplate().execute(new JpaCallback<List<HandInActivity>>() {
public List<HandInActivity> doInJpa(EntityManager em)
throws PersistenceException {
HandInStatus status = HandInStatus.AWAITING_FEEDBACK;
String q = "select h " +
"from HandInActivity h " +
"join h.handIns hi " +
"where hi.status = :status " +
"and hi.feedback.assignedTo = :user ";
if(project != null){
q += "and h.project = :project ";
}
TypedQuery<HandInActivity> query = em.createQuery(q, HandInActivity.class);
query.setParameter("user", user);
query.setParameter("status", status);
if(project != null){
query.setParameter("project", project);
}
try {
return query.getResultList();
} catch (NoResultException e) {
return new ArrayList<HandInActivity>();
}
}
});
}
public List<HandInActivity> findHandInActivitiesWithAssignedFeedback(final User user){
return findHandInActivitiesWithAssignedFeedback(user, null);
}
}

@ -1,14 +0,0 @@
package se.su.dsv.scipro.data.dao.jpa;
import org.springframework.stereotype.Repository;
import se.su.dsv.scipro.data.dao.interfaces.HandInDao;
import se.su.dsv.scipro.data.dataobjects.HandIn;
@Repository("handInDao")
public class HandInDaoJPAImp extends AbstractDaoJPAImp<HandIn> implements HandInDao {
public HandInDaoJPAImp() {
super(HandIn.class);
}
}

@ -1,16 +0,0 @@
package se.su.dsv.scipro.data.dao.jpa;
import org.springframework.stereotype.Repository;
import se.su.dsv.scipro.data.dao.interfaces.HandInFeedbackDao;
import se.su.dsv.scipro.data.dataobjects.HandInFeedback;
@Repository("handInFeedbackDao")
public class HandInFeedbackDaoJPAImp extends AbstractDaoJPAImp<HandInFeedback>
implements HandInFeedbackDao {
public HandInFeedbackDaoJPAImp() {
super(HandInFeedback.class);
}
}

@ -1,158 +0,0 @@
package se.su.dsv.scipro.data.dao.jpa;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceException;
import javax.persistence.TypedQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.jpa.JpaCallback;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import se.su.dsv.scipro.data.dao.interfaces.BaseEventDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectEventDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.enums.HandInStatus;
@Repository("projectEventDao")
public class ProjectEventDaoJPAImp extends LazyDeleteAbstractDaoJPAImp<ProjectEvent> implements ProjectEventDao, BaseEventDao {
@Autowired
private HandInActivityDao handInActivityDao;
public ProjectEventDaoJPAImp() {
super(ProjectEvent.class);
}
@Override
@Transactional
public ProjectEvent lazyDelete(ProjectEvent e){
HandInActivity hia = handInActivityDao.getHandInActivity(e, e.getProjectSchedule().getProject());
if(hia != null){
/*
* TODO We don't actually create any folders before an actual HandIn is created,
* but we might still want to delete the path if it does exist for some reason.
* First we need to set up test environment for the file repository...
*/
handInActivityDao.delete(hia);
}
return super.lazyDelete(e);
}
@Transactional
public List<Event> getEventsByUserAndProject(final User u, final Project p, final Date fromDate, final Date toDate, final Integer limit) {
return getJpaTemplate().execute(new JpaCallback<List<Event>>() {
public List<Event> doInJpa(EntityManager em) throws PersistenceException {
String q = "select e " +
"from ProjectEvent e ";
String conditions = "where e.deleted = false " +
"and e.projectSchedule.project = :project ";
if(u != null){
q += ", User u " +
"join u.roles role " +
"join e.participants evPart ";
conditions += "and u = :user " +
"and evPart = role ";
}
if(fromDate != null) {
conditions += "and e.dueDate >= :fromDate ";
}
if(toDate != null){
conditions += "and e.dueDate <= :toDate ";
}
String orderby = "order by e.dueDate asc ";
String peQueryString = q + conditions + orderby;
TypedQuery<Event> query = em.createQuery(peQueryString, Event.class);
query.setParameter("project", p);
if(u != null){
query.setParameter("user", u);
}
if(fromDate != null) {
query.setParameter("fromDate", fromDate);
}
if(toDate != null){
query.setParameter("toDate", toDate);
}
try{
return query.getResultList();
} catch (NoResultException e) {
return new ArrayList<Event>();
}
}
});
}
@Transactional
public int getProjectProgress(final Project project) {
return getJpaTemplate().execute(new JpaCallback<Integer>() {
public Integer doInJpa(EntityManager em) throws PersistenceException {
String qAll = "select count(e) " +
"from ProjectEvent e "+
"where e.deleted = false " +
"and e.projectSchedule.project = :project ";
String qNoHandIn = "select count(e) " +
"from ProjectEvent e " +
"where e.projectSchedule.project = :project " +
"and e.done = true " +
"and e.deleted = false " +
"and 0 = (select count(h) " +
"from HandInActivity h " +
"where h.event = e " +
"and h.project = :project) ";
String qWithHandIn = "select count(e) " +
"from ProjectEvent e, HandInActivity h " +
"join h.handIns hi " +
"where h.project = :project " +
"and e.deleted = false " +
"and e = h.event " +
"and hi.status not in (:awaitingFeedbackStatus, :requireSupplementaryFeedbackStatus) ";
TypedQuery<Long> queryAll = em.createQuery(qAll, Long.class);
queryAll.setParameter("project", project);
TypedQuery<Long> queryNoHandIn = em.createQuery(qNoHandIn, Long.class);
queryNoHandIn.setParameter("project", project);
TypedQuery<Long> queryWithHandIn = em.createQuery(qWithHandIn, Long.class);
queryWithHandIn.setParameter("project", project);
queryWithHandIn.setParameter("awaitingFeedbackStatus", HandInStatus.AWAITING_FEEDBACK);
queryWithHandIn.setParameter("requireSupplementaryFeedbackStatus", HandInStatus.REQUIRE_SUPPLEMENT);
double countAll = queryAll.getSingleResult().doubleValue();
double countNoHandIn = queryNoHandIn.getSingleResult().doubleValue();
double countWithHandIn = queryWithHandIn.getSingleResult().doubleValue();
return (int) (((countNoHandIn + countWithHandIn) / countAll) * 100);
}
});
}
}

@ -1,235 +0,0 @@
package se.su.dsv.scipro.data.dataobjects;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.TypedQuery;
import org.apache.wicket.markup.html.panel.Panel;
import se.su.dsv.scipro.data.dataobjects.interfaces.Commentable;
import se.su.dsv.scipro.data.enums.EventStatus;
import se.su.dsv.scipro.schedule.baseevent.panels.EventScheduleDetailsPanel;
import se.su.dsv.scipro.util.IAjaxCallback;
/**
* Note that in order to get the handinactivities you need to use the method getHandInActivity(event, project)
* in HandInActivityDao
*
*
*
* @author Dan Kjellman - <dan-kjel@dsv.su.se>
*
*/
@Entity
@Inheritance(strategy=InheritanceType.JOINED)
@Table(name="event")
public abstract class Event extends LazyDeletableDomainObject
implements Comparable<Event>, Commentable {
private static final long serialVersionUID = 2959377496669050427L;
public static final String PP_EVENT_ID = "eid";
@Id
@GeneratedValue
private Long id;
@Column(nullable=false)
private String title;
@Lob
private String description;
@ManyToOne(optional=false)
private User creator;
@Column(nullable=false)
private Date dueDate;
@Column(nullable=false)
private boolean requireHandIn = false;
public Event() {}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTitle() {
return title;
}
public String getTitle(final int characters) {
String result = title;
if(title.length() > characters)
result = title.substring(0, characters)+"..";
return result;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Date getDueDate() {
return dueDate;
}
public void setDueDate(Date dueDate) {
this.dueDate = dueDate;
}
public void setCreator(User creator) {
this.creator = creator;
}
public User getCreator() {
return creator;
}
public void setRequireHandIn(boolean requireHandIn) {
this.requireHandIn = requireHandIn;
}
public boolean isRequireHandIn() {
return requireHandIn;
}
@Override
public int hashCode() {
final int weight = 31;
int result = 17;
result = weight * result + ((id == null) ? 0 : (int) (id ^ (id >>> 32)));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (obj instanceof Event){
Event other = (Event) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
return false;
}
@Override
public String toString() {
return getTitle();
}
@Override
public int compareTo(Event other) {
int dcomp = dueDate.compareTo(other.dueDate);
if (dcomp == 0){
if (id == null){
return -1;
}else if(other.id == null){
return 1;
}
else return id.compareTo(other.id);
}
return dcomp;
}
public Panel getDisplayPanel(String id){
return new EventScheduleDetailsPanel(id, this);
}
/*
* Methods needed in order to give a subclass default behavior in the schedule and in the EventPage
*/
public abstract Panel getCreationPanel(String id, final IAjaxCallback callback, final boolean isSupervisorView);
public abstract Panel getScheduleDetailsPanel(String id);
public abstract Panel getPageDetailsPanel(String id);
/**
* This method lets subclasses define a query in order to check whether
* the instance is deletable or not. This method is called by
* the EventDao in it's isDeleteable method. Note that if Event.isDeleteable returns
* false this method will not be run.
* @param em
* @return
*/
public TypedQuery<Boolean> isDeletableQuery(EntityManager em){
return null;
}
/**
* If you wish to use a query in order to check whether a event is editable
* then override this method in your subclass. This method is called by
* the EventDao in it's isEditable method. Note that if Event.isEditable returns
* false this method will not be run.
* @param em
* @return
*/
public TypedQuery<Boolean> isEditableQuery(EntityManager em){
return null;
}
/**
* Override this method for subclasses that needs specific logic to
* check if an instance is deletable or not. Do not forget to call super.isDeletable
* if you want the behavior from the baseclass. This method is called by EventDao.isDeletable.
* @return
*/
public boolean isDeletable(final User user){
return new Date().before(getDueDate());
}
/**
* Override this method for subclasses that needs specific logic to
* check if an instance is editable or not. Do not forget to call super.isEditable
* if you want the behavior from the baseclass. This method is called by EventDao.isDeletable.
* @return
*/
public boolean isEditable(final User user){
return new Date().before(getDueDate());
}
public abstract EventStatus getEventStatus(final User requester, final Project project);
public TypedQuery<Boolean> getEventStatusQuery(final EntityManager em, final User requester, final Project project){
return null;
}
final public String getCommentKey(){
return Event.class.getCanonicalName().toString();
}
}

@ -1,115 +0,0 @@
package se.su.dsv.scipro.data.dataobjects;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import javax.persistence.TypedQuery;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.markup.html.panel.Panel;
import se.su.dsv.scipro.data.enums.EventStatus;
import se.su.dsv.scipro.data.enums.HandInStatus;
import se.su.dsv.scipro.events.panels.GroupEventPageDetailsPanel;
import se.su.dsv.scipro.schedule.groupevent.panels.CreateGroupEventPanel;
import se.su.dsv.scipro.schedule.groupevent.panels.GroupEventScheduleDetailsPanel;
import se.su.dsv.scipro.util.IAjaxCallback;
@Entity
@Table(name="group_event")
public class GroupEvent extends Event {
private static final long serialVersionUID = 1027497624747494476L;
@ManyToMany
private List<ProjectSchedule> projectSchedules = new ArrayList<ProjectSchedule>();
public List<ProjectSchedule> getProjectSchedules() {
return new ArrayList<ProjectSchedule>(projectSchedules);
}
public void setProjectSchedules(List<ProjectSchedule> projectSchedules) {
this.projectSchedules = projectSchedules;
}
public void addProjectSchedule(ProjectSchedule ps){
projectSchedules.add(ps);
}
@Override
public Panel getCreationPanel(String id, final IAjaxCallback callback, final boolean isSupervisorView) {
return new CreateGroupEventPanel("containerContent", this, null, isSupervisorView){
private static final long serialVersionUID = 1L;
@Override
protected void onFormSubmit(AjaxRequestTarget target) {
callback.doCallback(target);
}
};
}
@Override
public Panel getScheduleDetailsPanel(String id) {
return new GroupEventScheduleDetailsPanel(id, this);
}
@Override
public Panel getPageDetailsPanel(String id) {
return new GroupEventPageDetailsPanel(id, this);
}
public TypedQuery<Boolean> isDeletableQuery(EntityManager em){
String q = "select case when count(hi) = 0 then true else false end " +
"from HandInActivity hia " +
"join hia.handIns hi " +
"where hia.event = :event ";
TypedQuery<Boolean> query = em.createQuery(q, Boolean.class);
query.setParameter("event", this);
return query;
}
public boolean isDeletable(final User user){
return user.equals(getCreator()) && super.isDeletable(user);
}
public boolean isEditable(final User user){
return user.equals(getCreator()) && super.isEditable(user);
}
/*
* A group event that doesn't require hand ins are considered done when the due date
* has passed for all involved groups...
*/
@Override
public EventStatus getEventStatus(User requester, Project project) {
if(isRequireHandIn()){
return EventStatus.DETERMINE_BY_QUERY;
} else {
return new Date().after(getDueDate()) ? EventStatus.DONE : EventStatus.NOT_DONE;
}
}
@Override
public TypedQuery<Boolean> getEventStatusQuery(final EntityManager em, final User requester, final Project project){
String q = "select case when count(hi) > 0 then true else false end " +
"from HandInActivity hia " +
"join hia.handIns hi " +
"where hia.event = :event " +
"and hia.project = :project " +
"and (hi.status = :approvedStatus " +
"or hi.status = :notApprovedStatus) ";
TypedQuery<Boolean> query = em.createQuery(q, Boolean.class);
query.setParameter("event", this);
query.setParameter("project", project);
query.setParameter("approvedStatus", HandInStatus.APPROVED);
query.setParameter("notApprovedStatus", HandInStatus.NOT_APPROVED);
return query;
}
}

@ -1,226 +0,0 @@
package se.su.dsv.scipro.data.dataobjects;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import org.apache.wicket.markup.html.panel.Panel;
import se.su.dsv.scipro.data.enums.HandInStatus;
import se.su.dsv.scipro.icons.IconPanel;
import se.su.dsv.scipro.icons.ImageIcon;
@Entity
@Table(name="hand_in")
public class HandIn extends DomainObject {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
private Long id;
@ManyToOne(optional=false)
private HandInActivity handInActivity;
@Column(nullable=false)
private boolean done;
private Date dueDate;
@OneToOne(mappedBy="handIn", orphanRemoval = true, cascade = CascadeType.REMOVE)
private HandInFeedback feedback;
@ManyToOne(optional=true)
private User handedInBy;
@Column(nullable=false)
private String folderName;
private Date handedInDate;
@Enumerated(EnumType.STRING)
private HandInStatus status = HandInStatus.AWAITING_FEEDBACK;
@OneToMany(orphanRemoval = true, cascade=CascadeType.REMOVE)
private List<FileDescription> files = new ArrayList<FileDescription>();
public HandIn(){}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public void setHandInActivity(HandInActivity handInActivity) {
this.handInActivity = handInActivity;
}
public HandInActivity getHandInActivity() {
return handInActivity;
}
public boolean isDone() {
return done;
}
public void setDone(boolean done) {
this.done = done;
}
public void setDueDate(Date dueDate) {
this.dueDate = dueDate;
}
public Date getDueDate() {
return dueDate;
}
public HandInFeedback getFeedback() {
return feedback;
}
public void setFeedback(HandInFeedback feedback) {
this.feedback = feedback;
}
public void setHandedInBy(User handedInBy) {
this.handedInBy = handedInBy;
}
public User getHandedInBy() {
return handedInBy;
}
public void setHandedInDate(Date handedInDate) {
this.handedInDate = handedInDate;
}
public Date getHandedInDate() {
return handedInDate;
}
public void setStatus(HandInStatus status) {
this.status = status;
}
public HandInStatus getStatus() {
return status;
}
public void setFiles(List<FileDescription> files) {
this.files = files;
}
public List<FileDescription> getFiles() {
return files;
}
public void setFolderName(String folderName) {
this.folderName = folderName;
}
public String getFolderName() {
return folderName + "/";
}
@Override
public int hashCode() {
final int weight = 31;
int result = 17;
result = weight * result + ((id == null) ? 0 : (int) (id ^ (id >>> 32)));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (this.getClass() != obj.getClass())
return false;
HandIn other = (HandIn) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
public Panel getStatusPanel(String id){
final String s = getStatus().toString().replace("_", " ").toLowerCase();
final String first = String.valueOf(s.charAt(0));
String icon = "";
switch(getStatus()){
case APPROVED:
icon = ImageIcon.ICON_YES;
break;
case NOT_APPROVED:
icon = ImageIcon.ICON_NO;
break;
case REQUIRE_SUPPLEMENT:
icon = ImageIcon.ICON_CIRCLE_YELLOW;
break;
default:
icon = ImageIcon.ICON_CLOCK;
}
return new IconPanel(id, icon){
private static final long serialVersionUID = 1L;
@Override
public String getDisplayString() {
return first.toUpperCase() + s.substring(1, s.length());
}
};
}
public ImageIcon getStatusIcon(String id){
final String s = getStatus().toString().replace("_", " ").toLowerCase();
final String first = String.valueOf(s.charAt(0));
String icon = "";
switch(getStatus()){
case APPROVED:
icon = ImageIcon.ICON_YES;
break;
case NOT_APPROVED:
icon = ImageIcon.ICON_NO;
break;
case REQUIRE_SUPPLEMENT:
icon = ImageIcon.ICON_CIRCLE_YELLOW;
break;
default:
icon = ImageIcon.ICON_CLOCK;
}
return new ImageIcon(id, icon, first.toUpperCase() + s.substring(1, s.length()));
}
}

@ -1,143 +0,0 @@
package se.su.dsv.scipro.data.dataobjects;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.PrePersist;
import javax.persistence.Table;
import javax.persistence.UniqueConstraint;
@Entity
@Table(name="hand_in_activity", uniqueConstraints={@UniqueConstraint(columnNames={"project_id","event_id"}, name = "hand_in_activity_is_unique")})
public class HandInActivity extends LazyDeletableDomainObject {
private static final long serialVersionUID = 1L;
public static final String DIRECTORY_PATH = "eventhandins/";
@Id
@GeneratedValue
private Long id;
@ManyToOne(optional=false)
@JoinColumn(name="project_id")
private Project project;
@ManyToOne(optional=false)
@JoinColumn(name="event_id")
private Event event;
@OneToMany(mappedBy="handInActivity")
private List<HandIn> handIns = new ArrayList<HandIn>(1);
@Column(nullable=false)
private String dirName = null;
public HandInActivity(){}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Project getProject() {
return project;
}
public void setProject(Project project) {
this.project = project;
}
public Event getEvent() {
return event;
}
public void setEvent(Event event) {
this.event = event;
}
public void setHandIns(List<HandIn> handIns) {
this.handIns = handIns;
}
public List<HandIn> getHandIns() {
return handIns;
}
public void setDirName(String dirName) {
this.dirName = dirName;
}
public String getDirName() {
return dirName;
}
public final String getFullDirectoryName(){
return getDirName() + "_" + getId() + "/";
}
@Override
public int hashCode() {
final int weight = 31;
int result = 17;
result = weight * result + ((id == null) ? 0 : (int) (id ^ (id >>> 32)));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (this.getClass() != obj.getClass())
return false;
HandInActivity other = (HandInActivity) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
@Override
public String toString() {
return String.valueOf(getId());
}
@PrePersist
public void checkDirectoryName(){
if(getDirName() == null){
setDirName(getUniqueDirectoryName());
}
}
private String getUniqueDirectoryName(){
String folderName = createFolderName(getEvent().getTitle());
return folderName;
}
private static String createFolderName(String str){
str = str.trim();
str = str.replaceAll(" ", "-");
str = str.replaceAll("[^a-zA-Z0-9-_]", "-");
str = str.replaceAll("(^[^A-Za-z0-9]+)|([^A-Za-z0-9]+$)", "");
return str;
}
}

@ -1,117 +0,0 @@
package se.su.dsv.scipro.data.dataobjects;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@Entity
@Table(name="hand_in_feedback")
public class HandInFeedback extends DomainObject {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
private Long id;
@OneToOne(optional=false)
private HandIn handIn;
@ManyToOne(optional=false)
private User assignedTo;
private Date checkedDate;
@ManyToOne(optional=true)
private User checkedBy;
@OneToMany
private List<FileDescription> files = new ArrayList<FileDescription>();
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public void setHandIn(HandIn handIn) {
this.handIn = handIn;
}
public HandIn getHandIn() {
return handIn;
}
public User getAssignedTo() {
return assignedTo;
}
public void setAssignedTo(User assignedTo) {
this.assignedTo = assignedTo;
}
public Date getCheckedDate() {
return checkedDate;
}
public void setCheckedDate(Date checkedDate) {
this.checkedDate = checkedDate;
}
public User getCheckedBy() {
return checkedBy;
}
public void setCheckedBy(User checkedBy) {
this.checkedBy = checkedBy;
}
public void setFiles(List<FileDescription> files) {
this.files = files;
}
public List<FileDescription> getFiles() {
return files;
}
@Override
public int hashCode() {
final int weight = 31;
int result = 17;
result = weight * result + ((id == null) ? 0 : (int) (id ^ (id >>> 32)));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (this.getClass() != obj.getClass())
return false;
HandInFeedback other = (HandInFeedback) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
}

@ -1,123 +0,0 @@
package se.su.dsv.scipro.data.dataobjects;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import javax.persistence.TypedQuery;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.Model;
import se.su.dsv.scipro.data.enums.EventStatus;
import se.su.dsv.scipro.data.enums.HandInStatus;
import se.su.dsv.scipro.events.panels.ProjectEventPageDetailsPanel;
import se.su.dsv.scipro.schedule.projectevent.panels.CreateProjectEventPanel;
import se.su.dsv.scipro.schedule.projectevent.panels.ProjectEventScheduleDetailsPanel;
import se.su.dsv.scipro.util.IAjaxCallback;
@Entity
@Table(name="project_event")
public class ProjectEvent extends Event {
private static final long serialVersionUID = 8183387004042966762L;
@ManyToOne(optional=false)
private ProjectSchedule projectSchedule;
@ManyToMany
@JoinTable(name="project_event_student")
private Set<Student> participants;
private boolean done = false;
public ProjectSchedule getProjectSchedule() {
return projectSchedule;
}
public void setProjectSchedule(ProjectSchedule projectSchedule) {
this.projectSchedule = projectSchedule;
}
public Set<Student> getParticipants() {
return participants;
}
public void setParticipants(Set<Student> participants) {
this.participants = participants;
}
public boolean isDone() {
return done;
}
public void setDone(boolean done) {
this.done = done;
}
@Override
public Panel getCreationPanel(String id, final IAjaxCallback callback, final boolean isSupervisorView) {
return new CreateProjectEventPanel(id, getProjectSchedule().getProject(), this, isSupervisorView){
private static final long serialVersionUID = 1L;
@Override
protected void onFormSubmit(AjaxRequestTarget target) {
callback.doCallback(target);
}
};
}
@Override
public Panel getScheduleDetailsPanel(String id) {
return new ProjectEventScheduleDetailsPanel(id, this);
}
@Override
public Panel getPageDetailsPanel(String id) {
return new ProjectEventPageDetailsPanel(id, new Model<ProjectEvent>(this));
}
public TypedQuery<Boolean> isDeletableQuery(final EntityManager em){
String q = "select case when count(hi) = 0 then true else false end " +
"from HandInActivity hia " +
"join hia.handIns hi " +
"where hia.event = :event ";
TypedQuery<Boolean> query = em.createQuery(q, Boolean.class);
query.setParameter("event", this);
return query;
}
public EventStatus getEventStatus(final User requester, final Project project){
if(isRequireHandIn()){
return EventStatus.DETERMINE_BY_QUERY;
} else {
return isDone() ? EventStatus.DONE : EventStatus.NOT_DONE;
}
}
public TypedQuery<Boolean> getEventStatusQuery(final EntityManager em, final User requester, final Project project){
String q = "select case when count(hi) > 0 then true else false end " +
"from HandInActivity hia " +
"join hia.handIns hi " +
"where hia.event = :event " +
"and (hi.status = :approvedStatus " +
"or hi.status = :notApprovedStatus) ";
TypedQuery<Boolean> query = em.createQuery(q, Boolean.class);
query.setParameter("event", this);
query.setParameter("approvedStatus", HandInStatus.APPROVED);
query.setParameter("notApprovedStatus", HandInStatus.NOT_APPROVED);
return query;
}
}

@ -4,8 +4,6 @@ import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
@ -164,13 +162,4 @@ public class ProjectEventTemplate extends DomainObject implements Comparable<Pro
public int compareTo(ProjectEventTemplate other){
return numberInOrder - other.numberInOrder;
}
public ProjectEvent createEventFromTemplate() {
ProjectEvent event = new ProjectEvent();
event.setDone(false);
event.setRequireHandIn(isRequireHandIn());
event.setTitle(getTitle());
event.setDescription(getDescription());
return event;
}
}

@ -9,7 +9,6 @@ import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
@ -29,12 +28,6 @@ public class ProjectSchedule extends DomainObject {
@GeneratedValue
private Long id;
@OneToMany(mappedBy="projectSchedule")
private Set<ProjectEvent> projectEvents = new TreeSet<ProjectEvent>();
@ManyToMany(mappedBy="projectSchedules")
private Set<GroupEvent> groupEvents = new TreeSet<GroupEvent>();
@OneToMany(mappedBy="projectSchedule",cascade=CascadeType.PERSIST)
private Set<ProjectScheduleEvent> events = new TreeSet<ProjectScheduleEvent>();
@ -71,22 +64,6 @@ public class ProjectSchedule extends DomainObject {
this.project = project;
}
public Set<ProjectEvent> getProjectEvents() {
return projectEvents;
}
public void setProjectEvents(Set<ProjectEvent> projectEvents) {
this.projectEvents = projectEvents;
}
public Set<GroupEvent> getGroupEvents() {
return groupEvents;
}
public void setGroupEvents(Set<GroupEvent> groupEvents) {
this.groupEvents = groupEvents;
}
public Set<ProjectScheduleEvent> getEvents() {
return events;
}

@ -1,44 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<h2 class="bold" wicket:id="eventTitle">Event title</h2>
<div class="span-22 last append-bottom">
<strong>Date of event:</strong>
<div>
<span wicket:id="eventDueDate">Date of event</span>
</div>
</div>
<div class="span-14 last append-bottom">
<strong>Description:</strong>
<div>
<span wicket:id="eventDescription"></span>
</div>
</div>
<div class="span-22 last append-bottom">
<strong>Creator:</strong>
<div>
<span wicket:id="eventCreator"></span>
</div>
</div>
<div wicket:id="classSpecificDetails" class="span-22 last append-bottom"></div>
<div class="span-22 last append-bottom">
<h5 class="peer-title">Hand ins</h5>
<a href="#" wicket:id="groupEventPageLink">Hand ins for all groups in this event</a>
<div class="span-22 last">
<i><span wicket:id="noHandInMessage"></span></i>
</div>
<div class="span-18 last append-bottom prepend-top prepend-2" wicket:id="handInInfoPanel"></div>
<div class="span-22 last" wicket:id="handInPanel"></div>
</div>
<div class="span-22 last append-bottom">
<h5 class="peer-title">Comments</h5>
<div wicket:id="commentsPanel" class="span-22 last append-bottom"></div>
</div>
</wicket:panel>
</body>
</html>

@ -1,106 +0,0 @@
package se.su.dsv.scipro.events.panels;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.link.BookmarkablePageLink;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.commentthread.panels.CommentThreadPanel;
import se.su.dsv.scipro.components.ExpandableMultiLineLabel;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.events.panels.handins.HandInInfoPanel;
import se.su.dsv.scipro.events.panels.handins.HandInPanel;
import se.su.dsv.scipro.supervisor.pages.SupervisorGroupEventPage;
import se.su.dsv.scipro.util.DateFormatter;
public abstract class EventPagePanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
protected EventDao eventDao;
@SpringBean
protected ProjectDao projectDao;
@SpringBean
protected HandInActivityDao handInActivityDao;
private Event event;
private Project project;
public EventPagePanel(final String id, Event e, Project p, final boolean isSupervisorView) {
super(id);
project = projectDao.reLoad(p);
event = eventDao.reLoad(e);
add(new Label("eventTitle", event.getTitle()));
add(new DateFormatter().createFormattedDateLabel("eventDueDate", event.getDueDate()));
add(event.getCreator().getDisplayComponent("eventCreator"));
String desc = event.getDescription() == null ? "This event has no description" : event.getDescription();
add(new ExpandableMultiLineLabel("eventDescription", 200, desc, true));
add(event.getPageDetailsPanel("classSpecificDetails"));
final HandInActivity handInActivity = handInActivityDao.getHandInActivity(event, project);
add(new Label("noHandInMessage", "This event does not require hand in"){
private static final long serialVersionUID = 1L;
public boolean isVisible(){
return handInActivity == null;
}
});
PageParameters groupEventPP = new PageParameters();
groupEventPP.put(Event.PP_EVENT_ID, event.getId());
add(new BookmarkablePageLink<SupervisorGroupEventPage>("groupEventPageLink", SupervisorGroupEventPage.class, groupEventPP){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return projectDao.isSupervisorOrFollowerOf(SciProSession.get().getUser(), project) && event instanceof GroupEvent;
}
});
if(handInActivity == null){
add(new EmptyPanel("handInPanel"));
add(new EmptyPanel("handInInfoPanel"));
} else {
add(new HandInPanel("handInPanel", handInActivity, isSupervisorView){
private static final long serialVersionUID = 1L;
@Override
public Class<? extends Page> getResponsePageClass() {
return getSurroundingPageClass();
}
@Override
public PageParameters getResponsePageParameters() {
PageParameters pp = new PageParameters();
pp.put(Project.PP_PROJECT_ID, project.getId());
pp.put(Event.PP_EVENT_ID, event.getId());
return pp;
}
});
add(new HandInInfoPanel("handInInfoPanel"));
}
add(new CommentThreadPanel("commentsPanel", event, 10));
}
public abstract Class<? extends Page> getSurroundingPageClass();
}

@ -1,8 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div wicket:id="scheduleDetailsPanel"></div>
</wicket:panel>
</body>
</html>

@ -1,16 +0,0 @@
package se.su.dsv.scipro.events.panels;
import org.apache.wicket.markup.html.panel.Panel;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
public class GroupEventPageDetailsPanel extends Panel {
private static final long serialVersionUID = 1L;
public GroupEventPageDetailsPanel(final String id, final GroupEvent event){
super(id);
add(event.getScheduleDetailsPanel("scheduleDetailsPanel"));
}
}

@ -1,17 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div wicket:id="scheduleDetailsPanel" class="append-bottom"></div>
<div>
<strong>Event Status:</strong>
</div>
<div wicket:id="doneContainer" class="append-bottom">
<strong wicket:id="doneMsg">Done: </strong><input type="checkbox" wicket:id="statusCb" />
</div>
<div wicket:id="statusContainer" class="append-bottom">
<img wicket:id="statusIcon" /> <span wicket:id="statusMessage"></span>
</div>
</wicket:panel>
</body>
</html>

@ -1,79 +0,0 @@
package se.su.dsv.scipro.events.panels;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.Model;
import org.apache.wicket.model.PropertyModel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.components.IndicatingAjaxCheckBox;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectEventDao;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.icons.ImageIcon;
public class ProjectEventPageDetailsPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private ProjectEventDao projectEventDao;
@SpringBean
private EventDao eventDao;
public ProjectEventPageDetailsPanel(final String id, final Model<ProjectEvent> model){
super(id, model);
add(model.getObject().getScheduleDetailsPanel("scheduleDetailsPanel"));
final WebMarkupContainer statusContainer = new WebMarkupContainer("statusContainer") {
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return model.getObject().isRequireHandIn();
}
};
if(model.getObject().isRequireHandIn() &&
eventDao.eventIsDone(model.getObject(), null, model.getObject().getProjectSchedule().getProject())){
statusContainer.add(new ImageIcon("statusIcon", ImageIcon.ICON_CHECK));
statusContainer.add(new Label("statusMessage", "Supervisor feedback provided"));
} else {
statusContainer.add(new ImageIcon("statusIcon", ImageIcon.ICON_CLOCK));
statusContainer.add(new Label("statusMessage", "Waiting for hand in to be completed"));
}
add(statusContainer);
final WebMarkupContainer doneContainer = new WebMarkupContainer("doneContainer"){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return !model.getObject().isRequireHandIn();
}
};
IndicatingAjaxCheckBox statusCheckBox = new IndicatingAjaxCheckBox("statusCb", new PropertyModel<Boolean>(model.getObject(), "done")) {
private static final long serialVersionUID = 1L;
@Override
protected void onUpdate(AjaxRequestTarget target) {
model.setObject(projectEventDao.save(model.getObject()));
}
};
doneContainer.add(statusCheckBox);
doneContainer.add(new Label("doneMsg", "Done: "));
add(doneContainer);
}
}

@ -1,20 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div>
<i><span wicket:id="noTasksMsg"></span></i>
</div>
<div>
<ul class="no-list-style">
<li wicket:id="taskList">
<a href="#" wicket:id="eventLink">
<span wicket:id="eventTitle"></span>
<span> (<span wicket:id="projectTitle"></span>)</span>
</a>
</li>
</ul>
</div>
</wicket:panel>
</body>
</html>

@ -1,82 +0,0 @@
package se.su.dsv.scipro.events.panels;
import java.util.List;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.link.BookmarkablePageLink;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.LoadableDetachableModel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.supervisor.pages.SupervisorEventPage;
public class SupervisorFeedbackTasksPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private HandInActivityDao handInActivityDao;
public SupervisorFeedbackTasksPanel(String id, final User user){
this(id, user, null);
}
public SupervisorFeedbackTasksPanel(String id, final User user, final Project project) {
super(id);
final LoadableDetachableModel<List<HandInActivity>> model = new LoadableDetachableModel<List<HandInActivity>>(){
private static final long serialVersionUID = 1L;
@Override
protected List<HandInActivity> load() {
return handInActivityDao.findHandInActivitiesWithAssignedFeedback(user, project);
}
};
final ListView<HandInActivity> taskList = new ListView<HandInActivity>("taskList", model){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<HandInActivity> item) {
final HandInActivity h = item.getModelObject();
final PageParameters pp = new PageParameters();
pp.put(Event.PP_EVENT_ID, h.getEvent().getId());
final BookmarkablePageLink<Void> link = new BookmarkablePageLink<Void>("eventLink", getEventPageClass(), pp);
link.add(new Label("eventTitle", h.getEvent().getTitle(30)));
link.add(new Label("projectTitle", h.getProject().getTitle(30)));
item.add(link);
add(item);
}
};
add(taskList);
add(new Label("noTasksMsg", "No feedback tasks found"){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return taskList.size() == 0;
}
});
}
protected Class<? extends Page> getEventPageClass(){
return SupervisorEventPage.class;
}
}

@ -1,34 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div class="append-bottom" wicket:id="createLink"></div>
<div wicket:id="upcomingListContainer">
<div>
<i><span wicket:id="noEventsFoundMsg"></span></i>
</div>
<table>
<tr wicket:id="upcompingEvents">
<td wicket:id="eventDate"></td>
<td>
<a href="#" wicket:id="eventLink">
<span wicket:id="eventTitle"></span>
</a>
</td>
<td>
<img wicket:id="editLink" />
</td>
<td>
<img wicket:id="deleteLink" />
</td>
</tr>
</table>
</div>
<div wicket:id="dialog">
<div wicket:id="dialogContent">
<div wicket:id="formPanel"></div>
</div>
</div>
</wicket:panel>
</body>
</html>

@ -1,152 +0,0 @@
package se.su.dsv.scipro.events.panels;
import java.util.Date;
import java.util.List;
import org.apache.wicket.PageParameters;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.link.BookmarkablePageLink;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.LoadableDetachableModel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.odlabs.wiquery.ui.dialog.Dialog;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.GroupEventDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.icons.AjaxActionIcon;
import se.su.dsv.scipro.icons.ImageIcon;
import se.su.dsv.scipro.icons.ImageObject;
import se.su.dsv.scipro.schedule.groupevent.panels.CreateGroupEventLinkPanel;
import se.su.dsv.scipro.schedule.groupevent.panels.CreateGroupEventPanel;
import se.su.dsv.scipro.supervisor.pages.SupervisorGroupEventPage;
import se.su.dsv.scipro.util.DateFormatter;
public class SupervisorGroupEventsPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private GroupEventDao groupEventDao;
@SpringBean
private EventDao eventDao;
public SupervisorGroupEventsPanel(String id, final User creator) {
super(id);
final WebMarkupContainer dialogContent = new WebMarkupContainer("dialogContent");
dialogContent.setOutputMarkupId(true);
dialogContent.add(new EmptyPanel("formPanel"));
final Dialog dialog = new Dialog("dialog");
dialog.setOutputMarkupId(true);
dialog.setModal(true);
dialog.setAutoOpen(false);
dialog.add(dialogContent);
dialog.setWidth(600);
dialog.setHeight(450);
dialog.setTitle("Edit Group Event");
add(dialog);
final WebMarkupContainer upcomingListContainer = new WebMarkupContainer("upcomingListContainer");
upcomingListContainer.setOutputMarkupId(true);
final LoadableDetachableModel<List<GroupEvent>> listModel = new LoadableDetachableModel<List<GroupEvent>>(){
private static final long serialVersionUID = 1L;
@Override
protected List<GroupEvent> load() {
return groupEventDao.findGroupEventsByCreator(creator, new Date(), null, null);
}
};
final ListView<GroupEvent> upcomingEvents = new ListView<GroupEvent>("upcompingEvents", listModel){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<GroupEvent> item) {
final GroupEvent ge = item.getModelObject();
PageParameters pp = new PageParameters();
pp.put(Event.PP_EVENT_ID, ge.getId());
BookmarkablePageLink<SupervisorGroupEventPage> eventLink =
new BookmarkablePageLink<SupervisorGroupEventPage>("eventLink", SupervisorGroupEventPage.class, pp);
eventLink.add(new Label("eventTitle", ge.getTitle()));
item.add(new DateFormatter().createFormattedDateLabel("eventDate", ge.getDueDate()));
item.add(eventLink);
// item.add(new AjaxActionIcon("editLink", ImageIcon.ICON_EDIT, "edit") {
item.add(new AjaxActionIcon("editLink", ImageObject.TWENTYFOUR + ImageObject.EDIT) {
private static final long serialVersionUID = 1L;
@Override
protected void onClick(AjaxRequestTarget target) {
dialogContent.replace(new CreateGroupEventPanel("formPanel", ge, true) {
private static final long serialVersionUID = 1L;
@Override
protected void onFormSubmit(AjaxRequestTarget target) {
target.addComponent(upcomingListContainer);
dialog.close(target);
}
});
target.addComponent(dialogContent);
dialog.open(target);
}
});
// AjaxActionIcon deleteIcon = new AjaxActionIcon("deleteLink", ImageIcon.ICON_DELETE, "delete") {
AjaxActionIcon deleteIcon = new AjaxActionIcon("deleteLink", ImageObject.TWENTYFOUR + ImageObject.DELETE) {
private static final long serialVersionUID = 1L;
@Override
protected void onClick(AjaxRequestTarget target) {
groupEventDao.delete(groupEventDao.reLoad(ge));
target.addComponent(upcomingListContainer);
}
@Override
public boolean isVisible(){
return eventDao.isDeletable(ge, creator);
}
};
item.add(deleteIcon);
add(item);
}
};
upcomingListContainer.add(upcomingEvents);
upcomingListContainer.add(new Label("noEventsFoundMsg", "No events found"){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return upcomingEvents.size() == 0;
}
});
add(upcomingListContainer);
add(new CreateGroupEventLinkPanel("createLink"){
private static final long serialVersionUID = 1L;
@Override
protected void onFormSubmit(AjaxRequestTarget target) {
target.addComponent(upcomingListContainer);
}
});
}
}

@ -1,34 +0,0 @@
package se.su.dsv.scipro.events.panels.handins;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.HandInDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInFeedbackDao;
import se.su.dsv.scipro.data.dataobjects.HandIn;
public abstract class AbstractFeedbackFormPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
protected HandInDao handInDao;
@SpringBean
protected HandInFeedbackDao handInFeedbackDao;
protected HandIn handIn;
protected Class<? extends Page> responsePageClass;
protected PageParameters responsePageParams;
public AbstractFeedbackFormPanel(final String id, final HandIn hi,
Class<? extends Page> responsePageClass, final PageParameters responsePageParams){
super(id);
this.handIn = handInDao.reLoad(hi);
this.responsePageClass = responsePageClass;
this.responsePageParams = responsePageParams;
}
}

@ -1,64 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div class="span-10 colborder">
<table>
<tr>
<td><strong>Handed in by: </strong></td>
<td><span wicket:id="handedInBy">The user</span></td>
</tr>
<tr>
<td><strong>Status</strong></td>
<td wicket:id="handInStatus"></td>
</tr>
<tr>
<td><strong>Feedback assigned to: </strong></td>
<td><span wicket:id="assignedSupervisor">The supervisor</span></td>
</tr>
<tr>
<td>
<strong>Attached files:</strong>
</td>
<td>
<table>
<tr wicket:id="handInFiles">
<td><span wicket:id="fileName"></span></td>
<td><a href="#" wicket:id="open"><img wicket:id="openIcon" alt="Open/Preview"/></a></td>
<td><a href="#" wicket:id="download"><img wicket:id="downloadIcon" alt="Download"/></a></td>
</tr>
</table>
</td>
</tr>
</table>
</div>
<div class="span-10 last">
<table wicket:id="feedbackContainer">
<tr>
<td><strong>Feedback provided by: </strong></td>
<td><span wicket:id="feedbackProvider">The supervisor</span></td>
</tr>
<tr>
<td><strong>Date: </strong></td>
<td><span wicket:id="feedbackDate">The Feedback date</span></td>
</tr>
<tr>
<td>
<strong>Feedback files:</strong>
</td>
<td>
<table>
<tr wicket:id="feedbackFiles">
<td><span wicket:id="fileName"></span></td>
<td><a href="#" wicket:id="open"><img wicket:id="openIcon" alt="Open/Preview"/></a></td>
<td><a href="#" wicket:id="download"><img wicket:id="downloadIcon" alt="Download"/></a></td>
</tr>
</table>
</td>
</tr>
</table>
</div>
<div wicket:id="handInFeedbackLink" class="span-22 last"></div>
</wicket:panel>
</body>
</html>

@ -1,108 +0,0 @@
package se.su.dsv.scipro.events.panels.handins;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.RestartResponseException;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.pages.InternalErrorPage;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.HandInDao;
import se.su.dsv.scipro.data.dataobjects.FileDescription;
import se.su.dsv.scipro.data.dataobjects.HandIn;
import se.su.dsv.scipro.data.enums.HandInStatus;
import se.su.dsv.scipro.icons.ImageObject;
import se.su.dsv.scipro.repository.FileRepository;
import se.su.dsv.scipro.repository.components.FileDownloadLink;
import se.su.dsv.scipro.repository.components.FileOpenLink;
import se.su.dsv.scipro.util.DateFormatter;
public abstract class HandInDetailsPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private HandInDao handInDao;
@SpringBean
private FileRepository fileRepository;
private HandIn handIn;
public HandInDetailsPanel(final String id, final HandIn hi, final boolean isSupervisorView){
super(id);
handIn = handInDao.reLoad(hi);
if(handIn == null){
throw new RestartResponseException(InternalErrorPage.class);
}
add(handIn.getHandedInBy().getDisplayComponent("handedInBy"));
add(handIn.getStatusPanel("handInStatus"));
add(new ListView<FileDescription>("handInFiles", handIn.getFiles()){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<FileDescription> fileItem) {
final FileDescription fd = fileItem.getModelObject();
fileItem.add(new Label("fileName", fd.getName()));
fileItem.add(new FileDownloadLink("download", fileItem.getModel() ).add(new ImageObject("downloadIcon", ImageObject.SIXTEEN + ImageObject.DOCUMENT_DOWN)));
fileItem.add(new FileOpenLink("open", fileItem.getModel()).add(new ImageObject("openIcon", ImageObject.SIXTEEN + ImageObject.DOCUMENT_VIEW)));
add(fileItem);
}
});
add(hi.getFeedback().getAssignedTo().getDisplayComponent("assignedSupervisor"));
WebMarkupContainer feedbackContainer = new WebMarkupContainer("feedbackContainer"){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return hi.getFeedback().getCheckedDate() != null;
}
};
feedbackContainer.add(new DateFormatter().createFormattedDateLabel("feedbackDate", hi.getFeedback().getCheckedDate()));
Panel feedbackProviderPanel = null;
if(hi.getFeedback().getCheckedBy() != null){
feedbackProviderPanel = hi.getFeedback().getCheckedBy().getDisplayComponent("feedbackProvider");
} else {
feedbackProviderPanel = new EmptyPanel("feedbackProvider");
}
feedbackContainer.add(feedbackProviderPanel);
feedbackContainer.add(new ListView<FileDescription>("feedbackFiles", hi.getFeedback().getFiles()){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<FileDescription> item) {
final FileDescription fd = item.getModelObject();
item.add(new Label("fileName", fd.getName()));
item.add(new FileDownloadLink("download", item.getModel() ).add(new ImageObject("downloadIcon", ImageObject.SIXTEEN + ImageObject.DOCUMENT_DOWN)));
item.add(new FileOpenLink("open", item.getModel()).add(new ImageObject("openIcon", ImageObject.SIXTEEN + ImageObject.DOCUMENT_VIEW)));
add(item);
}
});
add(feedbackContainer);
add(new HandInFeedbackPanel("handInFeedbackLink", hi, getResponsePageClass(), getResponsePageParameters()){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return hi.getStatus() == HandInStatus.AWAITING_FEEDBACK && isSupervisorView;
}
});
}
public abstract Class<? extends Page> getResponsePageClass();
public abstract PageParameters getResponsePageParameters();
}

@ -1,24 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<a href="#" wicket:id="sendFeedbackLink" class="button">Send feedback
</a>
<a href="#" wicket:id="reassignFeedbackLink" class="button">Reassign feedback
</a>
<div wicket:id="sendFeedbackDialog">
<div wicket:id="sendFeedbackDialogContainer">
<div wicket:id="sendFeedbackDialogContent"></div>
</div>
</div>
<div wicket:id="reassignFeedbackDialog">
<div wicket:id="reassignFeedbackDialogContainer">
<div wicket:id="reassignFeedbackDialogContent"></div>
</div>
</div>
</wicket:panel>
</body>
</html>

@ -1,90 +0,0 @@
package se.su.dsv.scipro.events.panels.handins;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.ajax.markup.html.AjaxLink;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.Model;
import org.odlabs.wiquery.ui.dialog.Dialog;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.data.dataobjects.HandIn;
import se.su.dsv.scipro.data.dataobjects.User;
public class HandInFeedbackPanel extends Panel {
private static final long serialVersionUID = 1L;
public HandInFeedbackPanel(final String id, final HandIn hi,
final Class<? extends Page> responsePageClass, final PageParameters responsePageParams){
super(id);
final WebMarkupContainer sendFeedbackDialogContainer = new WebMarkupContainer("sendFeedbackDialogContainer");
sendFeedbackDialogContainer.setOutputMarkupId(true);
sendFeedbackDialogContainer.add(new EmptyPanel("sendFeedbackDialogContent"));
final Dialog sendFeedbackDialog = new Dialog("sendFeedbackDialog");
sendFeedbackDialog.setModal(true);
sendFeedbackDialog.setAutoOpen(false);
sendFeedbackDialog.setWidth(600);
sendFeedbackDialog.setTitle(new Model<String>("Send feedback"));
sendFeedbackDialog.add(sendFeedbackDialogContainer);
add(sendFeedbackDialog);
AjaxLink<Void> sendFeedbackLink = new AjaxLink<Void>("sendFeedbackLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick(AjaxRequestTarget target) {
sendFeedbackDialogContainer.replace(new SendFeedbackFormPanel("sendFeedbackDialogContent",
hi, responsePageClass, responsePageParams));
target.addComponent(sendFeedbackDialogContainer);
sendFeedbackDialog.open(target);
}
@Override
public boolean isVisible(){
return hi.getFeedback().getAssignedTo().equals(SciProSession.get().getUser());
}
};
add(sendFeedbackLink);
final WebMarkupContainer reassignFeedbackDialogContainer = new WebMarkupContainer("reassignFeedbackDialogContainer");
reassignFeedbackDialogContainer.setOutputMarkupId(true);
reassignFeedbackDialogContainer.add(new EmptyPanel("reassignFeedbackDialogContent"));
final Dialog reassignFeedbackDialog = new Dialog("reassignFeedbackDialog");
reassignFeedbackDialog.setModal(true);
reassignFeedbackDialog.setAutoOpen(false);
reassignFeedbackDialog.setWidth(600);
reassignFeedbackDialog.add(reassignFeedbackDialogContainer);
reassignFeedbackDialog.setTitle(new Model<String>("Reassign feedback"));
add(reassignFeedbackDialog);
AjaxLink<Void> reassignFeedbackLink = new AjaxLink<Void>("reassignFeedbackLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick(AjaxRequestTarget target) {
reassignFeedbackDialogContainer.replace(new ReassignFeedbackFormPanel("reassignFeedbackDialogContent",
hi, responsePageClass, responsePageParams));
target.addComponent(reassignFeedbackDialogContainer);
reassignFeedbackDialog.open(target);
}
@Override
public boolean isVisible(){
User loggedInUser = SciProSession.get().getUser();
User assignedUser = hi.getFeedback().getAssignedTo();
return assignedUser.equals(loggedInUser) ||
hi.getHandInActivity().getProject().getHeadSupervisor().getUser().equals(loggedInUser);
}
};
add(reassignFeedbackLink);
}
}

@ -1,19 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div class="span-10 last">
<i><p>This event requires a to hand in, select the files you want to hand in.</p></i>
<form wicket:id="handInForm">
<div wicket:id="feedbackPanel"></div>
<div wicket:id="fileInput"></div>
<div>
<button type="submit" wicket:id="submitHandIn" class="button">
I'm done, hand it in!
</button>
</div>
</form>
</div>
</wicket:panel>
</body>
</html>

@ -1,76 +0,0 @@
package se.su.dsv.scipro.events.panels.handins;
import java.util.ArrayList;
import java.util.Collection;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.form.Button;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.form.upload.FileUpload;
import org.apache.wicket.markup.html.form.upload.MultiFileUploadField;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.PropertyModel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.components.FormFeedbackPanel;
import se.su.dsv.scipro.data.controllers.HandInController;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.project.pages.ProjectEventPage;
public class HandInFormPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private HandInController handInController;
private Event event;
private Project project;
public HandInFormPanel(final String id, final Event event, final Project project){
super(id);
this.event = event;
this.project = project;
add(new HandInForm("handInForm"));
}
private class HandInForm extends Form<Void> {
private static final long serialVersionUID = 1L;
private final Collection<FileUpload> uploads = new ArrayList<FileUpload>();
private FormFeedbackPanel<Void> feedbackPanel;
public HandInForm(final String id){
super(id);
setMultiPart(true);
MultiFileUploadField mfu = new MultiFileUploadField("fileInput",
new PropertyModel<Collection<FileUpload>>(this, "uploads"), 5);
mfu.setRequired(true);
add(mfu);
feedbackPanel = new FormFeedbackPanel<Void>("feedbackPanel", this);
add(feedbackPanel);
add(new Button("submitHandIn"){
private static final long serialVersionUID = 1L;
@Override
public void onSubmit(){
if(handInController.store(project, event, uploads)){
final PageParameters pp = new PageParameters();
pp.put(Project.PP_PROJECT_ID, project.getId());
pp.put(Event.PP_EVENT_ID, event.getId());
setResponsePage(ProjectEventPage.class, pp);
} else {
error("An error occured, please try again");
}
}
});
}
}
}

@ -1,23 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div class="info-box rounded-box">
<div class="span-6 colborder">
<ul>
<li>Your handed in files are accessible from here, or in the files view of your project</li>
<li>After you've hand in the files will be presented to your supervisor for review</li>
</ul>
</div>
<div class="span-7 last">
<ul class="no-list-style">
<li><img wicket:id="awaitingFeedbackIcon" /> Awaiting feedback</li>
<li><img wicket:id="approvedFeedbackIcon" /> Approved</li>
<li><img wicket:id="notApprovedFeedbackIcon" /> Not approved</li>
<li><img wicket:id="notApprovedWithSupplementFeedbackIcon" /> Not approved, another hand in is required</li>
</ul>
</div>
</div>
</wicket:panel>
</body>
</html>

@ -1,19 +0,0 @@
package se.su.dsv.scipro.events.panels.handins;
import org.apache.wicket.markup.html.panel.Panel;
import se.su.dsv.scipro.icons.ImageIcon;
public class HandInInfoPanel extends Panel {
private static final long serialVersionUID = 1L;
public HandInInfoPanel(final String id){
super(id);
//For the explanations of statuses
add(new ImageIcon("awaitingFeedbackIcon", ImageIcon.ICON_CLOCK));
add(new ImageIcon("approvedFeedbackIcon", ImageIcon.ICON_YES));
add(new ImageIcon("notApprovedFeedbackIcon", ImageIcon.ICON_NO));
add(new ImageIcon("notApprovedWithSupplementFeedbackIcon", ImageIcon.ICON_CIRCLE_YELLOW));
}
}

@ -1,21 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div wicket:id="handInTabs" class="span-22 last">
<ul>
<li wicket:id="tabList">
<a wicket:id="handInTabLink"><img wicket:id="linkStatusIcon" /> <span wicket:id="linkHandedInDate"></span></a>
</li>
</ul>
<div wicket:id="tabContainerList">
<div wicket:id="handInDetailsPanel"></div>
</div>
</div>
<div>
<i><span wicket:id="noHeadSupervisorMsg"></span></i>
<div wicket:id="handInForm" class="span-22 prepend-top append-bottom"></div>
</div>
</wicket:panel>
</body>
</html>

@ -1,138 +0,0 @@
package se.su.dsv.scipro.events.panels.handins;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.behavior.SimpleAttributeModifier;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.Model;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.odlabs.wiquery.ui.tabs.Tabs;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dataobjects.HandIn;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.enums.HandInStatus;
import se.su.dsv.scipro.util.DateFormatter;
public abstract class HandInPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private HandInActivityDao handInActivityDao;
private boolean showHandInForm = false;
public HandInPanel(final String id, final HandInActivity hia, final boolean isSupervisorView){
super(id);
final HandInActivity handInActivity = handInActivityDao.reLoad(hia);
//Check if we want to show the form for creating a new hand in
if(!isSupervisorView){
if(handInActivity.getHandIns().size() == 0){
showHandInForm = true;
} else {
HandIn latest = handInActivity.getHandIns().get(handInActivity.getHandIns().size() - 1);
if(latest.getStatus() == HandInStatus.REQUIRE_SUPPLEMENT){
showHandInForm = true;
}
}
}
//Container for the tabs
Tabs handInTabs = new Tabs("handInTabs"){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return handInActivity.getHandIns().size() > 0;
}
};
//Content of each tab
final List<HandInDetailsPanel> panels = new ArrayList<HandInDetailsPanel>();
final ListView<HandIn> tabContainerList = new ListView<HandIn>("tabContainerList", handInActivity.getHandIns()){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<HandIn> item) {
final HandIn hi = item.getModelObject();
HandInDetailsPanel detailsPanel = new HandInDetailsPanel("handInDetailsPanel", hi, isSupervisorView){
private static final long serialVersionUID = 1L;
@Override
public Class<? extends Page> getResponsePageClass() {
return HandInPanel.this.getResponsePageClass();
}
@Override
public PageParameters getResponsePageParameters() {
return HandInPanel.this.getResponsePageParameters();
}
};
panels.add(detailsPanel);
detailsPanel.setOutputMarkupId(true);
item.add(detailsPanel);
item.setOutputMarkupId(true);
add(item);
}
};
//The actual tabs
ListView<HandIn> tabList = new ListView<HandIn>("tabList", handInActivity.getHandIns()){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<HandIn> item) {
final HandIn hi = item.getModelObject();
//Create the link as a markupcontainer since the tab-content container followed the link if created as a wicket link with setAnchor
final WebMarkupContainer handInTabLink = new WebMarkupContainer("handInTabLink");
handInTabLink.add(new SimpleAttributeModifier("href", "#" + panels.get(item.getIndex()).getMarkupId()));
handInTabLink.setOutputMarkupId(true);
handInTabLink.add(new DateFormatter().createFormattedDateLabel("linkHandedInDate", new Model<Date>(hi.getDateCreated())));
handInTabLink.add(hi.getStatusIcon("linkStatusIcon"));
item.add(handInTabLink);
item.setOutputMarkupId(true);
add(item);
}
};
handInTabs.add(tabContainerList);
handInTabs.add(tabList);
add(handInTabs);
//Conditionally show the form for creating a new hand in
if(showHandInForm && !isSupervisorView && hia.getProject().getHeadSupervisor() != null){
add(new HandInFormPanel("handInForm", handInActivity.getEvent(), handInActivity.getProject()));
} else {
add(new EmptyPanel("handInForm"));
}
add(new Label("noHeadSupervisorMsg", "The project needs a head supervisor before hand ins can be uploaded"){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return hia.getProject().getHeadSupervisor() == null;
}
});
}
/*
* Let the creator of this panel decide where to redirect the user when clicking save on something
*/
public abstract Class<? extends Page> getResponsePageClass();
public abstract PageParameters getResponsePageParameters();
}

@ -1,21 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<p>Reassign the feedback to someone else in the supervisor group</p>
<div class="span-8 last">
<form wicket:id="reassignForm">
<div class="span-8 last append-bottom">
<strong>Assign to: </strong>
<select wicket:id="assignedSupervisorDD"></select>
</div>
<div class="span-8 last append-1">
<button type="submit" wicket:id="saveAssignSupervisorButton" class="button">
Save
</button>
</div>
</form>
</div>
</wicket:panel>
</body>
</html>

@ -1,86 +0,0 @@
package se.su.dsv.scipro.events.panels.handins;
import java.util.ArrayList;
import java.util.List;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.form.Button;
import org.apache.wicket.markup.html.form.ChoiceRenderer;
import org.apache.wicket.markup.html.form.DropDownChoice;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.model.PropertyModel;
import se.su.dsv.scipro.data.dataobjects.HandIn;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectFollower;
import se.su.dsv.scipro.data.dataobjects.User;
public class ReassignFeedbackFormPanel extends AbstractFeedbackFormPanel {
private static final long serialVersionUID = 1L;
public ReassignFeedbackFormPanel(final String id, final HandIn hi,
Class<? extends Page> responsePageClass, final PageParameters responsePageParams){
super(id, hi, responsePageClass, responsePageParams);
add(new ReassignFeedbackForm("reassignForm"));
}
private class ReassignFeedbackForm extends Form<Void>{
private static final long serialVersionUID = 1L;
private User assignedSupervisor;
public ReassignFeedbackForm(final String id){
super(id);
assignedSupervisor = handIn.getFeedback().getAssignedTo();
List<User> supervisors = new ArrayList<User>();
Project p = handIn.getHandInActivity().getProject();
supervisors.add(p.getHeadSupervisor().getUser());
for(ProjectFollower pf : p.getProjectFollowers()){
supervisors.add(pf.getFollower().getUser());
}
ChoiceRenderer<User> userCr = new ChoiceRenderer<User>(){
private static final long serialVersionUID = 1L;
public String getDisplayValue(User user){
if(user.getFirstName() != null && user.getLastName() != null){
return user.toString();
} else {
String name = "";
if(user.getFirstName() != null){
name += user.getFirstName();
}
if(user.getLastName() != null){
name += user.getLastName();
}
if(user.getEmailAddress() != null){
if(name.length() > 0){
name += " ";
}
name += user.getEmailAddress();
}
return name;
}
}
public String getIdValue(User user, int index){
return String.valueOf(user.getId());
}
};
add(new DropDownChoice<User>("assignedSupervisorDD", new PropertyModel<User>(this, "assignedSupervisor"), supervisors, userCr));
add(new Button("saveAssignSupervisorButton"){
private static final long serialVersionUID = 1L;
public void onSubmit(){
if(assignedSupervisor != null){
handIn.getFeedback().setAssignedTo(assignedSupervisor);
}
handInFeedbackDao.save(handIn.getFeedback());
setResponsePage(responsePageClass, responsePageParams);
}
});
}
}
}

@ -1,27 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div class="span-8 last">
<p>Optionally select any files containing feedback and select a new status for the hand in.</p>
<form wicket:id="sendFeedbackForm">
<div class="span-8 last append-1" wicket:id="feedbackPanelContainer">
<div wicket:id="feedbackPanel"></div>
</div>
<div class="span-8 last append-2">
<div wicket:id="fileInput"></div>
</div>
<div class="span-8 last append-1">
<strong>Select status: </strong>
<select wicket:id="statusDD"></select>
</div>
<div class="span-8 last append-1">
<button type="submit" wicket:id="sendFeedbackButton" class="button">
Send
</button>
</div>
</form>
</div>
</wicket:panel>
</body>
</html>

@ -1,91 +0,0 @@
package se.su.dsv.scipro.events.panels.handins;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.ajax.markup.html.form.AjaxButton;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.form.DropDownChoice;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.form.upload.FileUpload;
import org.apache.wicket.markup.html.form.upload.MultiFileUploadField;
import org.apache.wicket.model.PropertyModel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.components.FormFeedbackPanel;
import se.su.dsv.scipro.data.controllers.HandInFeedbackController;
import se.su.dsv.scipro.data.dataobjects.HandIn;
import se.su.dsv.scipro.data.enums.HandInStatus;
import se.su.dsv.scipro.util.SelectOption;
public class SendFeedbackFormPanel extends AbstractFeedbackFormPanel {
private static final long serialVersionUID = 1L;
@SpringBean
private HandInFeedbackController handInFeedbackController;
public SendFeedbackFormPanel(final String id, final HandIn hi,
Class<? extends Page> responsePageClass, final PageParameters responsePageParams){
super(id, hi, responsePageClass, responsePageParams);
add(new SendFeedbackForm("sendFeedbackForm"));
}
private class SendFeedbackForm extends Form<Void>{
private static final long serialVersionUID = 1L;
private final Collection<FileUpload> uploads = new ArrayList<FileUpload>();
DropDownChoice<SelectOption<HandInStatus>> statusDD;
SelectOption<HandInStatus> status;
public SendFeedbackForm(final String id){
super(id);
setMultiPart(true);
MultiFileUploadField mfu = new MultiFileUploadField("fileInput",
new PropertyModel<Collection<FileUpload>>(this, "uploads"), 5);
add(mfu);
final WebMarkupContainer feedbackPanelContainer = new WebMarkupContainer("feedbackPanelContainer");
feedbackPanelContainer.setOutputMarkupId(true);
final FormFeedbackPanel<Void> feedbackPanel = new FormFeedbackPanel<Void>("feedbackPanel", this);
feedbackPanelContainer.add(feedbackPanel);
add(feedbackPanelContainer);
final List<SelectOption<HandInStatus>> statusOptions = new ArrayList<SelectOption<HandInStatus>>();
statusOptions.add(new SelectOption<HandInStatus>("Approved", HandInStatus.APPROVED));
statusOptions.add(new SelectOption<HandInStatus>("Not approved", HandInStatus.NOT_APPROVED));
statusOptions.add(new SelectOption<HandInStatus>("Require new hand-in", HandInStatus.REQUIRE_SUPPLEMENT));
statusDD = new DropDownChoice<SelectOption<HandInStatus>>("statusDD", new PropertyModel<SelectOption<HandInStatus>>(this, "status"), statusOptions);
statusDD.setRequired(true);
add(statusDD);
add(new AjaxButton("sendFeedbackButton"){
private static final long serialVersionUID = 1L;
@Override
protected void onSubmit(AjaxRequestTarget target, Form<?> form) {
SendFeedbackForm f = (SendFeedbackForm) form;
if(handInFeedbackController.store(handIn, f.uploads, f.status.value)){
setResponsePage(responsePageClass, responsePageParams);
} else {
error("An error occured, please try again!");
target.addComponent(feedbackPanelContainer);
}
}
@Override
protected void onError(AjaxRequestTarget target, Form<?> form) {
target.addComponent(feedbackPanelContainer);
}
});
}
}
}

@ -1,12 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div class="span-22 last prepend-top" wicket:id="handInList">
<h5 class="peer-title" wicket:id="projectTitle"></h5>
<span wicket:id=nothingHandedInYet></span>
<div class="span-22 last" wicket:id="projectHandInPanel"></div>
</div>
</wicket:panel>
</body>
</html>

@ -1,77 +0,0 @@
package se.su.dsv.scipro.events.panels.handins;
import java.util.ArrayList;
import java.util.List;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.GroupEventDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
import se.su.dsv.scipro.supervisor.pages.SupervisorGroupEventPage;
public class SupervisorGroupEventPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private GroupEventDao groupEventDao;
@SpringBean
private HandInActivityDao handInActivityDao;
public SupervisorGroupEventPanel(final String id, final GroupEvent ge){
super(id);
final GroupEvent event = groupEventDao.reLoad(ge);
final List<Project> projects = new ArrayList<Project>();
for(ProjectSchedule ps : event.getProjectSchedules()){
projects.add(ps.getProject());
}
add(new ListView<Project>("handInList", projects){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<Project> item) {
final HandInActivity handInActivity = handInActivityDao.getHandInActivity(ge, item.getModelObject());
item.add(new Label("projectTitle", handInActivity.getProject().getTitle()));
item.add(new Label("nothingHandedInYet", "Nothing has been handed in yet"){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return handInActivity.getHandIns().size() == 0;
}
});
item.add(new HandInPanel("projectHandInPanel", handInActivity, true){
private static final long serialVersionUID = 1L;
@Override
public Class<? extends Page> getResponsePageClass() {
return SupervisorGroupEventPage.class;
}
@Override
public PageParameters getResponsePageParameters() {
PageParameters pp = new PageParameters();
pp.put(Event.PP_EVENT_ID, event.getId());
return pp;
}
});
add(item);
}
});
}
}

@ -10,7 +10,6 @@ import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.FinalSeminarDao;
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.UserDao;
import se.su.dsv.scipro.data.dao.interfaces.UserSettingsDao;
import se.su.dsv.scipro.data.dataobjects.FinalSeminar;
@ -37,9 +36,6 @@ public class JsonProjectForSupervisorPage extends WebPage {
@SpringBean
ProjectDao projectDao;
@SpringBean
ProjectEventDao projectEventDao;
@SpringBean
FinalSeminarDao finalSeminarDao;
@ -122,8 +118,6 @@ public class JsonProjectForSupervisorPage extends WebPage {
jsonProject.add("projectMembers", jStudentArray);
jsonProject.add("projectReviewers", jReviewerArray);
jsonProject.add("projectCosupervisors", coSupervisorArray);
jsonProject.addProperty("projectProgress",
projectEventDao.getProjectProgress(project));
JsonArray finalSeminars = new JsonArray();

@ -1,45 +0,0 @@
package se.su.dsv.scipro.project.pages;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.events.panels.EventPagePanel;
import se.su.dsv.scipro.exceptions.PageNotFoundException;
public class ProjectEventPage extends ProjectSchedulePage {
@SpringBean
private EventDao eventDao;
public ProjectEventPage(PageParameters pp) {
super(pp);
Long eventId = pp.getAsLong(Event.PP_EVENT_ID);
if(eventId == null){
throw new PageNotFoundException(this);
}
Event event = eventDao.load(eventId);
if( event == null || event.isDeleted() ) {
throw new PageNotFoundException(this);
}
add(new EventPagePanel("eventPanel", event, project, false){
private static final long serialVersionUID = 1L;
@Override
public Class<? extends Page> getSurroundingPageClass() {
return ProjectEventPage.class;
}
});
}
}

@ -1,25 +0,0 @@
package se.su.dsv.scipro.project.pages;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.schedule.panels.ScheduleGeneratorPanel;
@Deprecated
public class ProjectScheduleGeneratorPage extends ProjectSchedulePage {
public ProjectScheduleGeneratorPage(final PageParameters pp){
super(pp);
add(new ScheduleGeneratorPanel("generatorPanel", SciProSession.get().getActiveProject()){
private static final long serialVersionUID = 1L;
@Override
public Class<? extends Page> getSurroundingPageClass() {
return ProjectSchedulePlannerPage.class;
}
});
}
}

@ -1,36 +0,0 @@
package se.su.dsv.scipro.project.pages;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import se.su.dsv.scipro.schedule.panels.SchedulePlannerPanel;
import se.su.dsv.scipro.security.auth.Authorization;
import se.su.dsv.scipro.security.auth.roles.Roles;
@Authorization(authorizedRoles={Roles.SYSADMIN}) //TODO Hidden for initial deployment
public class ProjectSchedulePlannerPage extends ProjectSchedulePage {
public ProjectSchedulePlannerPage(PageParameters pp) {
super(pp);
add(new SchedulePlannerPanel("schedulePlannerPanel", project, false){
private static final long serialVersionUID = 1L;
@Override
public Class<? extends Page> getSchedulePageClass() {
return ProjectSchedulePlannerPage.this.getClass();
}
@Override
public Class<? extends Page> getGeneratorPageClass() {
return ProjectScheduleGeneratorPage.class;
}
@Override
public Class<? extends Page> getEventPageClass() {
return ProjectEventPage.class;
}
});
}
}

@ -1,185 +0,0 @@
package se.su.dsv.scipro.project.panels;
import java.util.Date;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.link.Link;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.Model;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.odlabs.wiquery.core.effects.EffectSpeed;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dao.interfaces.RoleDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.icons.AjaxActionIcon;
import se.su.dsv.scipro.icons.ExpandContractActionIcon;
import se.su.dsv.scipro.icons.IconPanel;
import se.su.dsv.scipro.icons.ImageIcon;
import se.su.dsv.scipro.icons.ImageObject;
import se.su.dsv.scipro.schedule.baseevent.panels.EventScheduleDetailsPanel;
import se.su.dsv.scipro.util.DateFormatter;
import se.su.dsv.scipro.util.IAjaxCallback;
import se.su.dsv.scipro.util.JavascriptEventConfirmation;
import se.su.dsv.scipro.util.WiQueryCoreEffectsHelper;
public abstract class EventLayoutPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
protected EventDao eventDao;
@SpringBean
protected ProjectDao projectDao;
@SpringBean
protected RoleDao roleDao;
@SpringBean
protected HandInActivityDao handInActivityDao;
public EventLayoutPanel(String id, final Event event, final Project project, final boolean isSupervisorView){
super(id);
final User user = SciProSession.get().getUser();
//add(new CalendarIconImage("calendarIcon", event.getDueDate()));
add(new DateFormatter().createFormattedDateLabel("eventDueDate", event.getDueDate()));
add(new Label("eventTitle", event.getTitle()));
final WebMarkupContainer eventDetailsContainer = new WebMarkupContainer("eventDetailsContainer");
eventDetailsContainer.setOutputMarkupId(true);
eventDetailsContainer.add(new EmptyPanel("eventDetails"));
add(eventDetailsContainer);
final ExpandContractActionIcon showDetailsIcon = new ExpandContractActionIcon("showDetailsIcon"){
private static final long serialVersionUID = 1L;
@Override
public void onExpand(AjaxRequestTarget target) {
eventDetailsContainer.replace(new EventScheduleDetailsPanel("eventDetails", event));
target.addComponent(eventDetailsContainer);
target.appendJavascript(WiQueryCoreEffectsHelper.slideDownJs(eventDetailsContainer, EffectSpeed.FAST));
}
@Override
public void onContract(AjaxRequestTarget target) {
target.appendJavascript(WiQueryCoreEffectsHelper.slideUpJs(eventDetailsContainer, EffectSpeed.FAST));
}
};
add(showDetailsIcon);
Link<Void> eventPageLink = new Link<Void>("eventPageLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick() {
onEventDetailsClick();
}
};
add(eventPageLink);
add(new AjaxActionIcon("eventEditIcon", ImageObject.TWENTYFOUR + ImageObject.EDIT){
private static final long serialVersionUID = 1L;
@Override
protected void onClick(AjaxRequestTarget target) {
final IAjaxCallback cb = new IAjaxCallback(){
private static final long serialVersionUID = 1L;
@Override
public void doCallback(AjaxRequestTarget onSubmitTarget) {
closeDialogAndRefreshListView(onSubmitTarget);
}
};
replaceAndOpenDialog(target, event.getCreationPanel("containerContent", cb, isSupervisorView));
}
@Override
public boolean isVisible(){
return eventDao.isEditable(event, user);
}
});
add(new AjaxActionIcon("eventDeleteIcon", ImageObject.TWENTYFOUR + ImageObject.DELETE){
private static final long serialVersionUID = 1L;
@Override
protected void onClick(AjaxRequestTarget target) {
eventDao.lazyDelete(event);
refreshListView(target);
}
@Override
public boolean isVisible(){
return eventDao.isDeletable(event, user);
}
}.add(new JavascriptEventConfirmation("onclick", "Delete " + event.getTitle() + "?")));
/*if(event.isRequireHandIn()){
add(new IconPanel("handInRequiredIcon", ImageIcon.ICON_RED_FLAG){
private static final long serialVersionUID = 1L;
@Override
public String getDisplayString() {
return "Hand in required";
}
});
} else {
add(new EmptyPanel("handInRequiredIcon"));
}*/
String statusIcon = ImageIcon.ICON_EMPTY;
final Model<String> statusMsgModel = new Model<String>("");
//Check the status
if(eventDao.eventIsDone(event, user, project)) {
statusIcon = ImageIcon.ICON_EVENT_DONE;
statusMsgModel.setObject("Event is done");
} else if (event.isRequireHandIn()){
//Ok, event is not done
HandInActivity hia = handInActivityDao.getHandInActivity(event, project);
//if there are hand ins and the event is not done, it must be awaiting feedback
if(hia != null && hia.getHandIns().size() > 0){
statusMsgModel.setObject("Awaiting supervisor feedback");
} else {
statusMsgModel.setObject("No hand in uploaded yet");
}
statusIcon = ImageIcon.ICON_EVENT_ALERT;
} else {
//The event must be upcoming
if(event.getDueDate().getTime() > new Date().getTime()){
statusMsgModel.setObject("Event upcoming");
statusIcon = ImageIcon.ICON_EVENT_UPCOMING;
}
}
eventPageLink.add(new IconPanel("statusIcon", statusIcon){
private static final long serialVersionUID = 1L;
@Override
public String getDisplayString() {
return statusMsgModel.getObject();
}
});
}
public abstract void replaceAndOpenDialog(AjaxRequestTarget target, Panel replacePanel);
public abstract void refreshListView(AjaxRequestTarget target);
public abstract void closeDialogAndRefreshListView(AjaxRequestTarget target);
public abstract void onEventDetailsClick();
}

@ -1,58 +0,0 @@
package se.su.dsv.scipro.schedule.baseevent;
import org.apache.wicket.IClusterable;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.form.CheckBox;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.form.TextArea;
import org.apache.wicket.markup.html.form.TextField;
import org.apache.wicket.markup.html.panel.FeedbackPanel;
import org.apache.wicket.model.CompoundPropertyModel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.components.CustomDateTimeField;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
public abstract class EventForm<T> extends Form<T> implements IClusterable {
private static final long serialVersionUID = 1L;
protected WebMarkupContainer feedbackContainer;
protected FeedbackPanel feedbackPanel;
protected boolean isEdit;
protected boolean isSupervisorView;
protected CheckBox handInRequiredCheckBox;
@SpringBean
protected EventDao eventDao;
public EventForm(String id, T model, final boolean isEdit, final boolean isSupervisorView) {
super(id, new CompoundPropertyModel<T>(model));
this.isEdit = isEdit;
this.isSupervisorView = isSupervisorView;
feedbackContainer = new WebMarkupContainer("feedbackContainer");
feedbackContainer.setOutputMarkupId(true);
feedbackContainer.setVersioned(false);
feedbackPanel = new FeedbackPanel("feedbackPanel");
feedbackContainer.add(feedbackPanel);
add(feedbackContainer);
TextField<String> title = new TextField<String>("title");
title.setRequired(true);
add(title);
TextArea<String> description = new TextArea<String>("description");
add(description);
handInRequiredCheckBox = new CheckBox("requireHandIn");
add(handInRequiredCheckBox);
CustomDateTimeField dp = new CustomDateTimeField("date");
dp.setRequired(true);
add(dp);
}
protected abstract void onFormSubmit(AjaxRequestTarget target);
}

@ -1,97 +0,0 @@
package se.su.dsv.scipro.schedule.baseevent;
import java.util.Date;
import org.apache.wicket.IClusterable;
import org.apache.wicket.injection.web.InjectorHolder;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.joda.time.DateMidnight;
import se.su.dsv.scipro.data.dao.interfaces.CommentThreadDao;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dataobjects.CommentThread;
import se.su.dsv.scipro.data.dataobjects.Event;
public abstract class EventFormModel<T extends Event> implements IClusterable {
private static final long serialVersionUID = 1L;
@SpringBean
protected EventDao eventDao;
@SpringBean
private CommentThreadDao commentThreadDao;
@SpringBean
protected HandInActivityDao handInActivityDao;
protected T event;
private String title;
private String description;
private Date date;
private boolean requireHandIn;
public EventFormModel(T e) {
this.event = e;
if(event.getDueDate() == null){
event.setDueDate(new DateMidnight().plusDays(1).toDateTime().minusSeconds(1).toDate());
}
setTitle(event.getTitle());
setDescription(event.getDescription());
setDate(event.getDueDate());
setRequireHandIn(event.isRequireHandIn());
InjectorHolder.getInjector().inject(this);
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public void setRequireHandIn(boolean requireHandIn) {
this.requireHandIn = requireHandIn;
}
public boolean isRequireHandIn() {
return requireHandIn;
}
public T persist() throws IllegalStateException {
boolean createCt = event.getId() == null;
try {
event = doPersist();
} catch (IllegalStateException e){
throw e;
}
if(createCt){
CommentThread ct = new CommentThread(event);
ct = commentThreadDao.save(ct);
}
return event;
}
public abstract T doPersist();
}

@ -1,29 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<form wicket:id="eventForm" class="dialogForm">
<div wicket:id="feedbackContainer">
<div wicket:id="feedbackPanel"></div>
</div>
<div class="formRow">
<strong>Title:</strong><br />
<input type="text" wicket:id="title" />
</div>
<div class="formRow">
<strong>Description:</strong><br />
<textarea wicket:id="description"></textarea>
</div>
<div>
<strong>Require hand in: </strong>
<input type="checkbox" wicket:id="requireHandIn" />
</div>
<div class="formRow">
<strong>Date:</strong>
<div wicket:id="date"></div>
</div>
<wicket:child />
</form>
</wicket:panel>
</body>
</html>

@ -1,43 +0,0 @@
package se.su.dsv.scipro.schedule.baseevent.panels;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.markup.html.panel.Panel;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.schedule.baseevent.EventForm;
import se.su.dsv.scipro.schedule.baseevent.EventFormModel;
public abstract class CreateEventPanel<E extends Event, F extends EventForm<? extends EventFormModel<E>>> extends Panel {
private static final long serialVersionUID = 1L;
protected Project project;
protected E event;
public CreateEventPanel(String id, E event, Project p, final boolean isSupervisorView){
super(id);
this.project = p;
boolean isEdit = true;
if(event == null){
this.event = newEventInstance();
isEdit = false;
} else {
this.event = reLoadEvent(event);
}
add(newFormInstance(isEdit, isSupervisorView));
}
public CreateEventPanel(String id, E event, final boolean isSupervisorView){
this(id, event, null, isSupervisorView);
}
public CreateEventPanel(String id, final boolean isSupervisorView){
this(id, null, null, isSupervisorView);
}
protected abstract E newEventInstance();
protected abstract F newFormInstance(boolean isEdit, boolean isSupervisorView);
protected abstract E reLoadEvent(E event);
protected abstract void onFormSubmit(AjaxRequestTarget target);
}

@ -1,16 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<strong>Creator:</strong>
<div class="append-bottom">
<span wicket:id="creator"></span>
</div>
<strong>Description:</strong>
<div class="append-bottom">
<span wicket:id="eventDescription"></span>
</div>
<div wicket:id="classSpecificDetails"></div>
</wicket:panel>
</body>
</html>

@ -1,20 +0,0 @@
package se.su.dsv.scipro.schedule.baseevent.panels;
import org.apache.wicket.markup.html.basic.MultiLineLabel;
import org.apache.wicket.markup.html.panel.Panel;
import se.su.dsv.scipro.data.dataobjects.Event;
public class EventScheduleDetailsPanel extends Panel {
private static final long serialVersionUID = 1L;
public EventScheduleDetailsPanel(String id, Event e) {
super(id);
add(e.getCreator().getDisplayComponent("creator"));
add(new MultiLineLabel("eventDescription", e.getDescription()));
add(e.getScheduleDetailsPanel("classSpecificDetails"));
}
}

@ -1,31 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div class="rounded-box">
<div class="box-title">
<span wicket:id="showDetailsIcon"></span>
<span wicket:id="eventTitle">Event title here</span>
<img wicket:id="eventDeleteIcon" class="right" />
<img wicket:id="eventEditIcon" class="right" />
<a href="#" class="right" wicket:id="eventPageLink"><img wicket:id="eventPageLinkIcon" /></a>
</div>
<div>
<img wicket:id="calendarIcon" class="left"/>
<div>
<div wicket:id="handInRequiredIcon"></div>
<div wicket:id="statusIcon"></div>
<div>
<strong>Date of event: </strong><span wicket:id="eventDueDate"></span>
</div>
</div>
</div>
<p></p>
<div wicket:id="eventDetailsContainer" style="display:none;">
<div wicket:id="eventDetails"></div>
</div>
</div>
<div wicket:id="nextEvent"></div>
</wicket:panel>
</body>
</html>

@ -1,195 +0,0 @@
package se.su.dsv.scipro.schedule.baseevent.panels;
import java.util.Date;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.link.Link;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.Model;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.odlabs.wiquery.core.effects.EffectSpeed;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dao.interfaces.RoleDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.icons.ActionIcon;
import se.su.dsv.scipro.icons.AjaxActionIcon;
import se.su.dsv.scipro.icons.ExpandContractActionIcon;
import se.su.dsv.scipro.icons.IconPanel;
import se.su.dsv.scipro.icons.ImageIcon;
import se.su.dsv.scipro.icons.ImageObject;
import se.su.dsv.scipro.schedule.calendar.icon.CalendarIconImage;
import se.su.dsv.scipro.util.DateFormatter;
import se.su.dsv.scipro.util.IAjaxCallback;
import se.su.dsv.scipro.util.JavascriptEventConfirmation;
import se.su.dsv.scipro.util.WiQueryCoreEffectsHelper;
public abstract class EventSchedulePanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
protected EventDao eventDao;
@SpringBean
protected ProjectDao projectDao;
@SpringBean
protected RoleDao roleDao;
@SpringBean
protected HandInActivityDao handInActivityDao;
public EventSchedulePanel(String id, final Event event, final Project project, final boolean isSupervisorView){
super(id);
final User user = SciProSession.get().getUser();
add(new CalendarIconImage("calendarIcon", event.getDueDate()));
add(new Label("eventTitle", event.getTitle()));
add(new DateFormatter().createFormattedDateLabel("eventDueDate", event.getDueDate()));
final WebMarkupContainer eventDetailsContainer = new WebMarkupContainer("eventDetailsContainer");
eventDetailsContainer.setOutputMarkupId(true);
eventDetailsContainer.add(new EmptyPanel("eventDetails"));
add(eventDetailsContainer);
final ExpandContractActionIcon showDetailsIcon = new ExpandContractActionIcon("showDetailsIcon"){
private static final long serialVersionUID = 1L;
@Override
public void onExpand(AjaxRequestTarget target) {
eventDetailsContainer.replace(new EventScheduleDetailsPanel("eventDetails", event));
target.addComponent(eventDetailsContainer);
target.appendJavascript(WiQueryCoreEffectsHelper.slideDownJs(eventDetailsContainer, EffectSpeed.FAST));
}
@Override
public void onContract(AjaxRequestTarget target) {
target.appendJavascript(WiQueryCoreEffectsHelper.slideUpJs(eventDetailsContainer, EffectSpeed.FAST));
}
};
add(showDetailsIcon);
Link<Void> eventPageLink = new Link<Void>("eventPageLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick() {
onEventDetailsClick();
}
};
// ImageIcon eventPageLinkIcon = new ImageIcon("eventPageLinkIcon", ActionIcon.ICON_DETAILS);
ImageObject eventPageLinkIcon = new ImageObject("eventPageLinkIcon", ImageObject.TWENTYFOUR + ImageObject.DOCUMENT_VIEW);
eventPageLink.add(eventPageLinkIcon);
add(eventPageLink);
// add(new AjaxActionIcon("eventEditIcon", AjaxActionIcon.ICON_EDIT){
add(new AjaxActionIcon("eventEditIcon", ImageObject.TWENTYFOUR + ImageObject.EDIT){
private static final long serialVersionUID = 1L;
@Override
protected void onClick(AjaxRequestTarget target) {
final IAjaxCallback cb = new IAjaxCallback(){
private static final long serialVersionUID = 1L;
@Override
public void doCallback(AjaxRequestTarget onSubmitTarget) {
closeDialogAndRefreshListView(onSubmitTarget);
}
};
replaceAndOpenDialog(target, event.getCreationPanel("containerContent", cb, isSupervisorView));
}
@Override
public boolean isVisible(){
return eventDao.isEditable(event, user);
}
});
// add(new AjaxActionIcon("eventDeleteIcon", AjaxActionIcon.ICON_DELETE){
add(new AjaxActionIcon("eventDeleteIcon", ImageObject.TWENTYFOUR + ImageObject.DELETE){
private static final long serialVersionUID = 1L;
@Override
protected void onClick(AjaxRequestTarget target) {
eventDao.lazyDelete(event);
refreshListView(target);
}
@Override
public boolean isVisible(){
return eventDao.isDeletable(event, user);
}
}.add(new JavascriptEventConfirmation("onclick", "Delete " + event.getTitle() + "?")));
add(new NextEventPanel("nextEvent", event, eventDao.getNextEvent(user,
project, event)));
if(event.isRequireHandIn()){
add(new IconPanel("handInRequiredIcon", ImageIcon.ICON_RED_FLAG){
private static final long serialVersionUID = 1L;
@Override
public String getDisplayString() {
return "Hand in required";
}
});
} else {
add(new EmptyPanel("handInRequiredIcon"));
}
String statusIcon = ImageIcon.ICON_EMPTY;
final Model<String> statusMsgModel = new Model<String>("");
//Check the status
if(eventDao.eventIsDone(event, user, project)) {
statusIcon = ImageIcon.ICON_EVENT_DONE;
statusMsgModel.setObject("Event is done");
} else if (event.isRequireHandIn()){
//Ok, event is not done
HandInActivity hia = handInActivityDao.getHandInActivity(event, project);
//if there are hand ins and the event is not done, it must be awaiting feedback
if(hia != null && hia.getHandIns().size() > 0){
statusMsgModel.setObject("Awaiting supervisor feedback");
} else {
statusMsgModel.setObject("No hand in uploaded yet");
}
statusIcon = ImageIcon.ICON_EVENT_ALERT;
} else {
//The event must be upcoming
if(event.getDueDate().getTime() > new Date().getTime()){
statusMsgModel.setObject("Event upcoming");
statusIcon = ImageIcon.ICON_EVENT_UPCOMING;
}
}
add(new IconPanel("statusIcon", statusIcon){
private static final long serialVersionUID = 1L;
@Override
public String getDisplayString() {
return statusMsgModel.getObject();
}
});
}
public abstract void replaceAndOpenDialog(AjaxRequestTarget target, Panel replacePanel);
public abstract void refreshListView(AjaxRequestTarget target);
public abstract void closeDialogAndRefreshListView(AjaxRequestTarget target);
public abstract void onEventDetailsClick();
}

@ -1,11 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<img wicket:id="nextEventIcon" />
<span wicket:id="timeDiffDays">18</span> <span wicket:id="timeDiffDaysText">days</span>
<span wicket:id="timeDiffHours">5</span> <span wicket:id="timeDiffHoursText">hours</span>
<span wicket:id="noNextEvent" class="icon icon-arrow-down"></span>
</wicket:panel>
</body>
</html>

@ -1,69 +0,0 @@
package se.su.dsv.scipro.schedule.baseevent.panels;
import java.util.List;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.Model;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.icons.ImageIcon;
public class NextEventPanel extends Panel {
private static final long serialVersionUID = 1L;
public NextEventPanel(String id, final Event currentEvent, final Event nextEvent) {
super(id);
Long timeDiffDays = null;
Long timeDiffHours = null;
long timeDiff = 0;
if(nextEvent != null){
timeDiff = (nextEvent.getDueDate().getTime() - currentEvent.getDueDate().getTime()) / (1000 * 60 * 60);
}
timeDiffHours = timeDiff % 24;
timeDiffDays = timeDiff / 24;
final Model<Long> timeDiffDaysModel = new Model<Long>(timeDiffDays);
add(new ImageIcon("nextEventIcon", ImageIcon.ICON_ARROW_DOWN));
add(new Label("timeDiffDays", timeDiffDaysModel){
private static final long serialVersionUID = 1L;
public boolean isVisible(){
return nextEvent != null;
}
});
add(new Label("timeDiffDaysText", "days "){
private static final long serialVersionUID = 1L;
public boolean isVisible(){
return nextEvent != null;
}
});
final Model<Long> timeDiffHoursModel = new Model<Long>(timeDiffHours);
add(new Label("timeDiffHours", timeDiffHoursModel){
private static final long serialVersionUID = 1L;
public boolean isVisible(){
return nextEvent != null;
}
});
add(new Label("timeDiffHoursText", "hours"){
private static final long serialVersionUID = 1L;
public boolean isVisible(){
return nextEvent != null;
}
});
add(new Label("noNextEvent", "No next event"){
private static final long serialVersionUID = 1L;
public boolean isVisible(){
return nextEvent == null;
}
});
}
}

@ -1,132 +0,0 @@
package se.su.dsv.scipro.schedule.groupevent;
import java.util.Arrays;
import java.util.Date;
import java.util.Iterator;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.extensions.ajax.markup.html.IndicatingAjaxButton;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.joda.time.DateMidnight;
import se.su.dsv.scipro.components.autocomplete.AutoCompletionChoicesProvider;
import se.su.dsv.scipro.components.autocomplete.MultiObjectAutoCompleteBuilder;
import se.su.dsv.scipro.components.autocomplete.MultiObjectAutoCompleteField;
import se.su.dsv.scipro.components.autocomplete.MultiObjectAutoCompleteObjectConverter;
import se.su.dsv.scipro.components.autocomplete.MultiObjectAutoCompleteRenderer;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.schedule.baseevent.EventForm;
@Deprecated
public abstract class GroupEventForm extends EventForm<GroupEventFormModel>{
private static final long serialVersionUID = 1L;
@SpringBean
private ProjectDao projectDao;
public static int num = 0;
public GroupEventForm(String id, final GroupEvent ge, final boolean isEdit, final boolean isSupervisorView) {
super(id, new GroupEventFormModel(ge), isEdit, isSupervisorView);
final boolean hasHandInActivities = eventDao.hasHandInsInHandInActivity(ge);
AutoCompletionChoicesProvider<Project> provider = new AutoCompletionChoicesProvider<Project>(){
private static final long serialVersionUID = 1L;
@Override
public Iterator<Project> getChoices(String input) {
return projectDao.searchProjectByTitle(input, 10, true).iterator();
}
};
MultiObjectAutoCompleteRenderer<Project> renderer = new MultiObjectAutoCompleteRenderer<Project>(){
private static final long serialVersionUID = 1L;
public String getTextValue(Project p){
return p.getTitle();
}
protected String getIdValue(Project p){
return p.getId().toString();
}
};
MultiObjectAutoCompleteObjectConverter<Long, Project> objectConverter = new MultiObjectAutoCompleteObjectConverter<Long, Project>(){
private static final long serialVersionUID = 1L;
public Project convertToObject(Long id) {
return projectDao.load(id);
}
};
MultiObjectAutoCompleteBuilder<Project, Long> builder = new MultiObjectAutoCompleteBuilder<Project, Long>(provider);
builder.autoCompleteRenderer(renderer);
builder.idType(Long.class);
builder.objectConverter(objectConverter);
builder.resultListItemCssClass(Arrays.asList(new String[]{"icon", "icon-project"}));
final MultiObjectAutoCompleteField<Project, Long> projectSelector = builder.build("eventProjects");
projectSelector.setSelectedObjects(this.getModelObject().getEventProjects());
if(hasHandInActivities){
projectSelector.setEnableDeletionOfSelectedObjects(false);
projectSelector.setEnabled(false);
}
//Do not allow students to require hand ins for groupevents and do not allow removal of hand in activity if someone already handed in
handInRequiredCheckBox.setEnabled(isSupervisorView);
add(projectSelector);
add(new IndicatingAjaxButton("saveButton"){
private static final long serialVersionUID = 1L;
@Override
protected void onSubmit(AjaxRequestTarget target, Form<?> form) {
GroupEventFormModel model = (GroupEventFormModel) form.getModelObject();
if(model.getDate().before(new DateMidnight(new Date()).toDate())){
error("Please provide a date in the future");
}
if(model.getEventProjects().size() == 0){
error("The event must have at least one participant");
}
for(Project p : model.getEventProjects()){
if(p.getProjectSchedule() == null){
error(p.getTitle() + " does not have a schedule, please remove the project");
}
}
if(!form.hasError()){
try {
model.persist();
onFormSubmit(target);
} catch (IllegalStateException e){
error("Cannot remove the hand in activity since one or more projects already handed in");
}
} else {
target.addComponent(feedbackContainer);
}
}
@Override
protected void onError(AjaxRequestTarget target, Form<?> form) {
target.addComponent(feedbackContainer);
}
});
}
}

@ -1,78 +0,0 @@
package se.su.dsv.scipro.schedule.groupevent;
import java.util.ArrayList;
import java.util.List;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
import se.su.dsv.scipro.schedule.baseevent.EventFormModel;
@Deprecated
public class GroupEventFormModel extends EventFormModel<GroupEvent> {
private static final long serialVersionUID = 1L;
private List<Project> eventProjects = new ArrayList<Project>();
public GroupEventFormModel(GroupEvent e) {
super(e);
if(e.getId() != null){
event = (GroupEvent) eventDao.reLoad(e);
}
for(ProjectSchedule ps : e.getProjectSchedules()){
eventProjects.add(ps.getProject());
}
}
public List<Project> getEventProjects() {
return eventProjects;
}
public void setEventProjects(List<Project> eventProjects) {
this.eventProjects = eventProjects;
}
@Override
public GroupEvent doPersist() {
//First check if the user is trying to remove a hand in activity
if(event.getId() != null && event.isRequireHandIn() && !isRequireHandIn()){
for(ProjectSchedule ps : event.getProjectSchedules()){
HandInActivity hia = handInActivityDao.getHandInActivity(event, ps.getProject());
//If hand ins are saved, do not allow removal...
if(hia != null && hia.getHandIns().size() > 0){
throw new IllegalStateException();
}
}
}
event.setTitle(getTitle());
event.setDescription(getDescription());
event.setDueDate(getDate());
event.setCreator(SciProSession.get().getUser());
event.setRequireHandIn(isRequireHandIn());
List<ProjectSchedule> projectSchedules = new ArrayList<ProjectSchedule>();
for(Project p : eventProjects){
projectSchedules.add(p.getProjectSchedule());
}
event.setProjectSchedules(projectSchedules);
event = (GroupEvent) eventDao.save(event);
//If the event does not have a hand in, and the require hand in box is ticked, create one
if(event.isRequireHandIn()){
for(ProjectSchedule ps : event.getProjectSchedules()){
if(handInActivityDao.getHandInActivity(event, ps.getProject()) == null){
HandInActivity hia = new HandInActivity();
hia.setEvent(event);
hia.setProject(ps.getProject());
handInActivityDao.save(hia);
}
}
}
return event;
}
}

@ -1,16 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div wicket:id="dialog">
<div wicket:id="dialogContent">
<div wicket:id="formPanel"></div>
</div>
</div>
<a href="#" wicket:id="addGroupEventLink">
<img wicket:id="addIcon" /> Create Group Event
</a>
</wicket:panel>
</body>
</html>

@ -1,57 +0,0 @@
package se.su.dsv.scipro.schedule.groupevent.panels;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.ajax.markup.html.AjaxLink;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.odlabs.wiquery.ui.dialog.Dialog;
import se.su.dsv.scipro.icons.ImageIcon;
import se.su.dsv.scipro.icons.ImageObject;
public abstract class CreateGroupEventLinkPanel extends Panel {
private static final long serialVersionUID = 1L;
protected abstract void onFormSubmit(AjaxRequestTarget target);
public CreateGroupEventLinkPanel(String id) {
super(id);
final WebMarkupContainer dialogContent = new WebMarkupContainer("dialogContent");
dialogContent.setOutputMarkupId(true);
dialogContent.add(new EmptyPanel("formPanel"));
final Dialog dialog = new Dialog("dialog");
dialog.setOutputMarkupId(true);
dialog.setModal(true);
dialog.setAutoOpen(false);
dialog.add(dialogContent);
dialog.setWidth(600);
dialog.setHeight(450);
dialog.setTitle("Create Group Event");
add(dialog);
AjaxLink<Void> addGroupEventLink = new AjaxLink<Void>("addGroupEventLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick(AjaxRequestTarget target) {
dialogContent.replace(new CreateGroupEventPanel("formPanel", true) {
private static final long serialVersionUID = 1L;
@Override
protected void onFormSubmit(AjaxRequestTarget target) {
CreateGroupEventLinkPanel.this.onFormSubmit(target);
dialog.close(target);
}
});
target.addComponent(dialogContent);
dialog.open(target);
}
};
// addGroupEventLink.add(new ImageIcon("addIcon", ImageIcon.ICON_ADD));
addGroupEventLink.add(new ImageObject("addIcon", ImageObject.TWENTYFOUR + ImageObject.ADD));
add(addGroupEventLink);
}
}

@ -1,16 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:extend>
<div class="formRow">
<strong>Select projects to participate:</strong><br />
<div wicket:id="eventProjects"></div>
</div>
<div class="formRow">
<button class="button" type="submit" wicket:id="saveButton">
Save
</button>
</div>
</wicket:extend>
</body>
</html>

@ -1,57 +0,0 @@
package se.su.dsv.scipro.schedule.groupevent.panels;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.GroupEventDao;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.schedule.baseevent.panels.CreateEventPanel;
import se.su.dsv.scipro.schedule.groupevent.GroupEventForm;
public abstract class CreateGroupEventPanel extends CreateEventPanel<GroupEvent, GroupEventForm> {
private static final long serialVersionUID = 1L;
@SpringBean
private GroupEventDao geDao;
public CreateGroupEventPanel(String id, GroupEvent event, Project p, final boolean isSupervisorView) {
super(id, event, p, isSupervisorView);
}
public CreateGroupEventPanel(String id, GroupEvent event, final boolean isSupervisorView){
this(id, event, null, isSupervisorView);
}
public CreateGroupEventPanel(String id, final boolean isSupervisorView){
this(id, null, null, isSupervisorView);
}
@Override
public GroupEvent newEventInstance() {
GroupEvent ge = new GroupEvent();
if(project != null){
ge.addProjectSchedule(project.getProjectSchedule());
}
return ge;
}
@Override
public GroupEventForm newFormInstance(boolean isEdit, boolean isSupervisorView) {
return new GroupEventForm("eventForm", event, isEdit, isSupervisorView){
private static final long serialVersionUID = 1L;
@Override
protected void onFormSubmit(AjaxRequestTarget target){
CreateGroupEventPanel.this.onFormSubmit(target);
}
};
}
@Override
public GroupEvent reLoadEvent(GroupEvent event) {
return geDao.reLoad(event);
}
}

@ -1,12 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<strong>Participants:</strong>
<div class="scheduleEventParticipants" wicket:id="eventParticipants">
<span wicket:id="participant" class="icon icon-project">Event participant here</span>
</div>
</wicket:panel>
</body>
</html>

@ -1,39 +0,0 @@
package se.su.dsv.scipro.schedule.groupevent.panels;
import java.util.ArrayList;
import java.util.List;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.GroupEventDao;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
public class GroupEventScheduleDetailsPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private GroupEventDao geDao;
public GroupEventScheduleDetailsPanel(String id, GroupEvent e){
super(id);
e = geDao.reLoad(e);
List<Project> projList = new ArrayList<Project>();
for(ProjectSchedule ps : e.getProjectSchedules()){
projList.add(ps.getProject());
}
add(new ListView<Project>("eventParticipants", projList){
private static final long serialVersionUID = 1L;
@Override
public void populateItem(ListItem<Project> item){
item.add(item.getModelObject().getDisplayComponent("participant"));
add(item);
}
});
}
}

@ -1,115 +0,0 @@
package se.su.dsv.scipro.schedule.models;
import java.util.Date;
import java.util.List;
import org.apache.wicket.injection.web.InjectorHolder;
import org.apache.wicket.model.LoadableDetachableModel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.joda.time.DateMidnight;
import org.joda.time.DateTime;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.User;
public class EventListModel extends LoadableDetachableModel<List<Event>> {
private static final long serialVersionUID = 1L;
@SpringBean
private EventDao eventDao;
private DateTime firstDateOfTimeSpan;
private DateTime lastDateOfTimeSpan;
private Project project;
private User user = null;
private int count = 0;
public EventListModel(Project p){
this.project = p;
this.firstDateOfTimeSpan = new DateMidnight().withDayOfMonth(1).toDateTime();
lastDateOfTimeSpan = firstDateOfTimeSpan.plusMonths(1).minusSeconds(1);
InjectorHolder.getInjector().inject(this);
}
@Override
protected List<Event> load() {
List<Event> list = eventDao.getEventsByUserAndProject(user, project,
firstDateOfTimeSpan.toDate(), lastDateOfTimeSpan.toDate(), null);
setCount(list.size());
return list;
}
public void setTimeSpan(DateTime start, DateTime end){
firstDateOfTimeSpan = start;
lastDateOfTimeSpan = end;
reload();
}
private void setCount(int count) {
this.count = count;
}
/**
* Get the count of events the model is currently holding
* @return
*/
public int getCount() {
return count;
}
/**
* Add months to the time span the model is working on. Calling this will result in
* a time span of 1 month. Reloads the model
* @param numMonths
*/
public void plusMonths(int numMonths){
firstDateOfTimeSpan = firstDateOfTimeSpan.plusMonths(numMonths);
lastDateOfTimeSpan = firstDateOfTimeSpan.plusMonths(1).minusSeconds(1);
reload();
}
/**
* Subtract months from time span the model is currently working on. Calling this method
* will result in a time span of 1 month. Reloads the model
* @param numMonths
*/
public void minusMonths(int numMonths){
firstDateOfTimeSpan = firstDateOfTimeSpan.minusMonths(numMonths);
lastDateOfTimeSpan = firstDateOfTimeSpan.plusMonths(1).minusSeconds(1);
reload();
}
/**
* Reloads the model with the current settings
*/
public void reload(){
setObject(load());
}
/**
* Sets the time span to the first day of month from the date sent in as argument and the
* last day as the last day of that month
* @param date
*/
public void setMonthFromDate(Date date){
firstDateOfTimeSpan = new DateMidnight(date).withDayOfMonth(1).toDateTime();
lastDateOfTimeSpan = firstDateOfTimeSpan.plusMonths(1).minusSeconds(1);
reload();
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
reload();
}
}

@ -1,16 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<h5 class="peer-title">Project progress<span wicket:id="progressHelp" class="right"></span></h5>
<div wicket:id="progressBar"></div>
<strong>Project completion: <span wicket:id="projectCompletion"></span> %</strong>
<wicket:fragment wicket:id="progressExplanation" >
<p>The progress is based on all <strong>project events</strong> in the schedule. An event is considered done based on the following criteria</p>
<p><strong>For events with hand ins: </strong> Completed when the hand in has been approved/not approved by a supervisor</p>
<p><strong>For events without hand in: </strong>Completed when the event has been marked "done"</p>
</wicket:fragment>
</wicket:panel>
</body>
</html>

@ -1,38 +0,0 @@
package se.su.dsv.scipro.schedule.panels;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.odlabs.wiquery.ui.progressbar.ProgressBar;
import se.su.dsv.scipro.data.dao.interfaces.ProjectEventDao;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.icons.HelpIconDialog;
import se.su.dsv.scipro.security.auth.Authorization;
import se.su.dsv.scipro.security.auth.roles.Roles;
@Authorization(authorizedRoles={Roles.SYSADMIN}) //TODO Hidden for initial deployment
public class ProjectProgressPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private ProjectEventDao projectEventDao;
public ProjectProgressPanel(String id, final Project project) {
super(id);
final ProgressBar progressBar = new ProgressBar("progressBar");
int comp = projectEventDao.getProjectProgress(project);
progressBar.setValue(comp);
add(new Label("projectCompletion", String.valueOf(comp)));
add(new HelpIconDialog("progressHelp", "progressExplanation", this, "Project progress"));
add(progressBar);
}
public Panel getHelpIcon(String id){
return new HelpIconDialog(id, "progressExplanation", this, "Project progress");
}
}

@ -1,80 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div class="span-22 last">
<div class="span-18 last">
<div class="span-8 append-1">
<span>Explain what this page is about</span>
</div>
<div class="rounded-box info-box span-7 last">
<ul>
<li>Start by selecting a template form the list below</li>
<li>Select start date and end date, click generate</li>
<li>Save the result and edit the created schedule on the schedule page</li>
</ul>
</div>
</div>
<div class="span-18 last">
<fieldset>
<legend>Generator</legend>
<form wicket:id="templateGeneratorForm">
<div wicket:id="feedbackContainer">
<div wicket:id="feedbackPanel"></div>
</div>
<div><span>Selected template: </span><span wicket:id="selectedTemplateName" class="bold"></span></div>
<div><span>Select estimated start date: </span><input type="text" wicket:id="startDate" /></div>
<div><span>Select estimated end date: </span><input type="text" wicket:id="endDate" /></div>
<div><input type="submit" wicket:id="generateLink" /></div>
<div wicket:id="resultContainer" style="display:none;" class="prepend-top">
<table class="rounded-table-top">
<tr>
<th>Template name</th>
<th>Generated schedule duration</th>
<th>Date of last event</th>
<th>Preview</th>
<th></th>
</tr>
<tr wicket:id="resultList">
<td><span wicket:id="resTemplateName"></span></td>
<td><span wicket:id="resScheduleDuration"></span></td>
<td><span wicket:id="resLastEvent"></span></td>
<td><img wicket:id="previewResultIcon" /></td>
<td><a href="#" wicket:id="createScheduleLink">Create schedule</a></td>
</tr>
</table>
</div>
</form>
</fieldset>
</div>
<div wicket:id="filterPanel" class="span-18 last">
</div>
<div wicket:id="listContainer" class="span-18 last">
<table class="rounded-table">
<tr>
<th>Template name</th>
<th>System template</th>
<th>Creator</th>
<th>Details</th>
<th>Select</th>
</tr>
<tr wicket:id="templateList">
<td wicket:id="templateName">TempalteName</td>
<td><img wicket:id="isSysAdminTemplate"></img></td>
<td wicket:id="templateCreator">Creator</td>
<td><img wicket:id="detailsIcon" /></td>
<td><a href="#" wicket:id="selectLink">Select</a></td>
</tr>
<tr><td><div wicket:id="pager"></div></td><td></td><td></td><td></td><td></td></tr>
</table>
</div>
</div>
<div wicket:id="dialog">
<div wicket:id="dialogContent"></div>
</div>
</wicket:panel>
</body>
</html>

@ -1,398 +0,0 @@
package se.su.dsv.scipro.schedule.panels;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.wicket.IClusterable;
import org.apache.wicket.Page;
import org.apache.wicket.RestartResponseException;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.ajax.markup.html.AjaxLink;
import org.apache.wicket.ajax.markup.html.form.AjaxButton;
import org.apache.wicket.ajax.markup.html.navigation.paging.AjaxPagingNavigator;
import org.apache.wicket.datetime.DateConverter;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.link.Link;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.list.PageableListView;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.CompoundPropertyModel;
import org.apache.wicket.model.Model;
import org.apache.wicket.model.util.ListModel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.apache.wicket.util.convert.IConverter;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.odlabs.wiquery.core.effects.EffectSpeed;
import org.odlabs.wiquery.ui.datepicker.DatePicker;
import org.odlabs.wiquery.ui.datepicker.DatePicker.ShowOnEnum;
import org.odlabs.wiquery.ui.dialog.Dialog;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.activityplan.facade.ScheduleGenerator;
import se.su.dsv.scipro.activityplan.facade.ScheduleGeneratorResult;
import se.su.dsv.scipro.components.FormFeedbackPanel;
import se.su.dsv.scipro.data.dao.interfaces.HandInActivityDao;
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.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
import se.su.dsv.scipro.data.dataobjects.ScheduleTemplate;
import se.su.dsv.scipro.icons.AjaxActionIcon;
import se.su.dsv.scipro.icons.ImageIcon;
import se.su.dsv.scipro.icons.ImageObject;
import se.su.dsv.scipro.schedule.templates.panels.ScheduleTemplateDetailsPanel;
import se.su.dsv.scipro.schedule.templates.panels.ScheduleTemplateFilterPanel;
import se.su.dsv.scipro.schedule.templates.panels.models.ScheduleTemplatesModel;
import se.su.dsv.scipro.util.DateFormatter;
import se.su.dsv.scipro.util.WiQueryCoreEffectsHelper;
@Deprecated
public abstract class ScheduleGeneratorPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private ProjectScheduleDao projectScheduleDao;
@SpringBean
private ProjectEventDao projectEventDao;
@SpringBean
private ProjectDao projectDao;
@SpringBean
private HandInActivityDao handInActivityDao;
private ScheduleTemplatesModel templateModel;
private TemplateGeneratorForm form;
private Dialog dialog;
public ScheduleGeneratorPanel(final String id, final Project project){
super(id);
if(project.getProjectSchedule() != null){
throw new RestartResponseException(getSurroundingPageClass());
}
templateModel = new ScheduleTemplatesModel();
dialog = new Dialog("dialog");
dialog.setModal(true);
dialog.setAutoOpen(false);
dialog.add(new EmptyPanel("dialogContent"));
dialog.setWidth(700);
dialog.setHeight(600);
add(dialog);
form = new TemplateGeneratorForm("templateGeneratorForm", project);
add(form);
final WebMarkupContainer listContainer = new WebMarkupContainer("listContainer");
listContainer.setOutputMarkupId(true);
add(new ScheduleTemplateFilterPanel("filterPanel", templateModel, false){
private static final long serialVersionUID = 1L;
@Override
public void onFilterChanged(AjaxRequestTarget target) {
target.addComponent(WiQueryCoreEffectsHelper.fadeIn(listContainer, EffectSpeed.FAST));
}
});
final PageableListView<ScheduleTemplate> templateList = new PageableListView<ScheduleTemplate>("templateList", templateModel, 10){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<ScheduleTemplate> item) {
final ScheduleTemplate s = item.getModelObject();
item.add(new Label("templateName", s.getTemplateName()));
ImageIcon isSysAdminT = new ImageIcon("isSysAdminTemplate", s.isSysAdminTemplate() ? ImageIcon.ICON_CHECK : ImageIcon.ICON_EMPTY);
item.add(isSysAdminT);
item.add(s.getCreator().getDisplayComponent("templateCreator"));
AjaxActionIcon detailsIcon = new AjaxActionIcon("detailsIcon", ImageIcon.ICON_DETAILS){
private static final long serialVersionUID = 1L;
@Override
protected void onClick(AjaxRequestTarget target) {
dialog.replace(new ScheduleTemplateDetailsPanel("dialogContent", s));
target.addComponent(dialog);
dialog.setTitle(s.getTemplateName());
dialog.open(target);
}
};
AjaxLink<Void> selectLink = new AjaxLink<Void>("selectLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick(AjaxRequestTarget target) {
form.getModelObject().setSelectedTemplate(s);
target.addComponent(form.getSelectedTemplateLabel());
}
};
item.add(selectLink);
item.add(detailsIcon);
add(item);
}
};
listContainer.add(templateList);
final AjaxPagingNavigator pager = new AjaxPagingNavigator("pager", templateList) {
private static final long serialVersionUID = 1L;
@Override
protected void onAjaxEvent(AjaxRequestTarget target) {
target.addComponent(WiQueryCoreEffectsHelper.fadeIn(listContainer, EffectSpeed.FAST));
}
};
listContainer.add(pager);
listContainer.add(templateList);
add(listContainer);
}
private class TemplateGeneratorForm extends Form<TemplateGeneratorModel> {
private static final long serialVersionUID = 1L;
private DatePicker<Date> startDateField;
private DatePicker<Date> endDateField;
private WebMarkupContainer feedbackContainer;
private FormFeedbackPanel<TemplateGeneratorModel> feedbackPanel;
private Label selectedTemplateLabel;
public TemplateGeneratorForm(String id, final Project project) {
super(id, new CompoundPropertyModel<TemplateGeneratorModel>(new TemplateGeneratorModel()));
setOutputMarkupId(true);
feedbackContainer = new WebMarkupContainer("feedbackContainer");
feedbackContainer.setOutputMarkupId(true);
feedbackPanel = new FormFeedbackPanel<TemplateGeneratorModel>("feedbackPanel", this);
feedbackContainer.add(feedbackPanel);
add(feedbackContainer);
selectedTemplateLabel = new Label("selectedTemplateName", new Model<String>(){
private static final long serialVersionUID = 1L;
@Override
public String getObject(){
return getModelObject().getSelectedTemplate() == null ?
"" : getModelObject().getSelectedTemplate().getTemplateName();
}
});
selectedTemplateLabel.setOutputMarkupId(true);
add(selectedTemplateLabel);
startDateField = new DatePicker<Date>("startDate"){
private static final long serialVersionUID = 1L;
@Override
public final IConverter getConverter(Class<?> type){
return new DateConverter(true){
private static final long serialVersionUID = 1L;
@Override
public String getDatePattern() {
return "yy-dd-mm";
}
@Override
protected DateTimeFormatter getFormat() {
return DateTimeFormat.forPattern("YYYY-MM-dd");
}
};
}
};
startDateField.setDateFormat("yy-mm-dd");
startDateField.setRequired(true);
startDateField.setShowOn(ShowOnEnum.BOTH);
startDateField.setButtonText("<div class=\"ui-icon ui-icon-calendar\"></div>");
add(startDateField);
endDateField = new DatePicker<Date>("endDate"){
private static final long serialVersionUID = 1L;
@Override
public final IConverter getConverter(Class<?> type){
return new DateConverter(true){
private static final long serialVersionUID = 1L;
@Override
public String getDatePattern() {
return "yy-dd-mm";
}
@Override
protected DateTimeFormatter getFormat() {
return DateTimeFormat.forPattern("YYYY-MM-dd");
}
};
}
};
endDateField.setDateFormat("yy-mm-dd");
endDateField.setRequired(true);
endDateField.setShowOn(ShowOnEnum.BOTH);
endDateField.setButtonText("<div class=\"ui-icon ui-icon-calendar\"></div>");
//Not very nice error message....
//endDateField.add(DateValidator.minimum(startDateField.getModelObject()));
add(endDateField);
final WebMarkupContainer resultContainer = new WebMarkupContainer("resultContainer");
final ListView<ScheduleGeneratorResult> resultList = new ListView<ScheduleGeneratorResult>("resultList",
new ListModel<ScheduleGeneratorResult>(getModelObject().getResult())){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(
ListItem<ScheduleGeneratorResult> item) {
final ScheduleGeneratorResult res = item.getModelObject();
item.add(new Label("resTemplateName", res.getTemplate().getTemplateName()));
item.add(new Label("resScheduleDuration", new Model<Integer>(res.getTotalDuration())));
item.add(new DateFormatter().createFormattedDateLabel("resLastEvent", res.getLastEventDate()));
//item.add(new AjaxActionIcon("previewResultIcon", AjaxActionIcon.ICON_DETAILS, "Preview result"){
item.add(new AjaxActionIcon("previewResultIcon", ImageObject.TWENTYFOUR + ImageObject.DOCUMENT_VIEW){
private static final long serialVersionUID = 1L;
@Override
protected void onClick(AjaxRequestTarget target) {
// TODO Auto-generated method stub
}
});
item.add(new Link<Void>("createScheduleLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick() {
ProjectSchedule ps = new ProjectSchedule();
ps.setProject(project);
ps.setStartDate(res.getStartDate());
ps = projectScheduleDao.save(ps);
for(ProjectEvent e : res.getEventList()){
e.setProjectSchedule(ps);
e.setCreator(SciProSession.get().getUser());
ProjectEvent saved = projectEventDao.save(e);
if(saved.isRequireHandIn()){
HandInActivity hia = new HandInActivity();
hia.setEvent(saved);
hia.setProject(project);
handInActivityDao.save(hia);
}
}
setResponsePage(getSurroundingPageClass());
}
});
add(item);
}
};
resultContainer.add(resultList);
resultContainer.setOutputMarkupId(true);
add(resultContainer);
add(new AjaxButton("generateLink", new Model<String>("Generate")){
private static final long serialVersionUID = 1L;
@Override
protected void onSubmit(AjaxRequestTarget target, Form<?> form) {
TemplateGeneratorModel model = (TemplateGeneratorModel) form.getModelObject();
if(model.getSelectedTemplate() == null){
error("Please select template before generating");
} else if(model.getEndDate().before(model.getStartDate())) {
error("End date must be after start date");
} else {
ScheduleGenerator sg = new ScheduleGenerator(model.getSelectedTemplate().getId(),
project.getId(), model.getStartDate(), model.getEndDate());
model.setResult(sg.generate());
TemplateGeneratorForm.this.setModelObject(model);
target.addComponent(WiQueryCoreEffectsHelper.slideDown(resultContainer, EffectSpeed.FAST));
}
target.addComponent(feedbackContainer);
}
@Override
protected void onError(AjaxRequestTarget target, Form<?> form){
target.addComponent(feedbackContainer);
}
});
}
public Label getSelectedTemplateLabel(){
return selectedTemplateLabel;
}
}
public abstract Class<? extends Page> getSurroundingPageClass();
private class TemplateGeneratorModel implements IClusterable {
private static final long serialVersionUID = 1L;
private ScheduleTemplate selectedTemplate = null;
private Date startDate;
private Date endDate;
private List<ScheduleGeneratorResult> result = new ArrayList<ScheduleGeneratorResult>();
public TemplateGeneratorModel(){
startDate = new Date();
}
public Date getStartDate() {
return startDate;
}
public void setStartDate(Date startDate) {
this.startDate = startDate;
}
public Date getEndDate() {
return endDate;
}
public void setEndDate(Date endDate) {
this.endDate = endDate;
}
public List<ScheduleGeneratorResult> getResult() {
return result;
}
public void setResult(ScheduleGeneratorResult res) {
result.clear();
result.add(res);
}
public void setSelectedTemplate(ScheduleTemplate selectedTemplate) {
this.selectedTemplate = selectedTemplate;
}
public ScheduleTemplate getSelectedTemplate() {
return selectedTemplate;
}
}
}

@ -1,49 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<div class="span-18 last">
<div class="span-18 last">
<div class="span-6 append-1">
<div wicket:id="createScheduleContainer">
<div><a href="#" wicket:id="createScheduleFromTemplateLink"><img wicket:id="createScheduleFromTemplateIcon" /></a><span> Create activity plan from template</span></div>
<div><a href="#" wicket:id="createEmptyScheduleLink"><img wicket:id="createEmptyScheduleIcon" /></a><span> Create empty activity plan</span></div>
</div>
</div>
</div>
<div wicket:id="scheduleContainer" class="span-18 last">
<div class="span-18 last append-bottom">
<span>Filter events by participant: </span><select wicket:id="participantOptions"></select>
</div>
<div class="span-18 last">
<a href="#" wicket:id="addProjectEventLink">
<img wicket:id="addProjectEventLinkIcon" /> Add project event
</a>
<a href="#" wicket:id="addGroupEventLink">
<img wicket:id="addGroupEventLinkIcon" /> Add group event
</a>
<a href="#" wicket:id="saveAsTemplateLink">
<img wicket:id="saveTemplateLinkIcon" /> Save as template
</a>
</div>
<div wicket:id="monthPicker" class="span-18 last prepend-top"></div>
<div wicket:id="eventListContainer" class="span-18 last">
<div class="span-18 last">
<i><span>Found </span><span wicket:id="numResults"></span><span> events</span></i>
</div>
<div class="span-18 last" wicket:id="events">
<div wicket:id="eventPanel"></div>
</div>
</div>
</div>
</div>
<div wicket:id="dialog">
<div wicket:id="dialogContainer">
<div wicket:id="containerContent">
</div>
</div>
</div>
</wicket:panel>
</body>
</html>

@ -1,331 +0,0 @@
package se.su.dsv.scipro.schedule.panels;
import java.util.ArrayList;
import java.util.List;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.ajax.form.AjaxFormComponentUpdatingBehavior;
import org.apache.wicket.ajax.markup.html.AjaxLink;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.form.DropDownChoice;
import org.apache.wicket.markup.html.link.Link;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.model.Model;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.joda.time.DateTime;
import org.odlabs.wiquery.core.effects.EffectSpeed;
import org.odlabs.wiquery.ui.dialog.Dialog;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.activityplan.facade.TemplateGenerator;
import se.su.dsv.scipro.components.monthpicker.IMonthChangedListener;
import se.su.dsv.scipro.components.monthpicker.MonthPicker;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectScheduleDao;
import se.su.dsv.scipro.data.dao.interfaces.ScheduleTemplateDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
import se.su.dsv.scipro.data.dataobjects.ScheduleTemplate;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.icons.AjaxActionIcon;
import se.su.dsv.scipro.icons.ImageIcon;
import se.su.dsv.scipro.icons.ImageObject;
import se.su.dsv.scipro.schedule.baseevent.panels.EventSchedulePanel;
import se.su.dsv.scipro.schedule.groupevent.panels.CreateGroupEventPanel;
import se.su.dsv.scipro.schedule.models.EventListModel;
import se.su.dsv.scipro.schedule.projectevent.panels.CreateProjectEventPanel;
import se.su.dsv.scipro.supervisor.pages.SupervisorScheduleTemplatesEditorPage;
import se.su.dsv.scipro.util.SelectOption;
import se.su.dsv.scipro.util.WiQueryCoreEffectsHelper;
public abstract class SchedulePlannerPanel extends Panel {//implements ISchedulePlannerPanel<EventListModel> {
private static final long serialVersionUID = 1L;
@SpringBean
private ProjectDao projectDao;
@SpringBean
private ProjectScheduleDao projectScheduleDao;
@SpringBean
private ScheduleTemplateDao scheduleTemplateDao;
private Project project;
private User user;
private WebMarkupContainer dialogContainer;
private Dialog dialog;
private Model<String> dialogTitle = new Model<String>("");
private ListView<Event> eventList;
private WebMarkupContainer eventListContainer;
private boolean isSupervisorView = false;
private EventListModel eventsModel;
public SchedulePlannerPanel(String id, Project project, boolean isSupervisorView) {
super(id);
this.project = projectDao.reLoad(project);
this.user = SciProSession.get().getUser();
this.isSupervisorView = isSupervisorView;
setup();
}
public void setup(){
eventsModel = new EventListModel(project);
dialogContainer = new WebMarkupContainer("dialogContainer");
dialogContainer.setOutputMarkupId(true);
dialogContainer.setVersioned(false);
dialogContainer.add(new EmptyPanel("containerContent"));
dialog = new Dialog("dialog");
dialog.setModal(true);
dialog.setAutoOpen(false);
dialog.add(dialogContainer);
dialog.setWidth(600);
dialog.setHeight(450);
dialog.setTitle(dialogTitle);
add(dialog);
WebMarkupContainer createScheduleContainer = new WebMarkupContainer("createScheduleContainer"){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return project.getProjectSchedule() == null;
}
};
Link<Void> createScheduleFromTemplateLink = new Link<Void>("createScheduleFromTemplateLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick() {
setResponsePage(getGeneratorPageClass(), getGeneratorPageParameters());
}
};
createScheduleFromTemplateLink.add(new ImageObject("createScheduleFromTemplateIcon", ImageObject.SIXTEEN + ImageObject.ADD));
createScheduleContainer.add(createScheduleFromTemplateLink);
Link<Void> createEmptyScheduleLink = new Link<Void>("createEmptyScheduleLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick() {
ProjectSchedule ps = new ProjectSchedule();
ps.setProject(project);
ps = projectScheduleDao.save(ps);
setResponsePage(getSchedulePageClass(), getSchedulePageParameters());
}
};
createEmptyScheduleLink.add(new ImageObject("createEmptyScheduleIcon", ImageObject.TWENTYFOUR + ImageObject.ADD));
createScheduleContainer.add(createEmptyScheduleLink);
add(createScheduleContainer);
WebMarkupContainer scheduleContainer = new WebMarkupContainer("scheduleContainer"){
private static final long serialVersionUID = 1L;
@Override
public boolean isVisible(){
return project.getProjectSchedule() != null;
}
};
AjaxLink<Void> addProjectEventLink = new AjaxLink<Void>("addProjectEventLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick(AjaxRequestTarget target) {
dialogContainer.replace(new CreateProjectEventPanel("containerContent", project, null, isSupervisorView){
private static final long serialVersionUID = 1L;
@Override
protected void onFormSubmit(AjaxRequestTarget target) {
target.addComponent(WiQueryCoreEffectsHelper.fadeIn(eventListContainer, EffectSpeed.FAST));
dialog.close(target);
}
});
target.addComponent(dialogContainer);
dialogTitle.setObject("Create a Project Event");
dialog.open(target);
}
};
// addProjectEventLink.add(new ImageIcon("addProjectEventLinkIcon", ImageIcon.ICON_ADD));
addProjectEventLink.add(new ImageObject("addProjectEventLinkIcon", ImageObject.TWENTYFOUR + ImageObject.ADD));
scheduleContainer.add(addProjectEventLink);
AjaxLink<Void> addGroupEventLink = new AjaxLink<Void>("addGroupEventLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick(AjaxRequestTarget target) {
dialogContainer.replace(new CreateGroupEventPanel("containerContent", null, project, isSupervisorView){
private static final long serialVersionUID = 1L;
@Override
protected void onFormSubmit(AjaxRequestTarget target) {
target.addComponent(WiQueryCoreEffectsHelper.fadeIn(eventListContainer, EffectSpeed.FAST));
dialog.close(target);
}
});
target.addComponent(dialogContainer);
dialogTitle.setObject("Create a Group Event");
dialog.open(target);
}
@Override
public boolean isVisible(){
return isSupervisorView;
}
};
addGroupEventLink.add(new ImageObject("addGroupEventLinkIcon", ImageObject.TWENTYFOUR + ImageObject.ADD));
scheduleContainer.add(addGroupEventLink);
AjaxLink<Void> saveAsTemplateLink = new AjaxLink<Void>("saveAsTemplateLink"){
private static final long serialVersionUID = 1L;
@Override
public void onClick(AjaxRequestTarget target) {
TemplateGenerator tg = new TemplateGenerator(project.getId());
ScheduleTemplate scheduleTemplate = tg.generate();
setResponsePage(new SupervisorScheduleTemplatesEditorPage(scheduleTemplate));
}
};
saveAsTemplateLink.add(new ImageObject("saveTemplateLinkIcon", ImageObject.TWENTYFOUR + ImageObject.EDIT));
scheduleContainer.add(saveAsTemplateLink);
final List<SelectOption<User>> participantOptions = new ArrayList<SelectOption<User>>();
for(Student s : project.getProjectParticipants()){
User u = s.getUser();
participantOptions.add(new SelectOption<User>(u.getFirstName() + " " + u.getLastName(), u));
}
SelectOption<User> all = new SelectOption<User>("All", null);
participantOptions.add(all);
final DropDownChoice<SelectOption<User>> participantsDD =
new DropDownChoice<SelectOption<User>>("participantOptions", new Model<SelectOption<User>>(all),participantOptions);
participantsDD.add(new AjaxFormComponentUpdatingBehavior("onchange"){
private static final long serialVersionUID = 1L;
@Override
protected void onUpdate(AjaxRequestTarget target) {
User selected = participantsDD.getModelObject().value;
eventsModel.setUser(selected);
target.addComponent(WiQueryCoreEffectsHelper.fadeIn(eventListContainer, EffectSpeed.FAST));
}
});
scheduleContainer.add(participantsDD);
MonthPicker mp = new MonthPicker("monthPicker");
mp.registerOnChangeListener(new IMonthChangedListener(){
private static final long serialVersionUID = 1L;
@Override
public void onSelectionChange(AjaxRequestTarget target, DateTime startDate, DateTime endDate) {
eventsModel.setTimeSpan(startDate, endDate);
target.addComponent(WiQueryCoreEffectsHelper.fadeIn(eventListContainer, EffectSpeed.FAST));
}
});
mp.fireEventOnYearChange();
scheduleContainer.add(mp);
eventListContainer = new WebMarkupContainer("eventListContainer");
eventListContainer.setOutputMarkupId(true);
eventList = new ListView<Event>("events", eventsModel){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<Event> item) {
final Event e = item.getModelObject();
item.add(new EventSchedulePanel("eventPanel", e, project, isSupervisorView){
private static final long serialVersionUID = 1L;
@Override
public void replaceAndOpenDialog(AjaxRequestTarget target,
Panel replacePanel) {
dialogContainer.replace(replacePanel);
target.addComponent(dialogContainer);
dialog.open(target);
}
@Override
public void refreshListView(AjaxRequestTarget target) {
target.addComponent(WiQueryCoreEffectsHelper.fadeIn(eventListContainer, EffectSpeed.FAST));
}
@Override
public void closeDialogAndRefreshListView(AjaxRequestTarget target) {
target.addComponent(WiQueryCoreEffectsHelper.fadeIn(eventListContainer, EffectSpeed.FAST));
dialog.close(target);
}
@Override
public void onEventDetailsClick() {
PageParameters pp = getEventPageParameters();
pp.add(Event.PP_EVENT_ID, String.valueOf(e.getId()));
setResponsePage(getEventPageClass(), pp);
}
});
add(item);
}
};
eventList.setOutputMarkupId(true);
eventListContainer.add(eventList);
eventListContainer.add(new Label("numResults", new Model<Integer>(){
private static final long serialVersionUID = 1L;
public Integer getObject(){
return eventsModel.getCount();
}
}));
scheduleContainer.add(eventListContainer);
add(scheduleContainer);
}
public abstract Class<? extends Page> getSchedulePageClass();
public abstract Class<? extends Page> getGeneratorPageClass();
public abstract Class<? extends Page> getEventPageClass();
public PageParameters getSchedulePageParameters(){
return new PageParameters();
}
public PageParameters getGeneratorPageParameters(){
return new PageParameters();
}
public PageParameters getEventPageParameters(){
return new PageParameters();
}
}

@ -1,86 +0,0 @@
package se.su.dsv.scipro.schedule.projectevent;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.extensions.ajax.markup.html.IndicatingAjaxButton;
import org.apache.wicket.markup.html.form.CheckBoxMultipleChoice;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.form.IChoiceRenderer;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.joda.time.DateMidnight;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.schedule.baseevent.EventForm;
@Deprecated
public abstract class ProjectEventForm extends EventForm<ProjectEventFormModel> {
private static final long serialVersionUID = 1L;
@SpringBean
private ProjectDao projectDao;
public ProjectEventForm(String id, final ProjectEvent e, Project p, final boolean isEdit, final boolean isSupervisorView) {
super(id, new ProjectEventFormModel(e), isEdit, isSupervisorView);
handInRequiredCheckBox.setEnabled(!eventDao.hasHandInsInHandInActivity(e));
p = projectDao.reLoad(p);
List<Student> partList = new ArrayList<Student>(p.getProjectParticipants());
IChoiceRenderer<Student> cRenderer = new IChoiceRenderer<Student>(){
private static final long serialVersionUID = 1L;
@Override
public Object getDisplayValue(Student object) {
User u = object.getUser();
return u.getFirstName() + " " + u.getLastName();
}
@Override
public String getIdValue(Student object, int index) {
return String.valueOf(object.getId());
}
};
CheckBoxMultipleChoice<Student> checkBox = new CheckBoxMultipleChoice<Student>("participants", partList, cRenderer);
add(checkBox);
IndicatingAjaxButton saveButton = new IndicatingAjaxButton("saveButton", this){
private static final long serialVersionUID = 1L;
@Override
protected void onSubmit(AjaxRequestTarget target, Form<?> form) {
ProjectEventFormModel model = (ProjectEventFormModel) form.getModelObject();
if(model.getDate().before(new DateMidnight(new Date()).toDate())){
error("Please provide a date in the future");
}
if(model.getParticipants().size() == 0){
error("The event needs at least one participant");
}
if(!form.hasError()){
try {
model.persist();
onFormSubmit(target);
} catch (IllegalStateException e){
error("You cannot remove a hand in activity when you've already handed something in");
}
}
}
@Override
protected void onError(AjaxRequestTarget target, Form<?> form) {
target.addComponent(feedbackContainer);
}
};
add(saveButton);
}
}

@ -1,70 +0,0 @@
package se.su.dsv.scipro.schedule.projectevent;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
import se.su.dsv.scipro.SciProSession;
import se.su.dsv.scipro.data.dataobjects.HandInActivity;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.schedule.baseevent.EventFormModel;
@Deprecated
public class ProjectEventFormModel extends EventFormModel<ProjectEvent> {
private static final long serialVersionUID = 1L;
private List<Student> participants = new ArrayList<Student>();
public ProjectEventFormModel(ProjectEvent e) {
super(e);
if(e.getId() != null){
event = (ProjectEvent) eventDao.reLoad(e);
}
if(event.getParticipants() != null){
setParticipants(new ArrayList<Student>(event.getParticipants()));
}
setRequireHandIn(event.isRequireHandIn());
}
public List<Student> getParticipants() {
return participants;
}
public void setParticipants(List<Student> participants) {
this.participants = participants;
}
public ProjectEvent doPersist() throws IllegalStateException {
//First check if the user is trying to remove a hand in
if(event.getId() != null && event.isRequireHandIn() && !isRequireHandIn()){
HandInActivity hia = handInActivityDao.getHandInActivity(event, event.getProjectSchedule().getProject());
if(hia != null){
//If hand ins are saved, do not allow removal...
if(hia.getHandIns().size() > 0){
throw new IllegalStateException();
}
}
}
event.setTitle(getTitle());
event.setDescription(getDescription());
event.setCreator(SciProSession.get().getUser());
event.setDueDate(getDate());
event.setParticipants(new TreeSet<Student>(participants));
event.setRequireHandIn(isRequireHandIn());
event = (ProjectEvent) eventDao.save(event);
//If the event does not have a hand in, create one
if(event.isRequireHandIn() && handInActivityDao.getHandInActivity(event, event.getProjectSchedule().getProject()) == null){
HandInActivity hia = new HandInActivity();
hia.setEvent(event);
hia.setProject(event.getProjectSchedule().getProject());
handInActivityDao.save(hia);
}
return event;
}
}

@ -1,18 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:extend>
<div class="formRow">
<strong>Select participant(s):</strong><br />
<span wicket:id="participants">
<input type="checkbox" />
</span>
</div>
<div class="formRow">
<button class="button" type="submit" wicket:id="saveButton">
Save
</button>
</div>
</wicket:extend>
</body>
</html>

@ -1,50 +0,0 @@
package se.su.dsv.scipro.schedule.projectevent.panels;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.ProjectEventDao;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.schedule.baseevent.panels.CreateEventPanel;
import se.su.dsv.scipro.schedule.projectevent.ProjectEventForm;
public abstract class CreateProjectEventPanel extends CreateEventPanel<ProjectEvent, ProjectEventForm> {
private static final long serialVersionUID = 1L;
@SpringBean
private ProjectEventDao peDao;
public CreateProjectEventPanel(String id, final Project p, final ProjectEvent e, final boolean isSupervisorView){
super(id, e, p, isSupervisorView);
}
public CreateProjectEventPanel(String id, final Project p, final boolean isSupervisorView){
super(id, null, p, isSupervisorView);
}
@Override
public ProjectEvent newEventInstance() {
ProjectEvent e = new ProjectEvent();
e.setProjectSchedule(project.getProjectSchedule());
return e;
}
@Override
public ProjectEventForm newFormInstance(boolean isEdit, boolean isSupervisorView) {
return new ProjectEventForm("eventForm", event, project, isEdit, isSupervisorView){
private static final long serialVersionUID = 1L;
@Override
protected void onFormSubmit(AjaxRequestTarget target) {
CreateProjectEventPanel.this.onFormSubmit(target);
}
};
}
@Override
public ProjectEvent reLoadEvent(ProjectEvent event) {
return peDao.reLoad(event);
}
}

@ -1,11 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:panel>
<strong>Participants:</strong>
<div class="scheduleEventParticipants" wicket:id="eventParticipants">
<span wicket:id="participant">Event participant here</span>
</div>
</wicket:panel>
</body>
</html>

@ -1,37 +0,0 @@
package se.su.dsv.scipro.schedule.projectevent.panels;
import java.util.ArrayList;
import java.util.List;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.markup.html.panel.Panel;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.ProjectEventDao;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.Student;
public class ProjectEventScheduleDetailsPanel extends Panel {
private static final long serialVersionUID = 1L;
@SpringBean
private ProjectEventDao peDao;
public ProjectEventScheduleDetailsPanel(String id, ProjectEvent e){
super(id);
e = peDao.reLoad(e);
List<Student> partList = new ArrayList<Student>();
partList.addAll(e.getParticipants());
add(new ListView<Student>("eventParticipants", partList){
private static final long serialVersionUID = 1L;
@Override
protected void populateItem(ListItem<Student> item) {
item.add(item.getModelObject().getUser().getDisplayComponent("participant"));
add(item);
}
});
}
}

@ -1,8 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:extend>
<div wicket:id="eventPanel"></div>
</wicket:extend>
</body>
</html>

@ -1,43 +0,0 @@
package se.su.dsv.scipro.supervisor.pages;
import org.apache.wicket.Page;
import org.apache.wicket.PageParameters;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.events.panels.EventPagePanel;
import se.su.dsv.scipro.exceptions.PageNotFoundException;
public class SupervisorEventPage extends AbstractSupervisorProjectDetailsPage {
@SpringBean
private EventDao eventDao;
public SupervisorEventPage(final PageParameters pp){
super(pp);
Long eventId = pp.getAsLong(Event.PP_EVENT_ID);
if(eventId == null){
throw new PageNotFoundException(this);
}
Event event = eventDao.load(eventId);
if( event == null || event.isDeleted() ) {
throw new PageNotFoundException(this);
}
add(new EventPagePanel("eventPanel", event, projectModel.getObject(), true){
private static final long serialVersionUID = 1L;
@Override
public Class<? extends Page> getSurroundingPageClass() {
return SupervisorEventPage.class;
}
});
}
}

@ -1,38 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:extend>
<h2 class="bold" wicket:id="eventTitle">Event title</h2>
<div class="span-22 last append-bottom">
<strong>Date of event:</strong>
<div>
<span wicket:id="eventDueDate">Date of event</span>
</div>
</div>
<div class="span-22 last append-bottom">
<strong>Description:</strong>
<div>
<span wicket:id="eventDescription"></span>
</div>
</div>
<div class="span-22 last append-bottom">
<strong>Creator:</strong>
<div>
<span wicket:id="eventCreator"></span>
</div>
</div>
<div wicket:id="classSpecificDetails" class="span-22 last append-bottom"></div>
<div class="span-22 last append-bottom">
<h3 class="section">Hand ins</h3>
<span wicket:id="handInMessage"></span>
<div class="span-22 last" wicket:id="handInList"></div>
</div>
<div class="span-22 last append-bottom">
<h3 class="section">Comments</h3>
<div wicket:id="commentsPanel" class="span-22 last append-bottom"></div>
</div>
</wicket:extend>
</body>
</html>

@ -1,66 +0,0 @@
package se.su.dsv.scipro.supervisor.pages;
import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.panel.EmptyPanel;
import org.apache.wicket.model.Model;
import org.apache.wicket.spring.injection.annot.SpringBean;
import se.su.dsv.scipro.commentthread.panels.CommentThreadPanel;
import se.su.dsv.scipro.components.ExpandableMultiLineLabel;
import se.su.dsv.scipro.data.dao.interfaces.GroupEventDao;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.events.panels.handins.SupervisorGroupEventPanel;
import se.su.dsv.scipro.exceptions.PageNotFoundException;
import se.su.dsv.scipro.util.DateFormatter;
public class SupervisorGroupEventPage extends AbstractSupervisorProjectDetailsPage {
@SpringBean
private GroupEventDao groupEventDao;
public SupervisorGroupEventPage(final PageParameters pp){
super(pp);
Long eventId = pp.getAsLong(Event.PP_EVENT_ID);
if(eventId == null){
throw new PageNotFoundException(this);
}
final GroupEvent ge = groupEventDao.load(eventId);
if(ge == null || ge.isDeleted() ){
throw new PageNotFoundException(this);
}
add(new Label("eventTitle", ge.getTitle()));
add(new DateFormatter().createFormattedDateLabel("eventDueDate", ge.getDueDate()));
add(ge.getCreator().getDisplayComponent("eventCreator"));
String desc = ge.getDescription() == null ? "This event has no description" : ge.getDescription();
add(new ExpandableMultiLineLabel("eventDescription", 200, desc, true));
add(ge.getPageDetailsPanel("classSpecificDetails"));
add(new Label("handInMessage", new Model<String>(){
private static final long serialVersionUID = 1L;
@Override
public String getObject(){
return ge.isRequireHandIn() ? "Below you find the participating projects and their respective hand ins" :
"This event does not require hand ins";
}
}));
if(ge.isRequireHandIn()){
add(new SupervisorGroupEventPanel("handInList", ge));
} else {
add(new EmptyPanel("handInList"));
}
add(new CommentThreadPanel("commentsPanel", ge , 10));
}
}

@ -1,8 +0,0 @@
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org/dtds.data/wicket-xhtml1.4-strict.dtd">
<body>
<wicket:extend>
<div wicket:id="generatorPanel"></div>
</wicket:extend>
</body>
</html>

Some files were not shown because too many files have changed in this diff Show More