ItEr23S08CUEdicionCalendarioLaboral: Refactoring calendar model. Now a new class CalendarData appears, where the calendar versions will be stored.
This commit is contained in:
Manuel Rego Casasnovas
Óscar González Fernández
parent
911ca7751c
commit
f3c665aa8d
12 changed files with 746 additions and 625 deletions
|
|
@ -32,16 +32,21 @@ public class BaseCalendarDAO extends GenericDAOHibernate<BaseCalendar, Long>
|
|||
return new ArrayList<BaseCalendar>();
|
||||
}
|
||||
|
||||
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<BaseCalendar>) c.list();
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<BaseCalendar> findLastVersions() {
|
||||
public List<BaseCalendar> findByName(BaseCalendar baseCalendar) {
|
||||
if (baseCalendar == null) {
|
||||
return new ArrayList<BaseCalendar>();
|
||||
}
|
||||
|
||||
Criteria c = getSession().createCriteria(BaseCalendar.class);
|
||||
c.add(Restrictions.isNull("nextCalendar"));
|
||||
c.add(Restrictions.eq("name", baseCalendar.getName()));
|
||||
|
||||
return (List<BaseCalendar>) c.list();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,6 +11,6 @@ public interface IBaseCalendarDAO extends IGenericDAO<BaseCalendar, Long> {
|
|||
|
||||
List<BaseCalendar> findByParent(BaseCalendar baseCalendar);
|
||||
|
||||
List<BaseCalendar> findLastVersions();
|
||||
List<BaseCalendar> findByName(BaseCalendar baseCalendar);
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 <mrego@igalia.com>
|
||||
*/
|
||||
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<Integer, Integer> hoursPerDay;
|
||||
|
||||
private BaseCalendar parent;
|
||||
|
||||
private BaseCalendar previousCalendar;
|
||||
|
||||
private BaseCalendar nextCalendar;
|
||||
|
||||
private LocalDate expiringDate;
|
||||
|
||||
private Set<ExceptionDay> exceptions = new HashSet<ExceptionDay>();
|
||||
|
||||
public enum Days {
|
||||
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
|
||||
}
|
||||
private List<CalendarData> calendarDataVersions = new ArrayList<CalendarData>();
|
||||
|
||||
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<Integer, Integer>();
|
||||
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<Integer, Integer> 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<ExceptionDay> getOwnExceptions() {
|
||||
|
|
@ -183,8 +103,27 @@ public class BaseCalendar extends BaseEntity implements IValidable {
|
|||
Set<ExceptionDay> exceptionDays = new HashSet<ExceptionDay>();
|
||||
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<ExceptionDay> getExceptions(Date date) {
|
||||
return getExceptions(date);
|
||||
}
|
||||
|
||||
public Set<ExceptionDay> getExceptions(LocalDate date) {
|
||||
Set<ExceptionDay> exceptionDays = new HashSet<ExceptionDay>();
|
||||
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<Integer, Integer>(this.hoursPerDay);
|
||||
copy.calendarDataVersions = new ArrayList<CalendarData>();
|
||||
for (CalendarData calendarData : this.calendarDataVersions) {
|
||||
copy.calendarDataVersions.add(calendarData.copy());
|
||||
}
|
||||
copy.exceptions = new HashSet<ExceptionDay>(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<CalendarData> 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));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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 <mrego@igalia.com>
|
||||
*/
|
||||
public class CalendarData extends BaseEntity {
|
||||
|
||||
public static CalendarData create() {
|
||||
CalendarData calendarData = new CalendarData();
|
||||
calendarData.setNewObject(true);
|
||||
return calendarData;
|
||||
}
|
||||
|
||||
private Map<Integer, Integer> 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<Integer, Integer>();
|
||||
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<Integer, Integer> 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<Integer, Integer>(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;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -12,30 +12,19 @@
|
|||
</id>
|
||||
<version name="version" access="property" type="long" />
|
||||
|
||||
<property name="name" access="field"/>
|
||||
|
||||
<map name="hoursPerDay">
|
||||
<key column="BASE_CALENDAR_ID"/>
|
||||
<index column="DAY_ID" type="integer" />
|
||||
<element column="HOURS" type="integer" />
|
||||
</map>
|
||||
|
||||
<many-to-one name="parent" class="BaseCalendar" access="field"/>
|
||||
|
||||
<many-to-one name="previousCalendar" class="BaseCalendar" unique="true"
|
||||
cascade="all" />
|
||||
|
||||
<many-to-one name="nextCalendar" class="BaseCalendar" unique="true"
|
||||
cascade="all" />
|
||||
|
||||
<property name="expiringDate" access="field"
|
||||
type="org.joda.time.contrib.hibernate.PersistentLocalDate"/>
|
||||
<property name="name" access="field" unique="true" />
|
||||
|
||||
<set name="exceptions" access="field" cascade="all-delete-orphan">
|
||||
<key column="BASE_CALENDAR_ID" />
|
||||
<one-to-many class="ExceptionDay" />
|
||||
</set>
|
||||
|
||||
<list name="calendarDataVersions" access="field" cascade="all-delete-orphan">
|
||||
<key column="BASE_CALENDAR_ID" />
|
||||
<index column="POSITION_IN_CALENDAR" />
|
||||
<one-to-many class="CalendarData" />
|
||||
</list>
|
||||
|
||||
<joined-subclass name="ResourceCalendar">
|
||||
<key column="BASE_CALENDAR_ID" />
|
||||
</joined-subclass>
|
||||
|
|
@ -56,4 +45,25 @@
|
|||
|
||||
</class>
|
||||
|
||||
<!-- CalendarData -->
|
||||
<class name="CalendarData">
|
||||
<id name="id" access="property" type="long">
|
||||
<generator class="hilo">
|
||||
<param name="max_lo">100</param>
|
||||
</generator>
|
||||
</id>
|
||||
<version name="version" access="property" type="long" />
|
||||
|
||||
<map name="hoursPerDay">
|
||||
<key column="BASE_CALENDAR_ID"/>
|
||||
<index column="DAY_ID" type="integer" />
|
||||
<element column="HOURS" type="integer" />
|
||||
</map>
|
||||
|
||||
<many-to-one name="parent" class="BaseCalendar" access="field"/>
|
||||
|
||||
<property name="expiringDate" access="field"
|
||||
type="org.joda.time.contrib.hibernate.PersistentLocalDate"/>
|
||||
</class>
|
||||
|
||||
</hibernate-mapping>
|
||||
|
|
|
|||
|
|
@ -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<BaseCalendar> list = baseCalendarDAO.findByName(calendar);
|
||||
assertThat(list.size(), equalTo(1));
|
||||
assertThat(list.get(0).getId(), equalTo(calendar.getId()));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<BaseCalendar> getHistoryVersions() {
|
||||
public List<CalendarData> 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<String> summary = new ArrayList<String>();
|
||||
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);
|
||||
|
|
|
|||
|
|
@ -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<BaseCalendar> getBaseCalendars() {
|
||||
return baseCalendarDAO.findLastVersions();
|
||||
List<BaseCalendar> 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<BaseCalendar> getHistoryVersions() {
|
||||
public List<CalendarData> getHistoryVersions() {
|
||||
if (getBaseCalendar() == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
List<BaseCalendar> history = new ArrayList<BaseCalendar>();
|
||||
|
||||
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<CalendarData> 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<BaseCalendar> 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() {
|
||||
|
|
|
|||
|
|
@ -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<BaseCalendar> getHistoryVersions();
|
||||
List<CalendarData> getHistoryVersions();
|
||||
|
||||
void createNewVersion(Date date);
|
||||
|
||||
boolean isLastVersion();
|
||||
|
||||
String getName();
|
||||
|
||||
LocalDate getValidFrom(CalendarData calendarData);
|
||||
|
||||
/*
|
||||
* Final conversation steps
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -108,6 +108,7 @@
|
|||
itemRenderer="@{controller.historyVersionsRenderer}">
|
||||
<listhead>
|
||||
<listheader label="${i18n:_('Name')}" />
|
||||
<listheader label="${i18n:_('Parent')}" />
|
||||
<listheader label="${i18n:_('Valid from')}" />
|
||||
<listheader label="${i18n:_('Expiring Date')}" />
|
||||
<listheader label="${i18n:_('Summary')}" />
|
||||
|
|
|
|||
|
|
@ -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));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue