RenJuan/TASKPM
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make CalendarData return Capacity instead of EffortDuration

Browse source 
This change imply changes in dependent entities.

FEA: ItEr68OTS05IntroducionLimiteSobreasignacionCalendarios
This commit is contained in:
Óscar González Fernández 2011-01-18 23:47:41 +01:00
parent a13129756a
commit cf18d04498
7 changed files with 61 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/BaseCalendar.java
View file

@ -52,7 +52,8 @@ import org.navalplanner.business.workingday.ResourcesPerDay;
*/
public class BaseCalendar extends IntegrationEntity implements ICalendar {
private static final EffortDuration DEFAULT_VALUE = EffortDuration.zero();
private static final Capacity DEFAULT_VALUE = Capacity.zero()
.overAssignableWithoutLimit(true);
public static BaseCalendar create() {
return create(new BaseCalendar(CalendarData.create()));
@ -272,7 +273,8 @@ public class BaseCalendar extends IntegrationEntity implements ICalendar {
if (exceptionDay != null) {
return exceptionDay.getDuration();
}
return getDurationAt(date, getDayFrom(date));
return getCapacityConsideringCalendarDatasOn(date, getDayFrom(date))
.getStandardEffort();
}
private Days getDayFrom(LocalDate date) {
@ -287,23 +289,22 @@ public class BaseCalendar extends IntegrationEntity implements ICalendar {
return true;
}
public EffortDuration getDurationAt(LocalDate date, Days day) {
public Capacity getCapacityConsideringCalendarDatasOn(LocalDate date, Days day) {
CalendarData calendarData = getCalendarData(date);
EffortDuration duration = calendarData.getDurationAt(day);
Capacity capacity = calendarData.getCapacityOn(day);
BaseCalendar parent = getParent(date);
if (duration == null && parent != null) {
return parent.getDurationAt(date, day);
if (capacity == null && parent != null) {
return parent.getCapacityConsideringCalendarDatasOn(date, day);
}
return valueIfNotNullElseDefaultValue(duration);
return valueIfNotNullElseDefaultValue(capacity);
}
private EffortDuration valueIfNotNullElseDefaultValue(
EffortDuration duration) {
if (duration == null) {
private Capacity valueIfNotNullElseDefaultValue(Capacity capacity) {
if (capacity == null) {
return DEFAULT_VALUE;
}
return duration;
return capacity;
}
/**

8
navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CalendarData.java
View file

@ -111,8 +111,8 @@ public class CalendarData extends IntegrationEntity {
return capacity.getStandardEffort();
}
public EffortDuration getDurationAt(Days day) {
return toDuration(capacityPerDay.get(day.ordinal()));
public Capacity getCapacityOn(Days day) {
return capacityPerDay.get(day.ordinal());
}
public void setCapacityAt(Days day, Capacity capacity) {
@ -121,7 +121,7 @@ public class CalendarData extends IntegrationEntity {
public boolean isDefault(Days day) {
return getDurationAt(day) == null;
return getCapacityOn(day) == null;
}
public void setDefault(Days day) {
@ -175,7 +175,7 @@ public class CalendarData extends IntegrationEntity {
}
boolean isEmptyFor(Days day) {
return !isDefault(day) && getDurationAt(day).isZero() || isDefault(day)
return !isDefault(day) && getCapacityOn(day).isZero() || isDefault(day)
&& hasParent() && getParent().onlyGivesZeroHours(day);
}

4
navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/Capacity.java
View file

@ -98,6 +98,10 @@ public class Capacity {
}
}
public boolean isZero() {
return standardEffort.isZero();
}
public String getStandardEffortString() {
return asString(getStandardEffort());
}

9
navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarEditionController.java
View file

@ -86,6 +86,13 @@ import org.zkoss.zul.api.Window;
public abstract class BaseCalendarEditionController extends
GenericForwardComposer {
private static String asString(Capacity capacity) {
String extraEffortString = capacity.isOverAssignableWithoutLimit() ? _("unlimited")
: asString(capacity.getAllowedExtraEffort());
return asString(capacity.getStandardEffort()) + " " + extraEffortString;
}
private static String asString(EffortDuration duration) {
if (duration == null) {
return "";
@ -707,7 +714,7 @@ public abstract class BaseCalendarEditionController extends
summary.add("D");
}
} else {
summary.add(asString(calendarData.getDurationAt(day)));
summary.add(asString(calendarData.getCapacityOn(day)));
}
}
summaryListcell.appendChild(new Label(StringUtils.join(summary,

3
navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarModel.java
View file

@ -298,7 +298,8 @@ public class BaseCalendarModel extends IntegrationEntityModel implements
if (getBaseCalendar() == null) {
return EffortDuration.zero();
}
return getBaseCalendar().getDurationAt(selectedDate, day);
return getBaseCalendar().getCapacityConsideringCalendarDatasOn(
selectedDate, day).getStandardEffort();
}
@Override

45
navalplanner-webapp/src/test/java/org/navalplanner/web/calendars/BaseCalendarModelTest.java
View file

@ -42,7 +42,6 @@ import org.navalplanner.business.calendars.entities.Capacity;
import org.navalplanner.business.common.IAdHocTransactionService;
import org.navalplanner.business.common.IOnTransaction;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.workingday.EffortDuration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.annotation.NotTransactional;
@ -80,40 +79,41 @@ public class BaseCalendarModelTest {
baseCalendarModel.initCreate();
BaseCalendar baseCalendar = baseCalendarModel.getBaseCalendar();
baseCalendar.setName("Test");
setHours(baseCalendar, 8);
Capacity capacity = Capacity.create(hours(8));
setCapacity(baseCalendar, capacity);
baseCalendarModel.confirmSave();
assertThat(baseCalendarModel.getBaseCalendars().size(),
equalTo(previous + 1));
assertThat(baseCalendarModel.getBaseCalendars().get(previous).getId(),
equalTo(baseCalendar.getId()));
assertThat(baseCalendarModel.getBaseCalendars().get(previous)
.getDurationAt(new LocalDate(), Days.MONDAY), equalTo(hours(8)));
List<BaseCalendar> currentCalendars = baseCalendarModel
.getBaseCalendars();
assertThat(currentCalendars.size(), equalTo(previous + 1));
BaseCalendar createdCalendar = currentCalendars.get(previous);
assertThat(createdCalendar.getId(), equalTo(baseCalendar.getId()));
assertThat(createdCalendar.getCapacityConsideringCalendarDatasOn(
new LocalDate(), Days.MONDAY), equalTo(capacity));
}
private void setHours(BaseCalendar baseCalendar, Integer hours) {
EffortDuration hoursDuration = EffortDuration.hours(hours);
private void setCapacity(BaseCalendar baseCalendar, Capacity capacity) {
for (Days each : Days.values()) {
baseCalendar.setCapacityAt(each, Capacity.create(hoursDuration)
.overAssignableWithoutLimit(true));
baseCalendar.setCapacityAt(each, capacity);
}
}
@Test
@NotTransactional
public void testEditAndSave() throws ValidationException {
final Capacity capacity = Capacity.create(hours(4));
doEditsSaveAndThenAsserts(new IOnExistentCalendar() {
@Override
public void onExistentCalendar(BaseCalendar calendar) {
setHours(calendar, 4);
setCapacity(calendar, capacity);
}
}, new IOnExistentCalendar() {
@Override
public void onExistentCalendar(BaseCalendar calendar) {
assertThat(
calendar.getDurationAt(new LocalDate(), Days.MONDAY),
equalTo(hours(4)));
assertThat(calendar.getCapacityConsideringCalendarDatasOn(
new LocalDate(), Days.MONDAY), equalTo(capacity));
}
});
}
@ -158,20 +158,21 @@ public class BaseCalendarModelTest {
@Test
public void testEditAndNewVersion() {
final Capacity capacity = Capacity.create(hours(4));
final LocalDate date = new LocalDate().plusWeeks(1);
doEditsSaveAndThenAsserts(new IOnExistentCalendar() {
@Override
public void onExistentCalendar(BaseCalendar calendar) {
baseCalendarModel.createNewVersion(date);
setHours(baseCalendarModel.getBaseCalendar(), 4);
setCapacity(baseCalendarModel.getBaseCalendar(), capacity);
}
}, new IOnExistentCalendar() {
@Override
public void onExistentCalendar(BaseCalendar calendar) {
assertThat(calendar.getDurationAt(date, Days.MONDAY),
equalTo(hours(4)));
assertThat(calendar.getCapacityConsideringCalendarDatasOn(date,
Days.MONDAY), equalTo(capacity));
assertThat(calendar.getCalendarDataVersions().size(),
equalTo(2));
}
@ -182,7 +183,8 @@ public class BaseCalendarModelTest {
baseCalendarModel.initCreate();
baseCalendarModel.getBaseCalendar().setName(
"Test" + UUID.randomUUID().toString());
setHours(baseCalendarModel.getBaseCalendar(), 8);
setCapacity(baseCalendarModel.getBaseCalendar(),
Capacity.create(hours(8)));
baseCalendarModel.confirmSave();
return baseCalendarModel.getBaseCalendar();
}
@ -206,7 +208,8 @@ public class BaseCalendarModelTest {
baseCalendarModel.initCreate();
baseCalendarModel.getBaseCalendar().setName("Test");
setHours(baseCalendarModel.getBaseCalendar(), 8);
setCapacity(baseCalendarModel.getBaseCalendar(),
Capacity.create(hours(8)));
BaseCalendar parent = baseCalendarModel.getBaseCalendar();
baseCalendarModel.createNewVersion(new LocalDate().plusMonths(1));
BaseCalendar parentNewVersion = baseCalendarModel.getBaseCalendar();

11
navalplanner-webapp/src/test/java/org/navalplanner/web/test/ws/basecalendars/BaseCalendarServiceTest.java
View file

@ -43,6 +43,7 @@ import org.navalplanner.business.calendars.daos.ICalendarExceptionTypeDAO;
import org.navalplanner.business.calendars.entities.BaseCalendar;
import org.navalplanner.business.calendars.entities.CalendarData;
import org.navalplanner.business.calendars.entities.CalendarExceptionType;
import org.navalplanner.business.calendars.entities.Capacity;
import org.navalplanner.business.common.IAdHocTransactionService;
import org.navalplanner.business.common.IOnTransaction;
import org.navalplanner.business.common.daos.IConfigurationDAO;
@ -216,10 +217,12 @@ public class BaseCalendarServiceTest {
assertTrue(baseCalendar.getCalendarDataVersions().size() == 2);
CalendarData data = baseCalendar.getCalendarDataByCode("codeData");
assertEquals(EffortDuration.hours(4),
data.getDurationAt(CalendarData.Days.FRIDAY));
assertEquals(EffortDuration.hours(4),
data.getDurationAt(CalendarData.Days.TUESDAY));
assertEquals(Capacity.create(EffortDuration.hours(4))
.overAssignableWithoutLimit(true),
data.getCapacityOn(CalendarData.Days.FRIDAY));
assertEquals(Capacity.create(EffortDuration.hours(4))
.overAssignableWithoutLimit(true),
data.getCapacityOn(CalendarData.Days.TUESDAY));
}
@Test