From f3c665aa8d43387fbd9df6c4f9f89f25653ce43f Mon Sep 17 00:00:00 2001 From: Manuel Rego Casasnovas Date: Tue, 1 Sep 2009 18:24:49 +0200 Subject: [PATCH] ItEr23S08CUEdicionCalendarioLaboral: Refactoring calendar model. Now a new class CalendarData appears, where the calendar versions will be stored. --- .../calendars/daos/BaseCalendarDAO.java | 13 +- .../calendars/daos/IBaseCalendarDAO.java | 2 +- .../calendars/entities/BaseCalendar.java | 532 ++++++++++-------- .../calendars/entities/CalendarData.java | 111 ++++ .../calendars/entities/Calendars.hbm.xml | 46 +- .../calendars/daos/BaseCalendarDAOTest.java | 123 ++-- .../calendars/entities/BaseCalendarTest.java | 261 +++------ .../calendars/BaseCalendarCRUDController.java | 60 +- .../web/calendars/BaseCalendarModel.java | 169 +++--- .../web/calendars/IBaseCalendarModel.java | 9 +- .../src/main/webapp/calendars/_edition.zul | 1 + .../web/calendars/BaseCalendarModelTest.java | 44 +- 12 files changed, 746 insertions(+), 625 deletions(-) create mode 100644 navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CalendarData.java diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/BaseCalendarDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/BaseCalendarDAO.java index 110b412dd..773529872 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/BaseCalendarDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/BaseCalendarDAO.java @@ -32,16 +32,21 @@ public class BaseCalendarDAO extends GenericDAOHibernate return new ArrayList(); } - Criteria c = getSession().createCriteria(BaseCalendar.class); - c.add(Restrictions.eq("parent", baseCalendar)); + Criteria c = getSession().createCriteria(BaseCalendar.class) + .createCriteria("calendarDataVersions", "v"); + c.add(Restrictions.eq("v.parent", baseCalendar)); return (List) c.list(); } @Override - public List findLastVersions() { + public List findByName(BaseCalendar baseCalendar) { + if (baseCalendar == null) { + return new ArrayList(); + } + Criteria c = getSession().createCriteria(BaseCalendar.class); - c.add(Restrictions.isNull("nextCalendar")); + c.add(Restrictions.eq("name", baseCalendar.getName())); return (List) c.list(); } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/IBaseCalendarDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/IBaseCalendarDAO.java index 679f05c0a..5fa4fbab3 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/IBaseCalendarDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/IBaseCalendarDAO.java @@ -11,6 +11,6 @@ public interface IBaseCalendarDAO extends IGenericDAO { List findByParent(BaseCalendar baseCalendar); - List findLastVersions(); + List findByName(BaseCalendar baseCalendar); } 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 f0a77ee71..b42cd58ea 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 @@ -1,17 +1,17 @@ package org.navalplanner.business.calendars.entities; +import java.util.ArrayList; import java.util.Collections; import java.util.Date; -import java.util.HashMap; import java.util.HashSet; -import java.util.Map; +import java.util.List; import java.util.Set; +import org.hibernate.validator.NotEmpty; import org.joda.time.DateTimeConstants; import org.joda.time.LocalDate; +import org.navalplanner.business.calendars.entities.CalendarData.Days; import org.navalplanner.business.common.BaseEntity; -import org.navalplanner.business.common.IValidable; -import org.navalplanner.business.common.exceptions.ValidationException; /** * Represents a calendar with some exception days. A calendar is valid till the @@ -23,33 +23,23 @@ import org.navalplanner.business.common.exceptions.ValidationException; * * @author Manuel Rego Casasnovas */ -public class BaseCalendar extends BaseEntity implements IValidable { +public class BaseCalendar extends BaseEntity { private static final Integer DEFAULT_VALUE = 0; public static BaseCalendar create() { BaseCalendar baseCalendar = new BaseCalendar(); baseCalendar.setNewObject(true); + baseCalendar.calendarDataVersions.add(CalendarData.create()); return baseCalendar; } + @NotEmpty private String name; - private Map hoursPerDay; - - private BaseCalendar parent; - - private BaseCalendar previousCalendar; - - private BaseCalendar nextCalendar; - - private LocalDate expiringDate; - private Set exceptions = new HashSet(); - public enum Days { - MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY - } + private List calendarDataVersions = new ArrayList(); public enum DayType { NORMAL, ZERO_HOURS, OWN_EXCEPTION, ANCESTOR_EXCEPTION @@ -59,120 +49,50 @@ public class BaseCalendar extends BaseEntity implements IValidable { * Constructor for hibernate. Do not use! */ public BaseCalendar() { - hoursPerDay = new HashMap(); - setHoursForDay(Days.MONDAY, null); - setHoursForDay(Days.TUESDAY, null); - setHoursForDay(Days.WEDNESDAY, null); - setHoursForDay(Days.THURSDAY, null); - setHoursForDay(Days.FRIDAY, null); - setHoursForDay(Days.SATURDAY, null); - setHoursForDay(Days.SUNDAY, null); } public void setName(String name) { - if (nextCalendar != null) { - nextCalendar.setName(name); - } else { - this.name = name; - } + this.name = name; } public String getName() { - if (nextCalendar != null) { - return nextCalendar.getName(); - } - return name; } - public Map getHoursPerDay() { - return hoursPerDay; - } - - public Integer getHours(Days day) { - if ((getHoursForDay(day) == null) && (parent != null)) { - return parent.getHours(day); - } else { - return valueIfNotNullElseDefaultValue(getHoursForDay(day)); - } - } - - private Integer valueIfNotNullElseDefaultValue(Integer hours) { - if (hours == null) { - return DEFAULT_VALUE; - } - return hours; - } - - public void setHours(Days day, Integer hours) - throws IllegalArgumentException { - setHoursForDay(day, hours); - } - - private void setHoursForDay(Days day, Integer hours) - throws IllegalArgumentException { - if ((hours != null) && (hours < 0)) { - throw new IllegalArgumentException( - "The number of hours for a day can not be negative"); - } - hoursPerDay.put(day.ordinal(), hours); - } - - private Integer getHoursForDay(Days day) { - return hoursPerDay.get(day.ordinal()); - } - - public boolean isDefault(Days day) { - return (getHoursForDay(day) == null); - } - - public void setDefault(Days day) { - setHoursForDay(day, null); - } - public BaseCalendar getParent() { - return parent; + return getLastCalendarData().getParent(); + } + + public BaseCalendar getParent(Date date) { + return getParent(new LocalDate(date)); + } + + public BaseCalendar getParent(LocalDate date) { + return getCalendarData(date).getParent(); + } + + public void setParent(BaseCalendar parent) { + getLastCalendarData().setParent(parent); + } + + public void setParent(BaseCalendar parent, Date date) { + setParent(parent, new LocalDate(date)); + } + + public void setParent(BaseCalendar parent, LocalDate date) { + getCalendarData(date).setParent(parent); } public boolean isDerived() { - return (parent != null); + return (getParent() != null); } - public BaseCalendar getPreviousCalendar() { - return previousCalendar; + public boolean isDerived(Date date) { + return isDerived(new LocalDate(date)); } - public BaseCalendar getNextCalendar() { - return nextCalendar; - } - - public LocalDate getExpiringDate() { - return expiringDate; - } - - public void setExpiringDate(Date expiringDate) - throws UnsupportedOperationException, IllegalArgumentException { - setExpiringDate(new LocalDate(expiringDate)); - } - - public void setExpiringDate(LocalDate expiringDate) - throws UnsupportedOperationException, IllegalArgumentException { - if (nextCalendar == null) { - throw new UnsupportedOperationException( - "Can not set the expiring date " - + "because of it does not have a next calendar"); - } - if (expiringDate.compareTo(new LocalDate()) <= 0) { - throw new IllegalArgumentException( - "Expering date must be greater than current date"); - } - if (previousCalendar != null) { - if (expiringDate.compareTo(previousCalendar.getExpiringDate()) <= 0) { - throw new IllegalArgumentException( - "Expering date must be greater than expiring date of previous calendars"); - } - } - this.expiringDate = expiringDate; + public boolean isDerived(LocalDate date) { + return (getParent(date) != null); } public Set getOwnExceptions() { @@ -183,8 +103,27 @@ public class BaseCalendar extends BaseEntity implements IValidable { Set exceptionDays = new HashSet(); exceptionDays.addAll(exceptions); - if (parent != null) { - for (ExceptionDay exceptionDay : parent.getExceptions()) { + if (getParent() != null) { + for (ExceptionDay exceptionDay : getParent().getExceptions()) { + if (!isExceptionDayAlreadyInExceptions(exceptionDay)) { + exceptionDays.add(exceptionDay); + } + } + } + + return Collections.unmodifiableSet(exceptionDays); + } + + public Set getExceptions(Date date) { + return getExceptions(date); + } + + public Set getExceptions(LocalDate date) { + Set exceptionDays = new HashSet(); + exceptionDays.addAll(exceptions); + + if (getParent(date) != null) { + for (ExceptionDay exceptionDay : getParent(date).getExceptions()) { if (!isExceptionDayAlreadyInExceptions(exceptionDay)) { exceptionDays.add(exceptionDay); } @@ -211,18 +150,12 @@ public class BaseCalendar extends BaseEntity implements IValidable { "You can not modify the past adding a new exception day"); } - if (shouldUsePreviousCalendar(day.getDate())) { - previousCalendar.addExceptionDay(day); - } else if (shouldUseNextCalendar(day.getDate())) { - nextCalendar.addExceptionDay(day); - } else { - if (isExceptionDayAlreadyInExceptions(day)) { - throw new IllegalArgumentException( - "This day is already in the exception days"); - } - - exceptions.add(day); + if (isExceptionDayAlreadyInExceptions(day)) { + throw new IllegalArgumentException( + "This day is already in the exception days"); } + + exceptions.add(day); } public void removeExceptionDay(Date date) throws IllegalArgumentException { @@ -236,19 +169,13 @@ public class BaseCalendar extends BaseEntity implements IValidable { "You can not modify the past removing an exception day"); } - if (shouldUsePreviousCalendar(date)) { - previousCalendar.removeExceptionDay(date); - } else if (shouldUseNextCalendar(date)) { - nextCalendar.removeExceptionDay(date); - } else { - ExceptionDay day = getOwnExceptionDay(date); - if (day == null) { - throw new IllegalArgumentException( - "There is not an exception day on that date"); - } - - exceptions.remove(day); + ExceptionDay day = getOwnExceptionDay(date); + if (day == null) { + throw new IllegalArgumentException( + "There is not an exception day on that date"); } + + exceptions.remove(day); } public void updateExceptionDay(Date date, Integer hours) @@ -268,12 +195,6 @@ public class BaseCalendar extends BaseEntity implements IValidable { } public ExceptionDay getOwnExceptionDay(LocalDate date) { - if (shouldUsePreviousCalendar(date)) { - return previousCalendar.getOwnExceptionDay(date); - } else if (shouldUseNextCalendar(date)) { - return nextCalendar.getOwnExceptionDay(date); - } - for (ExceptionDay exceptionDay : exceptions) { if (exceptionDay.getDate().equals(date)) { return exceptionDay; @@ -288,13 +209,7 @@ public class BaseCalendar extends BaseEntity implements IValidable { } public ExceptionDay getExceptionDay(LocalDate date) { - if (shouldUsePreviousCalendar(date)) { - return previousCalendar.getExceptionDay(date); - } else if (shouldUseNextCalendar(date)) { - return nextCalendar.getExceptionDay(date); - } - - for (ExceptionDay exceptionDay : getExceptions()) { + for (ExceptionDay exceptionDay : getExceptions(date)) { if (exceptionDay.getDate().equals(date)) { return exceptionDay; } @@ -303,25 +218,6 @@ public class BaseCalendar extends BaseEntity implements IValidable { return null; } - private boolean shouldUsePreviousCalendar(LocalDate date) { - return ((previousCalendar != null) && (date.compareTo(previousCalendar - .getExpiringDate()) < 0)); - } - - private boolean shouldUseNextCalendar(LocalDate date) { - if ((getExpiringDate() != null) - && (getExpiringDate().compareTo(date) <= 0)) { - if (nextCalendar == null) { - throw new RuntimeException("A next calendar should exist " - + "if current calendar has a expiring date fixed"); - } - - return true; - } - - return false; - } - /** * Returns the number of workable hours for a specific date depending on the * calendar restrictions. @@ -335,45 +231,61 @@ public class BaseCalendar extends BaseEntity implements IValidable { * calendar restrictions. */ public Integer getWorkableHours(LocalDate date) { - if (shouldUsePreviousCalendar(date)) { - return previousCalendar.getWorkableHours(date); - } else if (shouldUseNextCalendar(date)) { - return nextCalendar.getWorkableHours(date); - } - - for (ExceptionDay exceptionDay : getExceptions()) { - if (exceptionDay.getDate().equals(date)) { - return exceptionDay.getHours(); - } + ExceptionDay exceptionDay = getExceptionDay(date); + if (exceptionDay != null) { + return exceptionDay.getHours(); } switch (date.getDayOfWeek()) { case DateTimeConstants.MONDAY: - return getHours(Days.MONDAY); + return getHours(date, Days.MONDAY); case DateTimeConstants.TUESDAY: - return getHours(Days.TUESDAY); + return getHours(date, Days.TUESDAY); case DateTimeConstants.WEDNESDAY: - return getHours(Days.WEDNESDAY); + return getHours(date, Days.WEDNESDAY); case DateTimeConstants.THURSDAY: - return getHours(Days.THURSDAY); + return getHours(date, Days.THURSDAY); case DateTimeConstants.FRIDAY: - return getHours(Days.FRIDAY); + return getHours(date, Days.FRIDAY); case DateTimeConstants.SATURDAY: - return getHours(Days.SATURDAY); + return getHours(date, Days.SATURDAY); case DateTimeConstants.SUNDAY: - return getHours(Days.SUNDAY); + return getHours(date, Days.SUNDAY); default: throw new RuntimeException("Day of week out of range!"); } } + public Integer getHours(Date date, Days day) { + return getHours(new LocalDate(date), day); + } + + public Integer getHours(LocalDate date, Days day) { + CalendarData calendarData = getCalendarData(date); + + Integer hours = calendarData.getHours(day); + BaseCalendar parent = getParent(date); + if ((hours == null) && (parent != null)) { + return parent.getHours(date, day); + } + + return valueIfNotNullElseDefaultValue(hours); + } + + private Integer valueIfNotNullElseDefaultValue(Integer hours) { + if (hours == null) { + return DEFAULT_VALUE; + } + return hours; + } + /** * Returns the number of workable hours for a specific period depending on * the calendar restrictions. @@ -416,18 +328,6 @@ public class BaseCalendar extends BaseEntity implements IValidable { return getWorkableHours(init, end); } - @Override - public void checkValid() throws ValidationException { - if ((nextCalendar == null) && (expiringDate != null)) { - throw new ValidationException("A next calendar should exist " - + "if current calendar has a expiring date fixed"); - } - if ((nextCalendar != null) && (expiringDate == null)) { - throw new ValidationException("A expiring date should be fixed" - + "if current calendar has a next calendar"); - } - } - /** * Creates a new {@link BaseCalendar} derived from the current calendar. The * new calendar will be the child of the current calendar. @@ -436,7 +336,7 @@ public class BaseCalendar extends BaseEntity implements IValidable { */ public BaseCalendar newDerivedCalendar() { BaseCalendar derivedCalendar = create(); - derivedCalendar.parent = this; + derivedCalendar.setParent(this); return derivedCalendar; } @@ -445,8 +345,8 @@ 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) throws IllegalArgumentException { - return newVersion(new LocalDate(date)); + public void newVersion(Date date) throws IllegalArgumentException { + newVersion(new LocalDate(date)); } /** @@ -454,48 +354,37 @@ 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 void newVersion(LocalDate date) throws IllegalArgumentException { if (date.compareTo(new LocalDate()) <= 0) { throw new IllegalArgumentException( "Date for new version must be greater than current date"); } - if (nextCalendar != null) { - return nextCalendar.newVersion(date); + CalendarData calendarData = getCalendarDataBeforeTheLastIfAny(); + if ((calendarData.getExpiringDate() != null) + && (date.compareTo(calendarData.getExpiringDate()) <= 0)) { + throw new IllegalArgumentException( + "Version date must be greater than expiring date of " + + "all versions of this calendar"); } - if (previousCalendar != null) { - if (date.compareTo(previousCalendar.getExpiringDate()) <= 0) { - throw new IllegalArgumentException( - "Version date must be greater than expiring date of " + - "all versions of this calendar"); - } - } + getLastCalendarData().setExpiringDate(date); - BaseCalendar nextCalendar = newCopy(); - - this.expiringDate = date; - - this.nextCalendar = nextCalendar; - nextCalendar.previousCalendar = this; - - nextCalendar.name = this.name; - - return nextCalendar; + CalendarData newCalendarData = CalendarData.create(); + newCalendarData.setParent(getLastCalendarData().getParent()); + calendarDataVersions.add(newCalendarData); } public BaseCalendar newCopy() { - if (nextCalendar != null) { - return nextCalendar.newCopy(); - } - BaseCalendar copy = create(); copy.name = this.name; - copy.hoursPerDay = new HashMap(this.hoursPerDay); + copy.calendarDataVersions = new ArrayList(); + for (CalendarData calendarData : this.calendarDataVersions) { + copy.calendarDataVersions.add(calendarData.copy()); + } copy.exceptions = new HashSet(this.exceptions); - copy.parent = this.parent; return copy; } @@ -520,23 +409,178 @@ public class BaseCalendar extends BaseEntity implements IValidable { return DayType.NORMAL; } - public void setParent(BaseCalendar parent) - throws IllegalArgumentException { - this.parent = parent; + public List getCalendarDataVersions() { + return Collections.unmodifiableList(calendarDataVersions); } - public BaseCalendar getCalendarVersion(Date date) { - return getCalendarVersion(new LocalDate(date)); - } - - public BaseCalendar getCalendarVersion(LocalDate date) { - if (shouldUsePreviousCalendar(date)) { - return previousCalendar.getCalendarVersion(date); - } else if (shouldUseNextCalendar(date)) { - return nextCalendar.getCalendarVersion(date); - } else { - return this; + private CalendarData getCalendarData(LocalDate date) { + for (CalendarData calendarData : calendarDataVersions) { + if (calendarData.getExpiringDate() == null) { + return calendarData; + } else { + if (date.compareTo(calendarData.getExpiringDate()) < 0) { + return calendarData; + } + } } + + throw new RuntimeException("Some version should not be expired"); + } + + private CalendarData getLastCalendarData() { + if (calendarDataVersions.isEmpty()) { + return null; + } + return calendarDataVersions.get(calendarDataVersions.size() - 1); + } + + public void setHours(Days day, Integer hours) { + CalendarData calendarData = getLastCalendarData(); + calendarData.setHours(day, hours); + } + + public void setHours(Days day, Integer hours, Date date) { + setHours(day, hours, new LocalDate(date)); + } + + public void setHours(Days day, Integer hours, LocalDate date) { + CalendarData calendarData = getCalendarData(date); + calendarData.setHours(day, hours); + } + + private CalendarData getCalendarDataBeforeTheLastIfAny() { + if (calendarDataVersions.size() <= 1) { + return getLastCalendarData(); + } + return calendarDataVersions.get(calendarDataVersions.size() - 2); + } + + public boolean isDefault(Days day) { + CalendarData calendarData = getLastCalendarData(); + return calendarData.isDefault(day); + } + + public boolean isDefault(Days day, Date date) { + return isDefault(day, new LocalDate(date)); + } + + public boolean isDefault(Days day, LocalDate date) { + CalendarData calendarData = getCalendarData(date); + return calendarData.isDefault(day); + } + + public void setDefault(Days day) { + CalendarData calendarData = getLastCalendarData(); + calendarData.setDefault(day); + } + + public void setDefault(Days day, Date date) { + setDefault(day, new LocalDate(date)); + } + + public void setDefault(Days day, LocalDate date) { + CalendarData calendarData = getCalendarData(date); + calendarData.setDefault(day); + } + + public LocalDate getExpiringDate() { + return getLastCalendarData().getExpiringDate(); + } + + public LocalDate getExpiringDate(Date date) { + return getExpiringDate(new LocalDate(date)); + } + + public LocalDate getExpiringDate(LocalDate date) { + return getCalendarData(date).getExpiringDate(); + } + + public void setExpiringDate(Date expiringDate) { + setExpiringDate(new LocalDate(expiringDate)); + } + + public void setExpiringDate(LocalDate expiringDate) { + setExpiringDate(expiringDate, new LocalDate()); + } + + public void setExpiringDate(Date expiringDate, Date date) + throws IllegalArgumentException { + setExpiringDate(new LocalDate(expiringDate), new LocalDate(date)); + } + + public void setExpiringDate(LocalDate expiringDate, LocalDate date) + throws IllegalArgumentException { + CalendarData calendarData = getCalendarData(date); + setExpiringDate(calendarData, expiringDate); + } + + private void setExpiringDate(CalendarData calendarData, + LocalDate expiringDate) throws IllegalArgumentException { + if (calendarData.getExpiringDate() == null) { + throw new IllegalArgumentException("Can not set the expiring date " + + "because of this is the last version"); + } + + if (expiringDate.compareTo(new LocalDate()) <= 0) { + throw new IllegalArgumentException( + "This date must be greater than current date"); + } + + Integer index = calendarDataVersions.indexOf(calendarData); + if (index > 0) { + CalendarData preivousCalendarData = calendarDataVersions.get(index - 1); + if (expiringDate.compareTo(preivousCalendarData.getExpiringDate()) <= 0) { + throw new IllegalArgumentException( + "This date must be greater than expiring date of previous calendars"); + } + } + + calendarData.setExpiringDate(expiringDate); + } + + private CalendarData getPreviousCalendarData(LocalDate date) { + CalendarData calendarData = getCalendarData(date); + Integer index = calendarDataVersions.indexOf(calendarData) - 1; + if (index < 0) { + return null; + } + return calendarDataVersions.get(index); + } + + public LocalDate getValidFrom(Date date) { + return getValidFrom(new LocalDate(date)); + } + + public LocalDate getValidFrom(LocalDate date) { + CalendarData calendarData = getPreviousCalendarData(date); + if (calendarData == null) { + return null; + } + return calendarData.getExpiringDate(); + } + + public void setValidFrom(Date validFromDate, Date date) { + setValidFrom(new LocalDate(validFromDate), new LocalDate(date)); + } + + public void setValidFrom(LocalDate validFromDate, LocalDate date) + throws IllegalArgumentException { + CalendarData calendarData = getPreviousCalendarData(date); + if (calendarData == null) { + throw new IllegalArgumentException( + "You can not set this date for the first version"); + } + setExpiringDate(calendarData, validFromDate); + } + + public boolean isLastVersion(Date date) { + return isLastVersion(new LocalDate(date)); + } + + public boolean isLastVersion(LocalDate date) { + CalendarData calendarData = getCalendarData(date); + Integer index = calendarDataVersions.indexOf(calendarData); + return (index == (calendarDataVersions.size() - 1)); } } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CalendarData.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CalendarData.java new file mode 100644 index 000000000..466462449 --- /dev/null +++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CalendarData.java @@ -0,0 +1,111 @@ +package org.navalplanner.business.calendars.entities; + +import java.util.Date; +import java.util.HashMap; +import java.util.Map; + +import org.joda.time.LocalDate; +import org.navalplanner.business.common.BaseEntity; + +/** + * Represents the information about the calendar that can change through time. + * + * @author Manuel Rego Casasnovas + */ +public class CalendarData extends BaseEntity { + + public static CalendarData create() { + CalendarData calendarData = new CalendarData(); + calendarData.setNewObject(true); + return calendarData; + } + + private Map hoursPerDay; + + private LocalDate expiringDate; + + private BaseCalendar parent; + + public enum Days { + MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY + } + + /** + * Constructor for hibernate. Do not use! + */ + public CalendarData() { + hoursPerDay = new HashMap(); + setHoursForDay(Days.MONDAY, null); + setHoursForDay(Days.TUESDAY, null); + setHoursForDay(Days.WEDNESDAY, null); + setHoursForDay(Days.THURSDAY, null); + setHoursForDay(Days.FRIDAY, null); + setHoursForDay(Days.SATURDAY, null); + setHoursForDay(Days.SUNDAY, null); + } + + public Map getHoursPerDay() { + return hoursPerDay; + } + + public Integer getHours(Days day) { + return getHoursForDay(day); + } + + public void setHours(Days day, Integer hours) + throws IllegalArgumentException { + setHoursForDay(day, hours); + } + + private void setHoursForDay(Days day, Integer hours) + throws IllegalArgumentException { + if ((hours != null) && (hours < 0)) { + throw new IllegalArgumentException( + "The number of hours for a day can not be negative"); + } + hoursPerDay.put(day.ordinal(), hours); + } + + private Integer getHoursForDay(Days day) { + return hoursPerDay.get(day.ordinal()); + } + + public boolean isDefault(Days day) { + return (getHoursForDay(day) == null); + } + + public void setDefault(Days day) { + setHoursForDay(day, null); + } + + public LocalDate getExpiringDate() { + return expiringDate; + } + + public void setExpiringDate(Date expiringDate) { + setExpiringDate(new LocalDate(expiringDate)); + } + + public void setExpiringDate(LocalDate expiringDate) { + this.expiringDate = expiringDate; + } + + public CalendarData copy() { + CalendarData copy = create(); + + copy.hoursPerDay = new HashMap(this.hoursPerDay); + copy.expiringDate = this.expiringDate; + copy.parent = this.parent; + + return copy; + } + + public BaseCalendar getParent() { + return parent; + } + + public void setParent(BaseCalendar parent) { + this.parent = parent; + } + +} diff --git a/navalplanner-business/src/main/resources/org/navalplanner/business/calendars/entities/Calendars.hbm.xml b/navalplanner-business/src/main/resources/org/navalplanner/business/calendars/entities/Calendars.hbm.xml index b40787f24..13162c42a 100644 --- a/navalplanner-business/src/main/resources/org/navalplanner/business/calendars/entities/Calendars.hbm.xml +++ b/navalplanner-business/src/main/resources/org/navalplanner/business/calendars/entities/Calendars.hbm.xml @@ -12,30 +12,19 @@ - - - - - - - - - - - - - - - + + + + + + + @@ -56,4 +45,25 @@ + + + + + 100 + + + + + + + + + + + + + + + diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/daos/BaseCalendarDAOTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/daos/BaseCalendarDAOTest.java index 395dc9c34..4ab4df2a0 100644 --- a/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/daos/BaseCalendarDAOTest.java +++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/daos/BaseCalendarDAOTest.java @@ -1,8 +1,6 @@ package org.navalplanner.business.test.calendars.daos; import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.hamcrest.CoreMatchers.nullValue; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; @@ -13,6 +11,7 @@ import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING import java.util.List; import org.hibernate.SessionFactory; +import org.hibernate.validator.InvalidStateException; import org.joda.time.LocalDate; import org.junit.Test; import org.junit.runner.RunWith; @@ -95,29 +94,18 @@ public class BaseCalendarDAOTest { BaseCalendar calendar = BaseCalendarTest.createBasicCalendar(); baseCalendarDAO.save(calendar); - BaseCalendar nextCalendar = calendar.newVersion((new LocalDate()) - .plusDays(1)); - baseCalendarDAO.save(nextCalendar); + calendar.newVersion((new LocalDate()).plusDays(1)); + baseCalendarDAO.save(calendar); try { BaseCalendar savedCalendar = baseCalendarDAO.find(calendar.getId()); - assertThat(savedCalendar.getPreviousCalendar(), nullValue()); - assertThat(savedCalendar.getNextCalendar(), notNullValue()); - assertThat(savedCalendar.getNextCalendar(), equalTo(nextCalendar)); - - BaseCalendar savedNextCalendar = baseCalendarDAO - .find(nextCalendar - .getId()); - assertThat(savedNextCalendar.getPreviousCalendar(), notNullValue()); - assertThat(savedNextCalendar.getNextCalendar(), nullValue()); - assertThat(savedNextCalendar.getPreviousCalendar(), - equalTo(calendar)); + assertThat(savedCalendar.getCalendarDataVersions().size(), + equalTo(2)); } catch (InstanceNotFoundException e) { fail("It should not throw an exception"); } - } @Test(expected = DataIntegrityViolationException.class) @@ -141,19 +129,16 @@ public class BaseCalendarDAOTest { public void removeVersions() throws InstanceNotFoundException { BaseCalendar calendar = BaseCalendarTest.createBasicCalendar(); baseCalendarDAO.save(calendar); - BaseCalendar newCalendar = calendar.newVersion((new LocalDate()) - .plusDays(1)); - System.out.println(newCalendar.getName()); - baseCalendarDAO.save(newCalendar); + calendar.newVersion((new LocalDate()).plusDays(1)); + baseCalendarDAO.save(calendar); baseCalendarDAO.flush(); session.getCurrentSession().evict(calendar); - session.getCurrentSession().evict(newCalendar); baseCalendarDAO.remove(calendar.getId()); baseCalendarDAO.flush(); - baseCalendarDAO.find(newCalendar.getId()); + baseCalendarDAO.find(calendar.getId()); } @Test @@ -188,22 +173,6 @@ public class BaseCalendarDAOTest { assertThat(children.size(), equalTo(0)); } - @Test - public void findLastVersions() { - BaseCalendar calendar = BaseCalendarTest.createBasicCalendar(); - baseCalendarDAO.save(calendar); - baseCalendarDAO.flush(); - - assertThat(baseCalendarDAO.findLastVersions().size(), equalTo(1)); - - BaseCalendar newCalendar = calendar.newVersion((new LocalDate()) - .plusDays(1)); - baseCalendarDAO.save(newCalendar); - baseCalendarDAO.flush(); - - assertThat(baseCalendarDAO.findLastVersions().size(), equalTo(1)); - } - @Test(expected = DataIntegrityViolationException.class) public void notAllowRemoveCalendarWithChildrenInOtherVersions() throws InstanceNotFoundException { @@ -221,15 +190,15 @@ public class BaseCalendarDAOTest { assertThat(baseCalendarDAO.findByParent(parent1).get(0).getId(), equalTo(calendar.getId())); - BaseCalendar newVersion = calendar.newVersion((new LocalDate()) + calendar.newVersion((new LocalDate()) .plusDays(1)); - newVersion.setParent(parent2); + calendar.setParent(parent2); - baseCalendarDAO.save(newVersion); + baseCalendarDAO.save(calendar); baseCalendarDAO.flush(); assertThat(baseCalendarDAO.findByParent(parent2).get(0).getId(), - equalTo(newVersion.getId())); + equalTo(calendar.getId())); assertThat(baseCalendarDAO.findByParent(parent1).get(0).getId(), equalTo(calendar.getId())); @@ -238,4 +207,72 @@ public class BaseCalendarDAOTest { baseCalendarDAO.flush(); } + @Test(expected = InvalidStateException.class) + public void notAllowTwoCalendarsWithNullName() { + BaseCalendar calendar = BaseCalendarTest.createBasicCalendar(); + calendar.setName(null); + + baseCalendarDAO.save(calendar); + baseCalendarDAO.flush(); + } + + @Test(expected = InvalidStateException.class) + public void notAllowTwoCalendarsWithEmptyName() { + BaseCalendar calendar = BaseCalendarTest.createBasicCalendar(); + calendar.setName(""); + + baseCalendarDAO.save(calendar); + baseCalendarDAO.flush(); + } + + @Test(expected = DataIntegrityViolationException.class) + public void notAllowTwoCalendarsWithTheSameName() { + BaseCalendar calendar1 = BaseCalendarTest.createBasicCalendar(); + calendar1.setName("Test"); + BaseCalendar calendar2 = BaseCalendarTest.createBasicCalendar(); + calendar2.setName("Test"); + + assertThat(calendar2.getName(), equalTo(calendar1.getName())); + baseCalendarDAO.save(calendar1); + baseCalendarDAO.save(calendar2); + baseCalendarDAO.flush(); + } + + @Test + public void notAllowTwoCalendarsWithTheSameNameChangingCalendarName() + throws InstanceNotFoundException { + BaseCalendar calendar1 = BaseCalendarTest.createBasicCalendar(); + calendar1.setName("Test"); + BaseCalendar calendar2 = BaseCalendarTest.createBasicCalendar(); + calendar2.setName("Test2"); + + baseCalendarDAO.save(calendar1); + baseCalendarDAO.save(calendar2); + baseCalendarDAO.flush(); + + calendar2 = baseCalendarDAO.find(calendar2.getId()); + calendar2.setName("Test"); + + assertThat(calendar2.getName(), equalTo(calendar1.getName())); + + try { + baseCalendarDAO.save(calendar2); + baseCalendarDAO.flush(); + fail("It should throw an exception"); + } catch (DataIntegrityViolationException e) { + + } + } + + @Test + public void findByName() { + BaseCalendar calendar = BaseCalendarTest.createBasicCalendar(); + baseCalendarDAO.save(calendar); + baseCalendarDAO.flush(); + + List list = baseCalendarDAO.findByName(calendar); + assertThat(list.size(), equalTo(1)); + assertThat(list.get(0).getId(), equalTo(calendar.getId())); + } + } 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 b41ee1f19..6cd2100cb 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 @@ -13,8 +13,7 @@ import org.junit.Test; import org.navalplanner.business.calendars.entities.BaseCalendar; import org.navalplanner.business.calendars.entities.ExceptionDay; import org.navalplanner.business.calendars.entities.BaseCalendar.DayType; -import org.navalplanner.business.calendars.entities.BaseCalendar.Days; -import org.navalplanner.business.common.exceptions.ValidationException; +import org.navalplanner.business.calendars.entities.CalendarData.Days; /** * Tests for {@link BaseCalendar}. @@ -84,16 +83,6 @@ public class BaseCalendarTest { return calendar; } - @Test - public void testValidCalendar() { - BaseCalendar calendar = createBasicCalendar(); - try { - calendar.checkValid(); - } catch (ValidationException e) { - fail("It should not throw an exception"); - } - } - @Test public void testGetWorkableHoursBasic() { BaseCalendar calendar = createBasicCalendar(); @@ -199,121 +188,76 @@ public class BaseCalendarTest { @Test public void testCreateNewVersion() { BaseCalendar calendar = createBasicCalendar(); - BaseCalendar nextCalendar = calendar.newVersion((new LocalDate()) - .plusDays(1)); + calendar.newVersion((new LocalDate()).plusDays(1)); - assertThat(calendar, equalTo(nextCalendar.getPreviousCalendar())); - assertThat(nextCalendar, equalTo(calendar.getNextCalendar())); + assertThat(calendar.getCalendarDataVersions().size(), equalTo(2)); } @Test public void testCreateNewVersionPreservesName() { BaseCalendar calendar = createBasicCalendar(); - BaseCalendar nextCalendar = calendar.newVersion((new LocalDate()) - .plusDays(1)); + String name = calendar.getName(); + calendar.newVersion((new LocalDate()).plusDays(1)); - assertThat(nextCalendar.getName(), equalTo(calendar.getName())); + assertThat(calendar.getName(), equalTo(name)); } @Test public void testChangeNameForAllVersions() { BaseCalendar calendar = createBasicCalendar(); calendar.setName("Test"); - BaseCalendar nextCalendar = calendar.newVersion((new LocalDate()) - .plusDays(1)); - - String name = "Name"; - nextCalendar.setName(name); - - assertThat(calendar.getName(), equalTo(name)); - assertThat(nextCalendar.getName(), equalTo(name)); - } - - @Test - public void testChangeNameForAllVersionsWithThreeVersions() { - BaseCalendar calendar = createBasicCalendar(); - calendar.setName("Test"); - BaseCalendar nextCalendar = calendar.newVersion((new LocalDate()) - .plusDays(1)); - BaseCalendar nextCalendar2 = calendar.newVersion((new LocalDate()) - .plusDays(2)); + calendar.newVersion((new LocalDate()).plusDays(1)); String name = "Name"; calendar.setName(name); assertThat(calendar.getName(), equalTo(name)); - assertThat(nextCalendar.getName(), equalTo(name)); - assertThat(nextCalendar2.getName(), equalTo(name)); } @Test(expected = IllegalArgumentException.class) public void testCreateInvalidNewVersion() { - BaseCalendar nextCalendar = createBasicCalendar().newVersion( - FRIDAY_LOCAL_DATE); - - nextCalendar.newVersion(MONDAY_LOCAL_DATE); + BaseCalendar calendar = createBasicCalendar(); + calendar.newVersion(FRIDAY_LOCAL_DATE); + calendar.newVersion(MONDAY_LOCAL_DATE); } @Test public void testGettWorkableHoursNewVersion() { - BaseCalendar origCalendar = createBasicCalendar(); - BaseCalendar newCalendar = origCalendar.newVersion(MONDAY_LOCAL_DATE); + BaseCalendar calendar = createBasicCalendar(); + calendar.newVersion(MONDAY_LOCAL_DATE); - newCalendar.setHours(Days.WEDNESDAY, 4); - newCalendar.setHours(Days.SUNDAY, 4); + calendar.setHours(Days.WEDNESDAY, 4); + calendar.setHours(Days.SUNDAY, 4); - int wednesdayHours = newCalendar.getWorkableHours(WEDNESDAY_LOCAL_DATE); - assertThat(wednesdayHours, equalTo(4)); - assertThat(wednesdayHours, equalTo(origCalendar - .getWorkableHours(WEDNESDAY_LOCAL_DATE))); + assertThat(calendar.getWorkableHours(WEDNESDAY_LOCAL_DATE), equalTo(4)); - int wednesdayHoursPastWeek = newCalendar - .getWorkableHours(WEDNESDAY_LOCAL_DATE.minusWeeks(1)); - assertThat(wednesdayHoursPastWeek, equalTo(8)); - assertThat(wednesdayHoursPastWeek, equalTo(origCalendar - .getWorkableHours(WEDNESDAY_LOCAL_DATE.minusWeeks(1)))); + assertThat(calendar + .getWorkableHours(WEDNESDAY_LOCAL_DATE.minusWeeks(1)), + equalTo(8)); - int sundayHours = newCalendar.getWorkableHours(SUNDAY_LOCAL_DATE); - assertThat(sundayHours, equalTo(4)); - assertThat(sundayHours, equalTo(origCalendar - .getWorkableHours(SUNDAY_LOCAL_DATE))); + assertThat(calendar.getWorkableHours(SUNDAY_LOCAL_DATE), equalTo(4)); - int sundayHoursPastWeek = newCalendar - .getWorkableHours(SUNDAY_LOCAL_DATE.minusWeeks(1)); - assertThat(sundayHoursPastWeek, equalTo(0)); - assertThat(sundayHoursPastWeek, equalTo(origCalendar - .getWorkableHours(SUNDAY_LOCAL_DATE.minusWeeks(1)))); + assertThat(calendar.getWorkableHours(SUNDAY_LOCAL_DATE.minusWeeks(1)), + equalTo(0)); } @Test public void testGettWorkableHoursNewVersionCheckingLimits() { - BaseCalendar origCalendar = createBasicCalendar(); - BaseCalendar newCalendar = origCalendar.newVersion(MONDAY_LOCAL_DATE); + BaseCalendar calendar = createBasicCalendar(); + calendar.newVersion(MONDAY_LOCAL_DATE); - newCalendar.setHours(Days.MONDAY, 1); - newCalendar.setHours(Days.SUNDAY, 2); + calendar.setHours(Days.MONDAY, 1); + calendar.setHours(Days.SUNDAY, 2); - int mondayHours = newCalendar.getWorkableHours(MONDAY_LOCAL_DATE); - assertThat(mondayHours, equalTo(1)); - assertThat(mondayHours, equalTo(origCalendar - .getWorkableHours(MONDAY_LOCAL_DATE))); + assertThat(calendar.getWorkableHours(MONDAY_LOCAL_DATE), equalTo(1)); - int sundayHours = newCalendar.getWorkableHours(SUNDAY_LOCAL_DATE); - assertThat(sundayHours, equalTo(2)); - assertThat(sundayHours, equalTo(origCalendar - .getWorkableHours(SUNDAY_LOCAL_DATE))); + assertThat(calendar.getWorkableHours(SUNDAY_LOCAL_DATE), equalTo(2)); - int mondayHoursPastWeek = newCalendar - .getWorkableHours(MONDAY_LOCAL_DATE.minusWeeks(1)); - assertThat(mondayHoursPastWeek, equalTo(8)); - assertThat(mondayHoursPastWeek, equalTo(origCalendar - .getWorkableHours(MONDAY_LOCAL_DATE.minusWeeks(1)))); + assertThat(calendar + .getWorkableHours(MONDAY_LOCAL_DATE.minusWeeks(1)), equalTo(8)); - int pastSundayHours = newCalendar.getWorkableHours(MONDAY_LOCAL_DATE - .minusDays(1)); - assertThat(pastSundayHours, equalTo(0)); - assertThat(pastSundayHours, equalTo(origCalendar - .getWorkableHours(MONDAY_LOCAL_DATE.minusDays(1)))); + assertThat(calendar.getWorkableHours(MONDAY_LOCAL_DATE + .minusDays(1)), equalTo(0)); } @Test @@ -334,35 +278,31 @@ public class BaseCalendarTest { @Test public void testRemoveExceptionDayNewVersionCalendar() { - BaseCalendar origCalendar = createChristmasCalendar(); - BaseCalendar newCalendar = origCalendar.newVersion(MONDAY_LOCAL_DATE); + BaseCalendar calendar = createChristmasCalendar(); + calendar.newVersion(MONDAY_LOCAL_DATE); - newCalendar.removeExceptionDay(CHRISTMAS_DAY_LOCAL_DATE); + calendar.removeExceptionDay(CHRISTMAS_DAY_LOCAL_DATE); - assertThat(origCalendar.getExceptions().size(), equalTo(1)); - assertThat(newCalendar.getExceptions().size(), equalTo(0)); + assertThat(calendar.getExceptions().size(), equalTo(0)); } @Test public void testGettWorkableHoursNewVersionFromChristmasCalendar() { - BaseCalendar origCalendar = createChristmasCalendar(); + BaseCalendar calendar = createChristmasCalendar(); ExceptionDay day = ExceptionDay.create(CHRISTMAS_DAY_LOCAL_DATE .plusYears(1), 0); - origCalendar.addExceptionDay(day); + calendar.addExceptionDay(day); - BaseCalendar newCalendar = origCalendar - .newVersion(CHRISTMAS_DAY_LOCAL_DATE.plusDays(1)); + calendar.newVersion(CHRISTMAS_DAY_LOCAL_DATE.plusDays(1)); - newCalendar + calendar .updateExceptionDay(CHRISTMAS_DAY_LOCAL_DATE.plusYears(1), 8); - int christmasHours = newCalendar - .getWorkableHours(CHRISTMAS_DAY_LOCAL_DATE.plusYears(1)); - assertThat(christmasHours, equalTo(8)); + assertThat(calendar + .getWorkableHours(CHRISTMAS_DAY_LOCAL_DATE.plusYears(1)), equalTo(8)); - int christmasHoursPastYear = newCalendar - .getWorkableHours(CHRISTMAS_DAY_LOCAL_DATE); - assertThat(christmasHoursPastYear, equalTo(0)); + assertThat(calendar + .getWorkableHours(CHRISTMAS_DAY_LOCAL_DATE), equalTo(0)); } public static void setHoursForAllDays(BaseCalendar calendar, Integer hours) { @@ -380,32 +320,17 @@ public class BaseCalendarTest { BaseCalendar calendar = createBasicCalendar(); setHoursForAllDays(calendar, 8); - BaseCalendar calendar2 = calendar.newVersion(TUESDAY_LOCAL_DATE); - setHoursForAllDays(calendar2, 4); + calendar.newVersion(TUESDAY_LOCAL_DATE); + setHoursForAllDays(calendar, 4); - BaseCalendar calendar3 = calendar2.newVersion(FRIDAY_LOCAL_DATE); - setHoursForAllDays(calendar3, 2); + calendar.newVersion(FRIDAY_LOCAL_DATE); + setHoursForAllDays(calendar, 2); - int hoursMonday = calendar.getWorkableHours(MONDAY_LOCAL_DATE); - assertThat(hoursMonday, equalTo(8)); - assertThat(calendar2.getWorkableHours(MONDAY_LOCAL_DATE), - equalTo(hoursMonday)); - assertThat(calendar3.getWorkableHours(MONDAY_LOCAL_DATE), - equalTo(hoursMonday)); + assertThat(calendar.getWorkableHours(MONDAY_LOCAL_DATE), equalTo(8)); - int hoursWednesday = calendar.getWorkableHours(WEDNESDAY_LOCAL_DATE); - assertThat(hoursWednesday, equalTo(4)); - assertThat(calendar2.getWorkableHours(WEDNESDAY_LOCAL_DATE), - equalTo(hoursWednesday)); - assertThat(calendar3.getWorkableHours(WEDNESDAY_LOCAL_DATE), - equalTo(hoursWednesday)); + assertThat(calendar.getWorkableHours(WEDNESDAY_LOCAL_DATE), equalTo(4)); - int hoursFriday = calendar.getWorkableHours(FRIDAY_LOCAL_DATE); - assertThat(hoursFriday, equalTo(2)); - assertThat(calendar2.getWorkableHours(FRIDAY_LOCAL_DATE), - equalTo(hoursFriday)); - assertThat(calendar3.getWorkableHours(FRIDAY_LOCAL_DATE), - equalTo(hoursFriday)); + assertThat(calendar.getWorkableHours(FRIDAY_LOCAL_DATE), equalTo(2)); } @@ -416,43 +341,31 @@ public class BaseCalendarTest { BaseCalendar calendar = baseCalendar.newDerivedCalendar(); setHoursForAllDays(calendar, 4); - BaseCalendar newCalendar = calendar.newVersion(WEDNESDAY_LOCAL_DATE); - setHoursForAllDays(newCalendar, 2); + calendar.newVersion(WEDNESDAY_LOCAL_DATE); + setHoursForAllDays(calendar, 2); - int hoursMonday = baseCalendar.getWorkableHours(MONDAY_LOCAL_DATE); - assertThat(hoursMonday, equalTo(8)); + assertThat(baseCalendar.getWorkableHours(MONDAY_LOCAL_DATE), equalTo(8)); - hoursMonday = calendar.getWorkableHours(MONDAY_LOCAL_DATE); - assertThat(hoursMonday, equalTo(4)); - assertThat(hoursMonday, equalTo(newCalendar - .getWorkableHours(MONDAY_LOCAL_DATE))); + assertThat(calendar.getWorkableHours(MONDAY_LOCAL_DATE), equalTo(4)); - int hoursFriday = baseCalendar.getWorkableHours(FRIDAY_LOCAL_DATE); - assertThat(hoursFriday, equalTo(8)); + assertThat(baseCalendar.getWorkableHours(FRIDAY_LOCAL_DATE), equalTo(8)); - hoursFriday = calendar.getWorkableHours(FRIDAY_LOCAL_DATE); - assertThat(hoursFriday, equalTo(2)); - assertThat(hoursFriday, equalTo(newCalendar - .getWorkableHours(FRIDAY_LOCAL_DATE))); + assertThat(calendar.getWorkableHours(FRIDAY_LOCAL_DATE), equalTo(2)); - int christmasHours = newCalendar - .getWorkableHours(CHRISTMAS_DAY_LOCAL_DATE); - assertThat(christmasHours, equalTo(0)); - assertThat(christmasHours, equalTo(calendar - .getWorkableHours(CHRISTMAS_DAY_LOCAL_DATE))); + assertThat(calendar.getWorkableHours(CHRISTMAS_DAY_LOCAL_DATE), + equalTo(0)); } @Test public void testAddExceptionToNewVersionCalendar() { BaseCalendar calendar = createBasicCalendar(); - BaseCalendar newVersion = calendar.newVersion(CHRISTMAS_DAY_LOCAL_DATE + calendar.newVersion(CHRISTMAS_DAY_LOCAL_DATE .plusDays(1)); ExceptionDay day = ExceptionDay.create(CHRISTMAS_DAY_LOCAL_DATE, 0); - newVersion.addExceptionDay(day); + calendar.addExceptionDay(day); assertThat(calendar.getExceptions().size(), equalTo(1)); - assertThat(newVersion.getExceptions().size(), equalTo(0)); assertThat(calendar.getExceptions().iterator().next().getDate(), equalTo(CHRISTMAS_DAY_LOCAL_DATE)); } @@ -576,8 +489,7 @@ public class BaseCalendarTest { assertThat(copy.getWorkableHours(CHRISTMAS_DAY_LOCAL_DATE), equalTo(0)); assertThat(copy.getParent(), equalTo(calendar)); - assertThat(copy.getNextCalendar(), nullValue()); - assertThat(copy.getPreviousCalendar(), nullValue()); + assertThat(copy.getCalendarDataVersions().size(), equalTo(1)); } @Test(expected = IllegalArgumentException.class) @@ -596,58 +508,35 @@ public class BaseCalendarTest { BaseCalendar calendar = parent1.newDerivedCalendar(); - BaseCalendar newVersion = calendar.newVersion(WEDNESDAY_LOCAL_DATE); - newVersion.setParent(parent2); + calendar.newVersion(WEDNESDAY_LOCAL_DATE); + calendar.setParent(parent2); - assertThat(newVersion.getParent(), equalTo(parent2)); - assertThat(newVersion.getPreviousCalendar().getParent(), + assertThat(calendar.getParent(), equalTo(parent2)); + assertThat(calendar.getParent(MONDAY_LOCAL_DATE), equalTo(parent1)); - int mondayHours = newVersion.getWorkableHours(MONDAY_LOCAL_DATE); - assertThat(mondayHours, equalTo(8)); assertThat(calendar.getWorkableHours(MONDAY_LOCAL_DATE), - equalTo(mondayHours)); + equalTo(8)); - int fridayHours = newVersion.getWorkableHours(FRIDAY_LOCAL_DATE); - assertThat(fridayHours, equalTo(4)); assertThat(calendar.getWorkableHours(FRIDAY_LOCAL_DATE), - equalTo(fridayHours)); + equalTo(4)); } @Test public void testExceptionsInDifferentVersions() { BaseCalendar calendar = createBasicCalendar(); - BaseCalendar newVersion = calendar.newVersion(WEDNESDAY_LOCAL_DATE); + calendar.newVersion(WEDNESDAY_LOCAL_DATE); - newVersion.addExceptionDay(ExceptionDay.create(MONDAY_LOCAL_DATE, 0)); - newVersion.addExceptionDay(ExceptionDay.create(FRIDAY_LOCAL_DATE, 0)); + calendar.addExceptionDay(ExceptionDay.create(MONDAY_LOCAL_DATE, 0)); + calendar.addExceptionDay(ExceptionDay.create(FRIDAY_LOCAL_DATE, 0)); - Integer mondayHours = newVersion.getWorkableHours(MONDAY_LOCAL_DATE); - assertThat(mondayHours, equalTo(0)); assertThat(calendar.getWorkableHours(MONDAY_LOCAL_DATE), - equalTo(mondayHours)); + equalTo(0)); - Integer fridayHours = newVersion.getWorkableHours(FRIDAY_LOCAL_DATE); - assertThat(fridayHours, equalTo(0)); assertThat(calendar.getWorkableHours(FRIDAY_LOCAL_DATE), - equalTo(fridayHours)); + equalTo(0)); - assertThat(calendar.getOwnExceptions().size(), equalTo(1)); - assertThat(newVersion.getOwnExceptions().size(), equalTo(1)); - } - - @Test - public void testGetVersion() { - BaseCalendar calendar = createBasicCalendar(); - BaseCalendar newVersion = calendar.newVersion(WEDNESDAY_LOCAL_DATE); - BaseCalendar lastVersion = newVersion.newVersion(SATURDAY_LOCAL_DATE); - - assertThat(lastVersion.getCalendarVersion(MONDAY_LOCAL_DATE), - equalTo(calendar)); - assertThat(lastVersion.getCalendarVersion(THURSDAY_LOCAL_DATE), - equalTo(newVersion)); - assertThat(lastVersion.getCalendarVersion(SUNDAY_LOCAL_DATE), - equalTo(lastVersion)); + assertThat(calendar.getOwnExceptions().size(), equalTo(2)); } @Test(expected = IllegalArgumentException.class) @@ -691,10 +580,10 @@ public class BaseCalendarTest { calendar.newVersion(new LocalDate()); } - @Test(expected = UnsupportedOperationException.class) + @Test(expected = IllegalArgumentException.class) public void testNotAllowSetExpiringDateIfNotNextCalendar() { BaseCalendar calendar = createBasicCalendar(); - assertThat(calendar.getNextCalendar(), nullValue()); + assertThat(calendar.getCalendarDataVersions().size(), equalTo(1)); calendar.setExpiringDate(WEDNESDAY_LOCAL_DATE); } 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 2e6007776..552b22d44 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 @@ -12,8 +12,9 @@ import java.util.Map; import org.apache.commons.lang.StringUtils; import org.joda.time.LocalDate; import org.navalplanner.business.calendars.entities.BaseCalendar; +import org.navalplanner.business.calendars.entities.CalendarData; import org.navalplanner.business.calendars.entities.BaseCalendar.DayType; -import org.navalplanner.business.calendars.entities.BaseCalendar.Days; +import org.navalplanner.business.calendars.entities.CalendarData.Days; import org.navalplanner.business.common.exceptions.ValidationException; import org.navalplanner.web.common.IMessagesForUser; import org.navalplanner.web.common.Level; @@ -352,7 +353,7 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { @Override public void onEvent(Event event) throws Exception { - reloadDayInformation(); + reloadCurrentWindow(); } }); @@ -475,6 +476,8 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { throw new WrongValueException(component, e.getMessage()); } Clients.closeErrorBox(component); + baseCalendarModel.setSelectedDay(date); + Util.reloadBindings(editWindow); } public Date getExpiringDate() { @@ -493,6 +496,8 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { throw new WrongValueException(component, e.getMessage()); } Clients.closeErrorBox(component); + baseCalendarModel.setSelectedDay(date); + Util.reloadBindings(editWindow); } public void goToCreateCopyForm(BaseCalendar baseCalendar) { @@ -589,7 +594,7 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { } - public List getHistoryVersions() { + public List getHistoryVersions() { return baseCalendarModel.getHistoryVersions(); } @@ -651,17 +656,8 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { return getDaysCurrentMonthByType().get(DayType.ZERO_HOURS); } - public void goToCalendarVersion(BaseCalendar calendar) { - if (calendar.getPreviousCalendar() != null) { - setSelectedDay(calendar.getPreviousCalendar().getExpiringDate() - .toDateTimeAtStartOfDay().toDate()); - } else if (calendar.getExpiringDate() != null) { - setSelectedDay(calendar.getExpiringDate().minusDays(1) - .toDateTimeAtStartOfDay() - .toDate()); - } else { - setSelectedDay(new Date()); - } + public void goToDate(Date date) { + setSelectedDay(date); ((Tab) editWindow.getFellow("dataTab")).setSelected(true); Util.reloadBindings(editWindow); @@ -707,24 +703,34 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { @Override public void render(Listitem item, Object data) throws Exception { - final BaseCalendar calendar = (BaseCalendar) data; + CalendarData calendarData = (CalendarData) data; Listcell nameListcell = new Listcell(); - nameListcell.appendChild(new Label(calendar.getName())); + nameListcell.appendChild(new Label(baseCalendarModel.getName())); item.appendChild(nameListcell); + Listcell parentListcell = new Listcell(); + Label parentLabel = new Label(); + BaseCalendar parent = calendarData.getParent(); + if (parent != null) { + parentLabel.setValue(parent.getName()); + } + parentListcell.appendChild(parentLabel); + item.appendChild(parentListcell); + Listcell validFromListcell = new Listcell(); Label validFromLabel = new Label(); - if (calendar.getPreviousCalendar() != null) { - LocalDate validFrom = calendar.getPreviousCalendar() - .getExpiringDate(); - validFromLabel.setValue(validFrom.toString()); + final LocalDate dateValidFrom = baseCalendarModel + .getValidFrom( + calendarData); + if (dateValidFrom != null) { + validFromLabel.setValue(dateValidFrom.toString()); } validFromListcell.appendChild(validFromLabel); item.appendChild(validFromListcell); Listcell expiringDateListcell = new Listcell(); - LocalDate expiringDate = calendar.getExpiringDate(); + final LocalDate expiringDate = calendarData.getExpiringDate(); Label expiringDateLabel = new Label(); if (expiringDate != null) { LocalDate date = new LocalDate(expiringDate).minusDays(1); @@ -736,7 +742,7 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { Listcell summaryListcell = new Listcell(); List summary = new ArrayList(); for (Days day : Days.values()) { - Integer hours = calendar.getHours(day); + Integer hours = calendarData.getHours(day); if (hours == null) { summary.add("D"); } else { @@ -753,7 +759,15 @@ public class BaseCalendarCRUDController extends GenericForwardComposer { @Override public void onEvent(Event event) throws Exception { - goToCalendarVersion(calendar); + if (dateValidFrom != null) { + goToDate(dateValidFrom.toDateTimeAtStartOfDay() + .toDate()); + } else if (expiringDate != null) { + goToDate(expiringDate.minusDays(1) + .toDateTimeAtStartOfDay().toDate()); + } else { + goToDate(new Date()); + } } }); buttonListcell.appendChild(button); 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 1186e66bd..d774f6c64 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,6 +1,7 @@ package org.navalplanner.web.calendars; -import java.util.ArrayList; +import static org.navalplanner.web.I18nHelper._; + import java.util.Date; import java.util.List; @@ -10,9 +11,10 @@ import org.hibernate.validator.InvalidValue; import org.joda.time.LocalDate; import org.navalplanner.business.calendars.daos.IBaseCalendarDAO; import org.navalplanner.business.calendars.entities.BaseCalendar; +import org.navalplanner.business.calendars.entities.CalendarData; import org.navalplanner.business.calendars.entities.ExceptionDay; import org.navalplanner.business.calendars.entities.BaseCalendar.DayType; -import org.navalplanner.business.calendars.entities.BaseCalendar.Days; +import org.navalplanner.business.calendars.entities.CalendarData.Days; import org.navalplanner.business.common.exceptions.InstanceNotFoundException; import org.navalplanner.business.common.exceptions.ValidationException; import org.springframework.beans.factory.annotation.Autowired; @@ -54,7 +56,11 @@ public class BaseCalendarModel implements IBaseCalendarModel { @Override @Transactional(readOnly = true) public List getBaseCalendars() { - return baseCalendarDAO.findLastVersions(); + List baseCalendars = baseCalendarDAO.getBaseCalendars(); + for (BaseCalendar baseCalendar : baseCalendars) { + forceLoad(baseCalendar); + } + return baseCalendars; } /* @@ -74,7 +80,7 @@ public class BaseCalendarModel implements IBaseCalendarModel { Validate.notNull(baseCalendar); this.baseCalendar = getFromDB(baseCalendar); - forceLoadHoursPerDayAndExceptionDays(this.baseCalendar); + forceLoad(this.baseCalendar); } @Override @@ -84,7 +90,7 @@ public class BaseCalendarModel implements IBaseCalendarModel { Validate.notNull(baseCalendar); this.baseCalendar = getFromDB(baseCalendar).newDerivedCalendar(); - forceLoadHoursPerDayAndExceptionDays(this.baseCalendar); + forceLoad(this.baseCalendar); } @Override @@ -94,7 +100,7 @@ public class BaseCalendarModel implements IBaseCalendarModel { Validate.notNull(baseCalendar); this.baseCalendar = getFromDB(baseCalendar).newCopy(); - forceLoadHoursPerDayAndExceptionDays(this.baseCalendar); + forceLoad(this.baseCalendar); } @Override @@ -102,37 +108,14 @@ public class BaseCalendarModel implements IBaseCalendarModel { this.baseCalendar = baseCalendar; } - private void forceLoadHoursPerDayAndExceptionDays(BaseCalendar baseCalendar) { - forceLoadHoursPerDayAndExceptionDaysBasic(baseCalendar); - forceLoadHoursPerDayAndExceptionDaysPrevious(baseCalendar); - forceLoadHoursPerDayAndExceptionDaysNext(baseCalendar); - } - - private void forceLoadHoursPerDayAndExceptionDaysBasic(BaseCalendar baseCalendar) { - baseCalendar.getHoursPerDay().size(); + private void forceLoad(BaseCalendar baseCalendar) { + for (CalendarData calendarData : baseCalendar.getCalendarDataVersions()) { + calendarData.getHoursPerDay().size(); + if (calendarData.getParent() != null) { + forceLoad(calendarData.getParent()); + } + } baseCalendar.getExceptions().size(); - - if (baseCalendar.getParent() != null) { - forceLoadHoursPerDayAndExceptionDaysBasic(baseCalendar.getParent()); - } - } - - private void forceLoadHoursPerDayAndExceptionDaysPrevious( - BaseCalendar baseCalendar) { - if (baseCalendar.getPreviousCalendar() != null) { - forceLoadHoursPerDayAndExceptionDaysBasic(baseCalendar.getPreviousCalendar()); - forceLoadHoursPerDayAndExceptionDaysPrevious(baseCalendar - .getPreviousCalendar()); - } - } - - private void forceLoadHoursPerDayAndExceptionDaysNext( - BaseCalendar baseCalendar) { - if (baseCalendar.getNextCalendar() != null) { - forceLoadHoursPerDayAndExceptionDaysBasic(baseCalendar.getNextCalendar()); - forceLoadHoursPerDayAndExceptionDaysNext(baseCalendar - .getNextCalendar()); - } } @Transactional(readOnly = true) @@ -165,7 +148,7 @@ public class BaseCalendarModel implements IBaseCalendarModel { if (getBaseCalendar() != null) { for (BaseCalendar calendar : baseCalendars) { - if (calendar.getId().equals(getBaseCalendar().getId())) { + if (areSameInDB(calendar, getBaseCalendar())) { baseCalendars.remove(calendar); break; } @@ -183,12 +166,6 @@ public class BaseCalendarModel implements IBaseCalendarModel { @Override public void setSelectedDay(Date date) { this.selectedDate = date; - - BaseCalendar validCalendar = baseCalendar.getCalendarVersion(date); - if (!validCalendar.equals(baseCalendar)) { - baseCalendar = validCalendar; - forceLoadHoursPerDayAndExceptionDays(baseCalendar); - } } @Override @@ -239,7 +216,7 @@ public class BaseCalendarModel implements IBaseCalendarModel { return null; } - return getBaseCalendar().getHours(day); + return getBaseCalendar().getHours(selectedDate, day); } @Override @@ -248,27 +225,27 @@ public class BaseCalendarModel implements IBaseCalendarModel { return false; } - return getBaseCalendar().isDefault(day); + return getBaseCalendar().isDefault(day, selectedDate); } @Override public void unsetDefault(Days day) { if (getBaseCalendar() != null) { - getBaseCalendar().setHours(day, 0); + getBaseCalendar().setHours(day, 0, selectedDate); } } @Override public void setDefault(Days day) { if (getBaseCalendar() != null) { - getBaseCalendar().setDefault(day); + getBaseCalendar().setDefault(day, selectedDate); } } @Override public void setHours(Days day, Integer hours) { if (getBaseCalendar() != null) { - getBaseCalendar().setHours(day, hours); + getBaseCalendar().setHours(day, hours, selectedDate); } } @@ -293,7 +270,7 @@ public class BaseCalendarModel implements IBaseCalendarModel { return false; } - return getBaseCalendar().isDerived(); + return getBaseCalendar().isDerived(selectedDate); } @Override @@ -302,7 +279,7 @@ public class BaseCalendarModel implements IBaseCalendarModel { return null; } - return getBaseCalendar().getParent(); + return getBaseCalendar().getParent(selectedDate); } @Override @@ -313,10 +290,10 @@ public class BaseCalendarModel implements IBaseCalendarModel { } catch (InstanceNotFoundException e) { throw new RuntimeException(e); } - forceLoadHoursPerDayAndExceptionDays(parent); + forceLoad(parent); if (getBaseCalendar() != null) { - getBaseCalendar().setParent(parent); + getBaseCalendar().setParent(parent, selectedDate); } } @@ -333,8 +310,8 @@ public class BaseCalendarModel implements IBaseCalendarModel { @Override public Date getExpiringDate() { if ((getBaseCalendar() != null) - && (getBaseCalendar().getExpiringDate() != null)) { - return getBaseCalendar().getExpiringDate().minusDays(1) + && (getBaseCalendar().getExpiringDate(selectedDate) != null)) { + return getBaseCalendar().getExpiringDate(selectedDate).minusDays(1) .toDateTimeAtStartOfDay() .toDate(); } @@ -345,19 +322,20 @@ public class BaseCalendarModel implements IBaseCalendarModel { @Override public void setExpiringDate(Date date) { if ((getBaseCalendar() != null) - && (getBaseCalendar().getExpiringDate() != null)) { + && (getBaseCalendar().getExpiringDate(selectedDate) != null)) { getBaseCalendar() - .setExpiringDate(date); + .setExpiringDate(date, selectedDate); } } @Override public Date getDateValidFrom() { - if ((getBaseCalendar() != null) - && (getBaseCalendar().getPreviousCalendar() != null)) { - LocalDate expiringDate = getBaseCalendar().getPreviousCalendar() - .getExpiringDate(); - return expiringDate.toDateTimeAtStartOfDay().toDate(); + if (getBaseCalendar() != null) { + LocalDate validFromDate = getBaseCalendar().getValidFrom( + selectedDate); + if (validFromDate != null) { + return validFromDate.toDateTimeAtStartOfDay().toDate(); + } } return null; @@ -365,49 +343,57 @@ public class BaseCalendarModel implements IBaseCalendarModel { @Override public void setDateValidFrom(Date date) { - if ((getBaseCalendar() != null) - && (getBaseCalendar().getPreviousCalendar() != null)) { - getBaseCalendar().getPreviousCalendar().setExpiringDate(date); + if (getBaseCalendar() != null) { + getBaseCalendar().setValidFrom(date, selectedDate); } } @Override - public List getHistoryVersions() { + public List getHistoryVersions() { if (getBaseCalendar() == null) { return null; } - List history = new ArrayList(); - - BaseCalendar lastVersion = getBaseCalendar(); - while (lastVersion.getNextCalendar() != null) { - lastVersion = lastVersion.getNextCalendar(); - } - - BaseCalendar current = lastVersion; - while (current != null) { - history.add(current); - current = current.getPreviousCalendar(); - } - - return history; + return getBaseCalendar().getCalendarDataVersions(); } @Override public void createNewVersion(Date date) { if (getBaseCalendar() != null) { - this.baseCalendar = getBaseCalendar().newVersion(date); + getBaseCalendar().newVersion(date); } } @Override public boolean isLastVersion() { if (getBaseCalendar() != null) { - return (getBaseCalendar().getNextCalendar() == null); + return getBaseCalendar().isLastVersion(selectedDate); } return false; } + @Override + public String getName() { + if (getBaseCalendar() != null) { + return getBaseCalendar().getName(); + } + return null; + } + + @Override + public LocalDate getValidFrom(CalendarData calendarData) { + if (getBaseCalendar() != null) { + List calendarDataVersions = getBaseCalendar() + .getCalendarDataVersions(); + Integer index = calendarDataVersions.indexOf(calendarData); + if (index > 0) { + return calendarDataVersions.get(index - 1).getExpiringDate(); + } + } + + return null; + } + /* * Final conversation steps */ @@ -415,16 +401,33 @@ public class BaseCalendarModel implements IBaseCalendarModel { @Override @Transactional public void confirmSave() throws ValidationException { + BaseCalendar entity = getBaseCalendar(); + InvalidValue[] invalidValues = baseCalendarValidator - .getInvalidValues(getBaseCalendar()); + .getInvalidValues(entity); if (invalidValues.length > 0) { throw new ValidationException(invalidValues); } - getBaseCalendar().checkValid(); + List list = baseCalendarDAO.findByName(getBaseCalendar()); + if (!list.isEmpty()) { + if ((list.size() > 1) + || !areSameInDB(entity, list.get(0))) { + InvalidValue[] invalidValues2 = { new InvalidValue(_( + "{0} already exists", entity.getName()), + BaseCalendar.class, "name", entity.getName(), entity) }; + throw new ValidationException(invalidValues2, + _("Could not save new calendar")); + } + } + baseCalendarDAO.save(getBaseCalendar()); } + private boolean areSameInDB(BaseCalendar one, BaseCalendar another) { + return one.getId().equals(another.getId()); + } + @Override @Transactional public void confirmRemove() { 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 8dd8f2df7..982912a44 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 @@ -5,8 +5,9 @@ import java.util.List; import org.joda.time.LocalDate; import org.navalplanner.business.calendars.entities.BaseCalendar; +import org.navalplanner.business.calendars.entities.CalendarData; import org.navalplanner.business.calendars.entities.BaseCalendar.DayType; -import org.navalplanner.business.calendars.entities.BaseCalendar.Days; +import org.navalplanner.business.calendars.entities.CalendarData.Days; import org.navalplanner.business.common.exceptions.ValidationException; /** @@ -112,12 +113,16 @@ public interface IBaseCalendarModel { void setDateValidFrom(Date date); - List getHistoryVersions(); + List getHistoryVersions(); void createNewVersion(Date date); boolean isLastVersion(); + String getName(); + + LocalDate getValidFrom(CalendarData calendarData); + /* * Final conversation steps */ diff --git a/navalplanner-webapp/src/main/webapp/calendars/_edition.zul b/navalplanner-webapp/src/main/webapp/calendars/_edition.zul index 43996e20f..e7153536b 100644 --- a/navalplanner-webapp/src/main/webapp/calendars/_edition.zul +++ b/navalplanner-webapp/src/main/webapp/calendars/_edition.zul @@ -108,6 +108,7 @@ itemRenderer="@{controller.historyVersionsRenderer}"> + diff --git a/navalplanner-webapp/src/test/java/org/navalplanner/web/calendars/BaseCalendarModelTest.java b/navalplanner-webapp/src/test/java/org/navalplanner/web/calendars/BaseCalendarModelTest.java index 1f708e775..5c5b40eea 100644 --- a/navalplanner-webapp/src/test/java/org/navalplanner/web/calendars/BaseCalendarModelTest.java +++ b/navalplanner-webapp/src/test/java/org/navalplanner/web/calendars/BaseCalendarModelTest.java @@ -7,13 +7,14 @@ import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONF import static org.navalplanner.web.WebappGlobalNames.WEBAPP_SPRING_CONFIG_FILE; import static org.navalplanner.web.test.WebappGlobalNames.WEBAPP_SPRING_CONFIG_TEST_FILE; +import java.util.Date; import java.util.List; import org.joda.time.LocalDate; import org.junit.Test; import org.junit.runner.RunWith; import org.navalplanner.business.calendars.entities.BaseCalendar; -import org.navalplanner.business.calendars.entities.BaseCalendar.Days; +import org.navalplanner.business.calendars.entities.CalendarData.Days; import org.navalplanner.business.common.exceptions.ValidationException; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; @@ -39,6 +40,7 @@ public class BaseCalendarModelTest { assertThat(baseCalendarModel.getBaseCalendars().size(), equalTo(0)); baseCalendarModel.initCreate(); BaseCalendar baseCalendar = baseCalendarModel.getBaseCalendar(); + baseCalendar.setName("Test"); setHours(baseCalendar, 8); try { baseCalendarModel.confirmSave(); @@ -47,7 +49,7 @@ public class BaseCalendarModelTest { assertThat(baseCalendarModel.getBaseCalendars().get(0).getId(), equalTo(baseCalendar.getId())); assertThat(baseCalendarModel.getBaseCalendars().get(0).getHours( - Days.MONDAY), equalTo(8)); + new Date(), Days.MONDAY), equalTo(8)); } catch (ValidationException e) { fail("It should not throw an exception"); } @@ -64,24 +66,21 @@ public class BaseCalendarModelTest { } @Test - public void testEditAndSave() { + public void testEditAndSave() throws ValidationException { assertThat(baseCalendarModel.getBaseCalendars().size(), equalTo(0)); saveOneCalendar(); BaseCalendar baseCalendar = baseCalendarModel.getBaseCalendars().get(0); baseCalendarModel.initEdit(baseCalendar); setHours(baseCalendarModel.getBaseCalendar(), 4); - try { - baseCalendarModel.confirmSave(); - assertThat(baseCalendarModel.getBaseCalendars().size(), equalTo(1)); - assertThat(baseCalendarModel.getBaseCalendars().get(0).getId(), - equalTo(baseCalendar.getId())); - assertThat(baseCalendarModel.getBaseCalendars().get(0).getHours( - Days.MONDAY), equalTo(4)); - } catch (ValidationException e) { - fail("It should not throw an exception"); - } + baseCalendarModel.confirmSave(); + + assertThat(baseCalendarModel.getBaseCalendars().size(), equalTo(1)); + assertThat(baseCalendarModel.getBaseCalendars().get(0).getId(), + equalTo(baseCalendar.getId())); + assertThat(baseCalendarModel.getBaseCalendars().get(0).getHours( + new Date(), Days.MONDAY), equalTo(4)); } @Test @@ -91,18 +90,18 @@ public class BaseCalendarModelTest { BaseCalendar baseCalendar = baseCalendarModel.getBaseCalendars().get(0); baseCalendarModel.initEdit(baseCalendar); - baseCalendarModel.createNewVersion((new LocalDate()).plusWeeks(1) - .toDateTimeAtStartOfDay().toDate()); + Date date = (new LocalDate()).plusWeeks(1) + .toDateTimeAtStartOfDay().toDate(); + baseCalendarModel.createNewVersion(date); setHours(baseCalendarModel.getBaseCalendar(), 4); try { baseCalendarModel.confirmSave(); assertThat(baseCalendarModel.getBaseCalendars().size(), equalTo(1)); - assertThat(baseCalendarModel.getBaseCalendars().get(0) - .getPreviousCalendar().getId(), equalTo(baseCalendar - .getId())); assertThat(baseCalendarModel.getBaseCalendars().get(0).getHours( - Days.MONDAY), equalTo(4)); + date, Days.MONDAY), equalTo(4)); + assertThat(baseCalendarModel.getBaseCalendars().get(0) + .getCalendarDataVersions().size(), equalTo(2)); } catch (ValidationException e) { fail("It should not throw an exception"); } @@ -110,6 +109,7 @@ public class BaseCalendarModelTest { private void saveOneCalendar() { baseCalendarModel.initCreate(); + baseCalendarModel.getBaseCalendar().setName("Test"); setHours(baseCalendarModel.getBaseCalendar(), 8); try { baseCalendarModel.confirmSave(); @@ -132,6 +132,7 @@ public class BaseCalendarModelTest { @Test public void testPossibleParentCalendars() throws ValidationException { baseCalendarModel.initCreate(); + baseCalendarModel.getBaseCalendar().setName("Test"); setHours(baseCalendarModel.getBaseCalendar(), 8); BaseCalendar parent = baseCalendarModel.getBaseCalendar(); baseCalendarModel.createNewVersion((new LocalDate()).plusMonths(1) @@ -141,6 +142,7 @@ public class BaseCalendarModelTest { baseCalendarModel.initCreateDerived(parent); BaseCalendar child = baseCalendarModel.getBaseCalendar(); + baseCalendarModel.getBaseCalendar().setName("Derived"); baseCalendarModel.confirmSave(); baseCalendarModel.initEdit(child); @@ -151,8 +153,8 @@ public class BaseCalendarModelTest { assertThat(possibleParentCalendars.get(0).getId(), equalTo(parentNewVersion.getId())); assertThat( - possibleParentCalendars.get(0).getPreviousCalendar().getId(), - equalTo(parent.getId())); + possibleParentCalendars.get(0).getCalendarDataVersions() + .size(), equalTo(2)); } }