From f5ab5b66f8745999d50818e3f4d6f85bf30d6423 Mon Sep 17 00:00:00 2001 From: Manuel Rego Casasnovas Date: Tue, 25 Aug 2009 10:20:04 +0200 Subject: [PATCH] ItEr23S08CUEdicionCalendarioLaboral: Adding history information. --- .../calendars/entities/BaseCalendar.java | 16 +- .../calendars/entities/BaseCalendarTest.java | 8 + .../calendars/BaseCalendarCRUDController.java | 87 +++++++++- .../web/calendars/BaseCalendarModel.java | 157 +++++++++++++----- .../web/calendars/IBaseCalendarModel.java | 12 +- .../src/main/webapp/calendars/_edition.zul | 63 ++++++- .../src/main/webapp/calendars/calendars.zul | 2 + 7 files changed, 281 insertions(+), 64 deletions(-) diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/BaseCalendar.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/BaseCalendar.java index a9a5ba91a..235075275 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/BaseCalendar.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/BaseCalendar.java @@ -149,7 +149,7 @@ public class BaseCalendar extends BaseEntity implements IValidable { + "because of it does not have a next calendar"); } if (previousCalendar != null) { - if (previousCalendar.getExpiringDate().compareTo(expiringDate) <= 0) { + if (expiringDate.compareTo(previousCalendar.getExpiringDate()) <= 0) { throw new IllegalArgumentException( "Expering date must be greater than expiring date of previous calendars"); } @@ -417,7 +417,7 @@ public class BaseCalendar extends BaseEntity implements IValidable { * It makes that the current calendar expires in the current date. And the * new calendar will be used from now onwards. */ - public BaseCalendar newVersion() { + public BaseCalendar newVersion() throws IllegalArgumentException { return newVersion(new LocalDate()); } @@ -426,7 +426,7 @@ public class BaseCalendar extends BaseEntity implements IValidable { * It makes that the current calendar expires in the specific date. And the * new calendar will be used from that date onwards. */ - public BaseCalendar newVersion(Date date) { + public BaseCalendar newVersion(Date date) throws IllegalArgumentException { return newVersion(new LocalDate(date)); } @@ -435,11 +435,19 @@ public class BaseCalendar extends BaseEntity implements IValidable { * It makes that the current calendar expires in the specific date. And the * new calendar will be used from that date onwards. */ - public BaseCalendar newVersion(LocalDate date) { + public BaseCalendar newVersion(LocalDate date) + throws IllegalArgumentException { if (nextCalendar != null) { nextCalendar.newVersion(date); } + if (previousCalendar != null) { + if (date.compareTo(previousCalendar.getExpiringDate()) <= 0) { + throw new IllegalArgumentException( + "Version date must be greater than expiring date of previous calendars"); + } + } + BaseCalendar nextCalendar = newCopy(); this.expiringDate = date; diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/BaseCalendarTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/BaseCalendarTest.java index 825bb383d..d758ddf01 100644 --- a/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/BaseCalendarTest.java +++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/BaseCalendarTest.java @@ -198,6 +198,14 @@ public class BaseCalendarTest { assertThat(nextCalendar, equalTo(calendar.getNextCalendar())); } + @Test(expected = IllegalArgumentException.class) + public void testCreateInvalidNewVersion() { + BaseCalendar nextCalendar = createBasicCalendar().newVersion( + FRIDAY_LOCAL_DATE); + + nextCalendar.newVersion(MONDAY_LOCAL_DATE); + } + @Test public void testGettWorkableHoursNewVersion() { BaseCalendar origCalendar = createBasicCalendar(); diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarCRUDController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarCRUDController.java index d8c63ea68..f0a35ab42 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarCRUDController.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarCRUDController.java @@ -16,6 +16,7 @@ import org.navalplanner.web.common.MessagesForUser; import org.navalplanner.web.common.OnlyOneVisible; import org.navalplanner.web.common.Util; import org.zkoss.zk.ui.Component; +import org.zkoss.zk.ui.SuspendNotAllowedException; import org.zkoss.zk.ui.WrongValueException; import org.zkoss.zk.ui.event.Event; import org.zkoss.zk.ui.event.EventListener; @@ -52,6 +53,8 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { private Window editWindow; + private Window historyWindow; + private Window confirmRemove; private boolean confirmingRemove = false; @@ -75,6 +78,7 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { super.doAfterCompose(comp); messagesForUser = new MessagesForUser(messagesContainer); comp.setVariable("controller", this, true); + historyWindow.setVisible(false); getVisibility().showOnly(listWindow); } @@ -290,6 +294,10 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { hoursIntbox.setDisabled(true); } + if (baseCalendarModel.isViewingHistory()) { + hoursIntbox.setDisabled(true); + } + hoursListcell.appendChild(hoursIntbox); item.appendChild(hoursListcell); @@ -322,6 +330,11 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { } }); + + if (baseCalendarModel.isViewingHistory()) { + defaultCheckbox.setDisabled(true); + } + defaultListcell.appendChild(defaultCheckbox); item.appendChild(defaultListcell); } @@ -331,7 +344,11 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { private void reloadCurrentWindow() { if (baseCalendarModel.isEditing()) { - Util.reloadBindings(editWindow); + if (baseCalendarModel.isViewingHistory()) { + Util.reloadBindings(historyWindow); + } else { + Util.reloadBindings(editWindow); + } } else { Util.reloadBindings(createWindow); } @@ -339,7 +356,11 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { private void reloadDayInformation() { if (baseCalendarModel.isEditing()) { - Util.reloadBindings(editWindow.getFellow("dayInformation")); + if (baseCalendarModel.isViewingHistory()) { + Util.reloadBindings(historyWindow.getFellow("dayInformation")); + } else { + Util.reloadBindings(editWindow.getFellow("dayInformation")); + } } else { Util.reloadBindings(createWindow.getFellow("dayInformation")); } @@ -357,7 +378,10 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { private void prepareParentCombo() { Combobox parentCalendars; - if (baseCalendarModel.isEditing()) { + if (baseCalendarModel.isViewingHistory()) { + parentCalendars = (Combobox) historyWindow + .getFellow("parentCalendars"); + } else if (baseCalendarModel.isEditing()) { parentCalendars = (Combobox) editWindow .getFellow("parentCalendars"); } else { @@ -416,18 +440,24 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { return baseCalendarModel.isEditing(); } - public Date getExpiringDate() { - return baseCalendarModel.getExpiringDate(); + public Date getDateValidFrom() { + return baseCalendarModel.getDateValidFrom(); } - public void setExpiringDate(Date date) { + public void setDateValidFrom(Date date) { try { - baseCalendarModel.setExpiringDate(date); + baseCalendarModel.setDateValidFrom(date); } catch (IllegalArgumentException e) { - ; + throw new WrongValueException( + editWindow.getFellow("dateValidFrom"), + e.getMessage()); } } + public Date getExpiringDate() { + return baseCalendarModel.getExpiringDate(); + } + public void goToCreateCopyForm(BaseCalendar baseCalendar) { baseCalendarModel.initCreateCopy(baseCalendar); if (baseCalendarModel.isDerived()) { @@ -521,4 +551,45 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { } + public List getHistoryVersions() { + return baseCalendarModel.getHistoryVersions(); + } + + public void goToHistoryView(BaseCalendar baseCalendar) { + baseCalendarModel.initHistoryView(baseCalendar); + if (baseCalendarModel.isDerived()) { + prepareParentCombo(); + } + + try { + Util.reloadBindings(historyWindow); + historyWindow.setVisible(true); + historyWindow.doModal(); + } catch (SuspendNotAllowedException e) { + throw new RuntimeException(e); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + + public boolean isViewingHistory() { + return baseCalendarModel.isViewingHistory(); + } + + public boolean isNotViewingHistory() { + return !isViewingHistory(); + } + + public boolean isEditingAndNotViewingHistory() { + return isEditing() && !isViewingHistory(); + } + + public void back() { + baseCalendarModel.cancelHistoryView(); + historyWindow.setVisible(false); + + Util.reloadBindings(editWindow); + getVisibility().showOnly(editWindow); + } + } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarModel.java index 3f1c396a5..df8c341f0 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarModel.java @@ -1,5 +1,6 @@ package org.navalplanner.web.calendars; +import java.util.ArrayList; import java.util.Date; import java.util.List; @@ -39,6 +40,10 @@ public class BaseCalendarModel implements IBaseCalendarModel { private boolean editing = false; + private BaseCalendar baseCalendarHistory; + + private boolean viewingHistory = false; + private ClassValidator baseCalendarValidator = new ClassValidator( BaseCalendar.class); @@ -56,7 +61,6 @@ public class BaseCalendarModel implements IBaseCalendarModel { return baseCalendarDAO.findLastVersions(); } - /* * Initial conversation steps */ @@ -73,7 +77,15 @@ public class BaseCalendarModel implements IBaseCalendarModel { editing = true; Validate.notNull(baseCalendar); - this.baseCalendar = getFromDB(baseCalendar).newVersion(); + this.baseCalendar = getFromDB(baseCalendar); + try { + this.baseCalendar = this.baseCalendar.newVersion(); + } catch (IllegalArgumentException e) { + LocalDate expiringDate = this.baseCalendar.getPreviousCalendar() + .getExpiringDate(); + this.baseCalendar = this.baseCalendar.newVersion(expiringDate + .plusDays(1)); + } forceLoadHoursPerDayAndExceptionDays(this.baseCalendar); } @@ -102,6 +114,16 @@ public class BaseCalendarModel implements IBaseCalendarModel { this.baseCalendar = baseCalendar; } + @Override + @Transactional(readOnly = true) + public void initHistoryView(BaseCalendar baseCalendar) { + viewingHistory = true; + Validate.notNull(baseCalendar); + + this.baseCalendarHistory = getFromDB(baseCalendar); + forceLoadHoursPerDayAndExceptionDays(this.baseCalendarHistory); + } + private void forceLoadHoursPerDayAndExceptionDays(BaseCalendar baseCalendar) { forceLoadHoursPerDayAndExceptionDaysBasic(baseCalendar); forceLoadHoursPerDayAndExceptionDaysPrevious(baseCalendar); @@ -155,6 +177,9 @@ public class BaseCalendarModel implements IBaseCalendarModel { @Override public BaseCalendar getBaseCalendar() { + if (viewingHistory) { + return baseCalendarHistory; + } return baseCalendar; } @@ -163,16 +188,17 @@ public class BaseCalendarModel implements IBaseCalendarModel { public List getPossibleParentCalendars() { List baseCalendars = getBaseCalendars(); - if (baseCalendar != null) { + if (getBaseCalendar() != null) { for (BaseCalendar calendar : baseCalendars) { if (isEditing()) { - if (calendar.getId().equals( - baseCalendar.getPreviousCalendar().getId())) { + if ((getBaseCalendar().getPreviousCalendar() != null) + && (calendar.getId().equals(getBaseCalendar() + .getPreviousCalendar().getId()))) { baseCalendars.remove(calendar); break; } } else { - if (calendar.getId().equals(baseCalendar.getId())) { + if (calendar.getId().equals(getBaseCalendar().getId())) { baseCalendars.remove(calendar); break; } @@ -201,104 +227,104 @@ public class BaseCalendarModel implements IBaseCalendarModel { @Override @Transactional(readOnly = true) public Integer getHoursOfDay() { - if (baseCalendar == null) { + if (getBaseCalendar() == null) { return null; } - return baseCalendar.getWorkableHours(selectedDate); + return getBaseCalendar().getWorkableHours(selectedDate); } @Override @Transactional(readOnly = true) public DayType getTypeOfDay() { - if (baseCalendar == null) { + if (getBaseCalendar() == null) { return null; } - return baseCalendar.getType(selectedDate); + return getBaseCalendar().getType(selectedDate); } @Override @Transactional(readOnly = true) public void createException(Integer hours) { if (getTypeOfDay().equals(DayType.OWN_EXCEPTION)) { - baseCalendar.updateExceptionDay(selectedDate, hours); + getBaseCalendar().updateExceptionDay(selectedDate, hours); } else { ExceptionDay day = ExceptionDay.create(selectedDate, hours); - baseCalendar.addExceptionDay(day); + getBaseCalendar().addExceptionDay(day); } } @Override public Integer getHours(Days day) { - if (baseCalendar == null) { + if (getBaseCalendar() == null) { return null; } - return baseCalendar.getHours(day); + return getBaseCalendar().getHours(day); } @Override public Boolean isDefault(Days day) { - if (baseCalendar == null) { + if (getBaseCalendar() == null) { return false; } - return baseCalendar.isDefault(day); + return getBaseCalendar().isDefault(day); } @Override public void unsetDefault(Days day) { - if (baseCalendar != null) { - baseCalendar.setHours(day, 0); + if (getBaseCalendar() != null) { + getBaseCalendar().setHours(day, 0); } } @Override public void setDefault(Days day) { - if (baseCalendar != null) { - baseCalendar.setDefault(day); + if (getBaseCalendar() != null) { + getBaseCalendar().setDefault(day); } } @Override public void setHours(Days day, Integer hours) { - if (baseCalendar != null) { - baseCalendar.setHours(day, hours); + if (getBaseCalendar() != null) { + getBaseCalendar().setHours(day, hours); } } @Override public boolean isExceptional() { - if (baseCalendar == null) { + if (getBaseCalendar() == null) { return false; } - ExceptionDay day = baseCalendar.getOwnExceptionDay(selectedDate); + ExceptionDay day = getBaseCalendar().getOwnExceptionDay(selectedDate); return (day != null); } @Override public void removeException() { - baseCalendar.removeExceptionDay(selectedDate); + getBaseCalendar().removeExceptionDay(selectedDate); } @Override public boolean isDerived() { - if (baseCalendar == null) { + if (getBaseCalendar() == null) { return false; } - return baseCalendar.isDerived(); + return getBaseCalendar().isDerived(); } @Override public BaseCalendar getParent() { - if (baseCalendar == null) { + if (getBaseCalendar() == null) { return null; } - return baseCalendar.getParent(); + return getBaseCalendar().getParent(); } @Override @@ -311,26 +337,37 @@ public class BaseCalendarModel implements IBaseCalendarModel { } forceLoadHoursPerDayAndExceptionDays(parent); - if (baseCalendar != null) { - baseCalendar.setParent(parent); + if (getBaseCalendar() != null) { + getBaseCalendar().setParent(parent); } } @Override @Transactional(readOnly = true) public boolean isParent() { - if (baseCalendar == null) { + if (getBaseCalendar() == null) { return false; } - return !baseCalendarDAO.findByParent(baseCalendar).isEmpty(); + return !baseCalendarDAO.findByParent(getBaseCalendar()).isEmpty(); } @Override public Date getExpiringDate() { - if ((baseCalendar != null) - && (baseCalendar.getPreviousCalendar() != null)) { - LocalDate expiringDate = baseCalendar.getPreviousCalendar() + if ((getBaseCalendar() != null) + && (getBaseCalendar().getExpiringDate() != null)) { + return getBaseCalendar().getExpiringDate().toDateTimeAtStartOfDay() + .toDate(); + } + + return null; + } + + @Override + public Date getDateValidFrom() { + if ((getBaseCalendar() != null) + && (getBaseCalendar().getPreviousCalendar() != null)) { + LocalDate expiringDate = getBaseCalendar().getPreviousCalendar() .getExpiringDate(); return expiringDate.toDateTimeAtStartOfDay().toDate(); } @@ -339,13 +376,35 @@ public class BaseCalendarModel implements IBaseCalendarModel { } @Override - public void setExpiringDate(Date date) { - if ((baseCalendar != null) - && (baseCalendar.getPreviousCalendar() != null)) { - baseCalendar.getPreviousCalendar().setExpiringDate(date); + public void setDateValidFrom(Date date) { + if ((getBaseCalendar() != null) + && (getBaseCalendar().getPreviousCalendar() != null)) { + getBaseCalendar().getPreviousCalendar().setExpiringDate(date); } } + @Override + public List getHistoryVersions() { + if (getBaseCalendar() == null) { + return null; + } + + List history = new ArrayList(); + + BaseCalendar current = getBaseCalendar().getPreviousCalendar(); + while (current != null) { + history.add(current); + current = current.getPreviousCalendar(); + } + + return history; + } + + @Override + public boolean isViewingHistory() { + return this.viewingHistory; + } + /* * Final conversation steps */ @@ -354,20 +413,20 @@ public class BaseCalendarModel implements IBaseCalendarModel { @Transactional public void confirmSave() throws ValidationException { InvalidValue[] invalidValues = baseCalendarValidator - .getInvalidValues(baseCalendar); + .getInvalidValues(getBaseCalendar()); if (invalidValues.length > 0) { throw new ValidationException(invalidValues); } - baseCalendar.checkValid(); - baseCalendarDAO.save(baseCalendar); + getBaseCalendar().checkValid(); + baseCalendarDAO.save(getBaseCalendar()); } @Override @Transactional public void confirmRemove() { try { - baseCalendarDAO.remove(baseCalendar.getId()); + baseCalendarDAO.remove(getBaseCalendar().getId()); } catch (InstanceNotFoundException e) { throw new RuntimeException(e); } @@ -378,8 +437,18 @@ public class BaseCalendarModel implements IBaseCalendarModel { resetState(); } + @Override + public void cancelHistoryView() { + viewingHistory = false; + resetStateHistory(); + } + private void resetState() { baseCalendar = null; } + private void resetStateHistory() { + baseCalendarHistory = null; + } + } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/IBaseCalendarModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/IBaseCalendarModel.java index 4641b29a1..018d94ef7 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/IBaseCalendarModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/IBaseCalendarModel.java @@ -59,6 +59,8 @@ public interface IBaseCalendarModel { void initCreateCopy(BaseCalendar baseCalendar); + void initHistoryView(BaseCalendar baseCalendar); + /* * Intermediate conversation steps */ @@ -103,7 +105,13 @@ public interface IBaseCalendarModel { Date getExpiringDate(); - void setExpiringDate(Date date); + Date getDateValidFrom(); + + void setDateValidFrom(Date date); + + List getHistoryVersions(); + + boolean isViewingHistory(); /* * Final conversation steps @@ -115,4 +123,6 @@ public interface IBaseCalendarModel { void cancel(); + void cancelHistoryView(); + } diff --git a/navalplanner-webapp/src/main/webapp/calendars/_edition.zul b/navalplanner-webapp/src/main/webapp/calendars/_edition.zul index 1250e1431..16abd8ba5 100644 --- a/navalplanner-webapp/src/main/webapp/calendars/_edition.zul +++ b/navalplanner-webapp/src/main/webapp/calendars/_edition.zul @@ -1,5 +1,16 @@ + + + + + + + + + + @@ -8,7 +19,8 @@ @@ -17,7 +29,8 @@ - + + + + + + + + + + \ No newline at end of file diff --git a/navalplanner-webapp/src/main/webapp/calendars/calendars.zul b/navalplanner-webapp/src/main/webapp/calendars/calendars.zul index 93833ff26..4f95e6c54 100644 --- a/navalplanner-webapp/src/main/webapp/calendars/calendars.zul +++ b/navalplanner-webapp/src/main/webapp/calendars/calendars.zul @@ -21,6 +21,8 @@ +