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

Rename method to better name

Browse source 
FEA: ItEr60S19TimeUnitDataType
This commit is contained in:
Óscar González Fernández 2010-09-15 20:36:31 +02:00
parent 846c3a040d
commit 9fe1a8d943
17 changed files with 84 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -287,7 +287,7 @@ public class BaseCalendar extends IntegrationEntity implements ICalendar {
return null;
}
public EffortDuration getCapacityDurationAt(LocalDate date) {
public EffortDuration getCapacityOn(LocalDate date) {
return getWorkableTimeAt(date);
}
@ -382,7 +382,7 @@ public class BaseCalendar extends IntegrationEntity implements ICalendar {
EffortDuration result = zero();
for (LocalDate current = init; current.compareTo(end) <= 0; current = current
.plusDays(1)) {
result = result.plus(getCapacityDurationAt(current));
result = result.plus(getCapacityOn(current));
init = init.plusDays(1);
}
return result;
@ -525,7 +525,7 @@ public class BaseCalendar extends IntegrationEntity implements ICalendar {
}
return DayType.ANCESTOR_EXCEPTION;
}
if (getCapacityDurationAt(date).isZero()) {
if (getCapacityOn(date).isZero()) {
return DayType.ZERO_HOURS;
}
return DayType.NORMAL;
@ -728,7 +728,7 @@ public class BaseCalendar extends IntegrationEntity implements ICalendar {
Set<LocalDate> result = new HashSet<LocalDate>();
for (LocalDate current = init; current.compareTo(end) <= 0; current = current
.plusDays(1)) {
if (getCapacityDurationAt(current).isZero()) {
if (getCapacityOn(current).isZero()) {
result.add(current);
}
}

6
navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CombinedWorkHours.java
View file

@ -72,12 +72,12 @@ public abstract class CombinedWorkHours implements ICalendar {
}
@Override
public EffortDuration getCapacityDurationAt(LocalDate date) {
public EffortDuration getCapacityOn(LocalDate date) {
EffortDuration current = null;
for (ICalendar workHour : calendars) {
current = current == null ? workHour.getCapacityDurationAt(date)
current = current == null ? workHour.getCapacityOn(date)
: updateCapacity(current,
workHour.getCapacityDurationAt(date));
workHour.getCapacityOn(date));
}
return current;
}

2
navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/ICalendar.java
View file

@ -44,7 +44,7 @@ public interface ICalendar {
* the date at which the capacity is calculated
* @return the capacity at which the resource can work
*/
public EffortDuration getCapacityDurationAt(LocalDate date);
public EffortDuration getCapacityOn(LocalDate date);
public AvailabilityTimeLine getAvailability();

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

@ -66,20 +66,20 @@ public class ResourceCalendar extends BaseCalendar {
}
public Integer getCapacity(LocalDate from, LocalDate to) {
EffortDuration result = getCapacityDurationAt(to);
EffortDuration result = getCapacityOn(to);
for (LocalDate date = from; date.isBefore(to);) {
result = result.plus(getCapacityDurationAt(date));
result = result.plus(getCapacityOn(date));
date = date.plusDays(1);
}
return result.roundToHours();
}
@Override
public EffortDuration getCapacityDurationAt(LocalDate date) {
public EffortDuration getCapacityOn(LocalDate date) {
if (!isActive(date)) {
return EffortDuration.zero();
}
return multiplyByCapacity(super.getCapacityDurationAt(date));
return multiplyByCapacity(super.getCapacityOn(date));
}
protected Integer multiplyByCapacity(Integer duration) {

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

@ -42,13 +42,13 @@ public class SameWorkHoursEveryDay implements ICalendar {
}
@Override
public EffortDuration getCapacityDurationAt(LocalDate date) {
public EffortDuration getCapacityOn(LocalDate date) {
return EffortDuration.hours(hours);
}
@Override
public EffortDuration asDurationOn(LocalDate day, ResourcesPerDay amount) {
return amount.asDurationGivenWorkingDayOf(getCapacityDurationAt(day));
return amount.asDurationGivenWorkingDayOf(getCapacityOn(day));
}
@Override

2
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
View file

@ -634,7 +634,7 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
AvailabilityTimeLine availability) {
if (availability.isValid(day)) {
EffortDuration capacityAtDay = getAllocationCalendar()
.getCapacityDurationAt(day);
.getCapacityOn(day);
return new Share(-capacityAtDay.getSeconds());
} else {
return new Share(Integer.MAX_VALUE);

4
navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/Gap.java
View file

@ -127,7 +127,7 @@ public class Gap implements Comparable<Gap> {
final ResourceCalendar calendar = resource.getCalendar();
int capacityRounded = calendar.getCapacityDurationAt(startDate)
int capacityRounded = calendar.getCapacityOn(startDate)
.roundToHours();
if (startDate.equals(endDate)) {
return capacityRounded - Math.max(startHour, endHour);
@ -176,7 +176,7 @@ public class Gap implements Comparable<Gap> {
private int getHoursAtDay(LocalDate day, BaseCalendar calendar,
DateAndHour realStart, boolean isFirst, final boolean isLast) {
final int capacity = calendar.getCapacityDurationAt(day).roundToHours();
final int capacity = calendar.getCapacityOn(day).roundToHours();
if (isLast && isFirst) {
return Math.min(endTime.getHour() - realStart.getHour(),
capacity);

2
navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java
View file

@ -887,7 +887,7 @@ public abstract class Resource extends IntegrationEntity {
for (int i = 0; i < days; i++) {
LocalDate current = start.plusDays(i);
EffortDuration capacityCurrent = calendar
.getCapacityDurationAt(current);
.getCapacityOn(current);
if (capacityCurrent != null
&& (criterionToSatisfy == null || satisfiesCriterionAt(
criterionToSatisfy, current))) {

98
navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/BaseCalendarTest.java
View file

@ -142,15 +142,15 @@ public class BaseCalendarTest {
}
@Test
public void testGetWorkableHoursBasic() {
public void testCapacityOnBasic() {
BaseCalendar calendar = createBasicCalendar();
EffortDuration wednesdayHours = calendar
.getCapacityDurationAt(WEDNESDAY_LOCAL_DATE);
.getCapacityOn(WEDNESDAY_LOCAL_DATE);
assertThat(wednesdayHours, equalTo(hours(8)));
EffortDuration sundayHours = calendar
.getCapacityDurationAt(SUNDAY_LOCAL_DATE);
.getCapacityOn(SUNDAY_LOCAL_DATE);
assertThat(sundayHours, equalTo(zero()));
}
@ -161,11 +161,11 @@ public class BaseCalendarTest {
}
@Test
public void testGetWorkableHoursChristmas() {
public void testCapacityOnChristmas() {
BaseCalendar calendar = createChristmasCalendar();
EffortDuration duration = calendar
.getCapacityDurationAt(CHRISTMAS_DAY_LOCAL_DATE);
.getCapacityOn(CHRISTMAS_DAY_LOCAL_DATE);
assertThat(duration, equalTo(EffortDuration.zero()));
}
@ -178,29 +178,29 @@ public class BaseCalendarTest {
}
@Test
public void testGetWorkableHoursDerivedBasicCalendar() {
public void testCapacityOnDerivedBasicCalendar() {
BaseCalendar calendar = createBasicCalendar().newDerivedCalendar();
EffortDuration wednesdayHours = calendar
.getCapacityDurationAt(WEDNESDAY_LOCAL_DATE);
.getCapacityOn(WEDNESDAY_LOCAL_DATE);
assertThat(wednesdayHours, equalTo(hours(8)));
EffortDuration sundayHours = calendar
.getCapacityDurationAt(SUNDAY_LOCAL_DATE);
.getCapacityOn(SUNDAY_LOCAL_DATE);
assertThat(sundayHours, equalTo(zero()));
}
@Test
public void testGetWorkableHoursDerivedChristmasCalendar() {
public void testCapacityOnDerivedChristmasCalendar() {
BaseCalendar calendar = createChristmasCalendar().newDerivedCalendar();
EffortDuration hours = calendar
.getCapacityDurationAt(CHRISTMAS_DAY_LOCAL_DATE);
.getCapacityOn(CHRISTMAS_DAY_LOCAL_DATE);
assertThat(hours, equalTo(EffortDuration.zero()));
}
@Test
public void testGetWorkableHoursDerivedBasicCalendarWithException() {
public void testCapacityOnDerivedBasicCalendarWithException() {
BaseCalendar calendar = createBasicCalendar().newDerivedCalendar();
CalendarException day = CalendarException.create(WEDNESDAY_LOCAL_DATE,
@ -208,20 +208,20 @@ public class BaseCalendarTest {
calendar.addExceptionDay(day);
EffortDuration mondayHours = calendar
.getCapacityDurationAt(MONDAY_LOCAL_DATE);
.getCapacityOn(MONDAY_LOCAL_DATE);
assertThat(mondayHours, equalTo(hours(8)));
EffortDuration wednesdayHours = calendar
.getCapacityDurationAt(WEDNESDAY_LOCAL_DATE);
.getCapacityOn(WEDNESDAY_LOCAL_DATE);
assertThat(wednesdayHours, equalTo(hours(4)));
EffortDuration sundayHours = calendar
.getCapacityDurationAt(SUNDAY_LOCAL_DATE);
.getCapacityOn(SUNDAY_LOCAL_DATE);
assertThat(sundayHours, equalTo(zero()));
}
@Test
public void testGetWorkableHoursDerivedChristmasCalendarRedefiningExceptionDay() {
public void testCapacityOnDerivedChristmasCalendarRedefiningExceptionDay() {
BaseCalendar calendar = createChristmasCalendar().newDerivedCalendar();
CalendarException day = CalendarException.create(
@ -230,12 +230,12 @@ public class BaseCalendarTest {
calendar.addExceptionDay(day);
EffortDuration hours = calendar
.getCapacityDurationAt(CHRISTMAS_DAY_LOCAL_DATE);
.getCapacityOn(CHRISTMAS_DAY_LOCAL_DATE);
assertThat(hours, equalTo(hours(4)));
}
@Test
public void testGettWorkableHoursInterval() {
public void testCapacityOnInterval() {
BaseCalendar calendar = createBasicCalendar();
int mondayToWednesdayHours = calendar.getWorkableHours(
@ -244,7 +244,7 @@ public class BaseCalendarTest {
}
@Test
public void testGettWorkableHoursPerWeek() {
public void testCapacityOnPerWeek() {
BaseCalendar calendar = createBasicCalendar();
int weekHours = calendar.getWorkableHoursPerWeek(WEDNESDAY_LOCAL_DATE);
@ -301,47 +301,47 @@ public class BaseCalendarTest {
}
@Test
public void testGettWorkableHoursNewVersion() {
public void testCapacityOnNewVersion() {
BaseCalendar calendar = createBasicCalendar();
calendar.newVersion(MONDAY_LOCAL_DATE);
calendar.setDurationAt(Days.WEDNESDAY, hours(4));
calendar.setDurationAt(Days.SUNDAY, hours(4));
assertThat(calendar.getCapacityDurationAt(WEDNESDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(WEDNESDAY_LOCAL_DATE),
equalTo(hours(4)));
assertThat(calendar.getCapacityDurationAt(WEDNESDAY_LOCAL_DATE
assertThat(calendar.getCapacityOn(WEDNESDAY_LOCAL_DATE
.minusWeeks(1)), equalTo(hours(8)));
assertThat(calendar.getCapacityDurationAt(SUNDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(SUNDAY_LOCAL_DATE),
equalTo(hours(4)));
assertThat(
calendar.getCapacityDurationAt(SUNDAY_LOCAL_DATE.minusWeeks(1)),
calendar.getCapacityOn(SUNDAY_LOCAL_DATE.minusWeeks(1)),
equalTo(zero()));
}
@Test
public void testGettWorkableHoursNewVersionCheckingLimits() {
public void testCapacityOnNewVersionCheckingLimits() {
BaseCalendar calendar = createBasicCalendar();
calendar.newVersion(MONDAY_LOCAL_DATE);
calendar.setDurationAt(Days.MONDAY, hours(1));
calendar.setDurationAt(Days.SUNDAY, hours(2));
assertThat(calendar.getCapacityDurationAt(MONDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(MONDAY_LOCAL_DATE),
equalTo(hours(1)));
assertThat(calendar.getCapacityDurationAt(SUNDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(SUNDAY_LOCAL_DATE),
equalTo(hours(2)));
assertThat(
calendar.getCapacityDurationAt(MONDAY_LOCAL_DATE.minusWeeks(1)),
calendar.getCapacityOn(MONDAY_LOCAL_DATE.minusWeeks(1)),
equalTo(hours(8)));
assertThat(
calendar.getCapacityDurationAt(MONDAY_LOCAL_DATE.minusDays(1)),
calendar.getCapacityOn(MONDAY_LOCAL_DATE.minusDays(1)),
equalTo(zero()));
}
@ -372,7 +372,7 @@ public class BaseCalendarTest {
}
@Test
public void testGettWorkableHoursNewVersionFromChristmasCalendar() {
public void testCapacityOnNewVersionFromChristmasCalendar() {
BaseCalendar calendar = createChristmasCalendar();
CalendarException day = CalendarException.create(
CHRISTMAS_DAY_LOCAL_DATE.plusYears(1), EffortDuration.zero(),
@ -385,10 +385,10 @@ public class BaseCalendarTest {
hours(8),
createCalendarExceptionType());
assertThat(calendar.getCapacityDurationAt(CHRISTMAS_DAY_LOCAL_DATE
assertThat(calendar.getCapacityOn(CHRISTMAS_DAY_LOCAL_DATE
.plusYears(1)), equalTo(hours(8)));
assertThat(calendar.getCapacityDurationAt(CHRISTMAS_DAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(CHRISTMAS_DAY_LOCAL_DATE),
equalTo(zero()));
}
@ -400,7 +400,7 @@ public class BaseCalendarTest {
}
@Test
public void testGettWorkableHoursTwoNewVersions() {
public void testCapacityOnTwoNewVersions() {
BaseCalendar calendar = createBasicCalendar();
setHoursForAllDays(calendar, 8);
@ -410,19 +410,19 @@ public class BaseCalendarTest {
calendar.newVersion(FRIDAY_LOCAL_DATE);
setHoursForAllDays(calendar, 2);
assertThat(calendar.getCapacityDurationAt(MONDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(MONDAY_LOCAL_DATE),
equalTo(hours(8)));
assertThat(calendar.getCapacityDurationAt(WEDNESDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(WEDNESDAY_LOCAL_DATE),
equalTo(hours(4)));
assertThat(calendar.getCapacityDurationAt(FRIDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(FRIDAY_LOCAL_DATE),
equalTo(hours(2)));
}
@Test
public void testGettWorkableHoursDeriveAndNewVersion() {
public void testCapacityOnDeriveAndNewVersion() {
BaseCalendar baseCalendar = createChristmasCalendar();
BaseCalendar calendar = baseCalendar.newDerivedCalendar();
@ -431,19 +431,19 @@ public class BaseCalendarTest {
calendar.newVersion(WEDNESDAY_LOCAL_DATE);
setHoursForAllDays(calendar, 2);
assertThat(baseCalendar.getCapacityDurationAt(MONDAY_LOCAL_DATE),
assertThat(baseCalendar.getCapacityOn(MONDAY_LOCAL_DATE),
equalTo(hours(8)));
assertThat(calendar.getCapacityDurationAt(MONDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(MONDAY_LOCAL_DATE),
equalTo(hours(4)));
assertThat(baseCalendar.getCapacityDurationAt(FRIDAY_LOCAL_DATE),
assertThat(baseCalendar.getCapacityOn(FRIDAY_LOCAL_DATE),
equalTo(hours(8)));
assertThat(calendar.getCapacityDurationAt(FRIDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(FRIDAY_LOCAL_DATE),
equalTo(hours(2)));
assertThat(calendar.getCapacityDurationAt(CHRISTMAS_DAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(CHRISTMAS_DAY_LOCAL_DATE),
equalTo(zero()));
}
@ -471,7 +471,7 @@ public class BaseCalendarTest {
private void thenForAllDaysReturnsZero() {
for (LocalDate localDate : DAYS_OF_A_WEEK_EXAMPLE) {
assertThat(calendarFixture.getCapacityDurationAt(localDate),
assertThat(calendarFixture.getCapacityOn(localDate),
equalTo(zero()));
}
}
@ -571,7 +571,7 @@ public class BaseCalendarTest {
calendar.setParent(parent);
assertThat(calendar.getParent(), equalTo(parent));
assertThat(calendar.getCapacityDurationAt(CHRISTMAS_DAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(CHRISTMAS_DAY_LOCAL_DATE),
equalTo(zero()));
}
@ -581,7 +581,7 @@ public class BaseCalendarTest {
BaseCalendar derived = calendar.newDerivedCalendar();
BaseCalendar copy = derived.newCopy();
assertThat(copy.getCapacityDurationAt(CHRISTMAS_DAY_LOCAL_DATE),
assertThat(copy.getCapacityOn(CHRISTMAS_DAY_LOCAL_DATE),
equalTo(zero()));
assertThat(copy.getParent(), equalTo(calendar));
assertThat(copy.getCalendarDataVersions().size(), equalTo(1));
@ -594,7 +594,7 @@ public class BaseCalendarTest {
}
@Test
public void testGettWorkableHoursNewVersionChangeParent() {
public void testCapacityOnNewVersionChangeParent() {
BaseCalendar parent1 = createBasicCalendar();
setHoursForAllDays(parent1, 8);
BaseCalendar parent2 = createBasicCalendar();
@ -609,10 +609,10 @@ public class BaseCalendarTest {
assertThat(calendar.getParent(MONDAY_LOCAL_DATE),
equalTo(parent1));
assertThat(calendar.getCapacityDurationAt(MONDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(MONDAY_LOCAL_DATE),
equalTo(hours(8)));
assertThat(calendar.getCapacityDurationAt(FRIDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(FRIDAY_LOCAL_DATE),
equalTo(hours(4)));
}
@ -626,10 +626,10 @@ public class BaseCalendarTest {
calendar.addExceptionDay(CalendarException.create(FRIDAY_LOCAL_DATE,
zero(), createCalendarExceptionType()));
assertThat(calendar.getCapacityDurationAt(MONDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(MONDAY_LOCAL_DATE),
equalTo(zero()));
assertThat(calendar.getCapacityDurationAt(FRIDAY_LOCAL_DATE),
assertThat(calendar.getCapacityOn(FRIDAY_LOCAL_DATE),
equalTo(zero()));
assertThat(calendar.getOwnExceptions().size(), equalTo(2));

4
navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/CombinedWorkHoursTest.java
View file

@ -58,14 +58,14 @@ public class CombinedWorkHoursTest {
public void returnsTheMinOfCalendars() {
ICalendar minOf = CombinedWorkHours
.minOf(hours(4), hours(2), hours(7));
EffortDuration duration = minOf.getCapacityDurationAt(new LocalDate(
EffortDuration duration = minOf.getCapacityOn(new LocalDate(
2000, 3, 3));
assertThat(duration, equalTo(EffortDuration.hours(2)));
}
private ICalendar hours(int hours) {
ICalendar result = createNiceMock(ICalendar.class);
expect(result.getCapacityDurationAt(isA(LocalDate.class))).andReturn(
expect(result.getCapacityOn(isA(LocalDate.class))).andReturn(
EffortDuration.hours(hours));
replay(result);
return result;

4
navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/ResourceCalendarTest.java
View file

@ -66,9 +66,9 @@ public class ResourceCalendarTest {
public void testGetWorkableHours() {
ResourceCalendar calendar = createBasicResourceCalendar();
assertThat(calendar.getCapacityDurationAt(PAST),
assertThat(calendar.getCapacityOn(PAST),
equalTo(EffortDuration.zero()));
assertThat(calendar.getCapacityDurationAt(FUTURE),
assertThat(calendar.getCapacityOn(FUTURE),
equalTo(EffortDuration.hours(8)));
}

6
navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/GenericResourceAllocationTest.java
View file

@ -230,7 +230,7 @@ public class GenericResourceAllocationTest {
private <T extends BaseCalendar> T createCalendar(Class<T> klass,
final int hoursPerDay) {
BaseCalendar baseCalendar = createNiceMock(klass);
expect(baseCalendar.getCapacityDurationAt(isA(LocalDate.class)))
expect(baseCalendar.getCapacityOn(isA(LocalDate.class)))
.andReturn(hours(hoursPerDay)).anyTimes();
expect(baseCalendar.isActive(isA(LocalDate.class))).andReturn(true)
.anyTimes();
@ -419,7 +419,7 @@ public class GenericResourceAllocationTest {
public void allocatingSeveralResourcesPerDayHavingJustOneResourceProducesOvertime() {
LocalDate start = new LocalDate(2006, 10, 5);
final Integer standardHoursPerDay = SameWorkHoursEveryDay
.getDefaultWorkingDay().getCapacityDurationAt(start).getHours();
.getDefaultWorkingDay().getCapacityOn(start).getHours();
final int TASK_DURATION_DAYS = 4;
givenBaseCalendarWithoutExceptions(standardHoursPerDay);
givenTaskWithStartAndEnd(toInterval(start, Period
@ -460,7 +460,7 @@ public class GenericResourceAllocationTest {
LocalDate start = new LocalDate(2006, 10, 5);
final int TASK_DURATION_DAYS = 1;
final Integer defaultWorkableHours = SameWorkHoursEveryDay
.getDefaultWorkingDay().getCapacityDurationAt(start).getHours();
.getDefaultWorkingDay().getCapacityOn(start).getHours();
givenBaseCalendarWithoutExceptions(defaultWorkableHours);
givenTaskWithStartAndEnd(toInterval(start, Period
.days(TASK_DURATION_DAYS)));

4
navalplanner-business/src/test/java/org/navalplanner/business/test/planner/entities/SpecificResourceAllocationTest.java
View file

@ -78,7 +78,7 @@ public class SpecificResourceAllocationTest {
private void givenResourceCalendarAlwaysReturning(final int hours) {
this.calendar = createNiceMock(ResourceCalendar.class);
expect(this.calendar.getCapacityDurationAt(isA(LocalDate.class)))
expect(this.calendar.getCapacityOn(isA(LocalDate.class)))
.andReturn(EffortDuration.hours(hours)).anyTimes();
expect(
this.calendar.asDurationOn(isA(LocalDate.class),
@ -115,7 +115,7 @@ public class SpecificResourceAllocationTest {
private void givenResourceCalendar(final int defaultAnswer, final Map<LocalDate, Integer> answersForDates){
this.calendar = createNiceMock(ResourceCalendar.class);
expect(this.calendar.getCapacityDurationAt(isA(LocalDate.class)))
expect(this.calendar.getCapacityOn(isA(LocalDate.class)))
.andAnswer(new IAnswer<EffortDuration>() {
@Override

4
navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/QueueComponent.java
View file

@ -336,7 +336,7 @@ public class QueueComponent extends XulElement implements
int workableHours = queueElement.getLimitingResourceQueue()
.getResource().getCalendar()
.getCapacityDurationAt(queueElement.getEndDate())
.getCapacityOn(queueElement.getEndDate())
.roundToHours();
int shadeWidth = new Long((24 - workableHours)
@ -367,7 +367,7 @@ public class QueueComponent extends XulElement implements
int workableHours = queueElement.getLimitingResourceQueue()
.getResource().getCalendar()
.getCapacityDurationAt(queueElement.getEndDate())
.getCapacityOn(queueElement.getEndDate())
.roundToHours();
int shadeWidth = new Long((24 - workableHours)

2
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/chart/ChartFiller.java
View file

@ -104,7 +104,7 @@ public abstract class ChartFiller implements IChartFiller {
protected static EffortDuration calendarCapacityFor(Resource resource,
LocalDate day) {
return resource.getCalendarOrDefault().getCapacityDurationAt(day);
return resource.getCalendarOrDefault().getCapacityOn(day);
}
protected abstract class GraphicSpecificationCreator implements

6
navalplanner-webapp/src/main/java/org/navalplanner/web/planner/company/CompanyPlanningModel.java
View file

@ -852,9 +852,9 @@ public abstract class CompanyPlanningModel implements ICompanyPlanningModel {
BaseCalendar calendar = resource.getCalendar();
EffortDuration workableTime = SameWorkHoursEveryDay
.getDefaultWorkingDay().getCapacityDurationAt(day);
.getDefaultWorkingDay().getCapacityOn(day);
if (calendar != null) {
workableTime = calendar.getCapacityDurationAt(day);
workableTime = calendar.getCapacityOn(day);
}
EffortDuration assignedDuration = durationsGrouped.get(day)
@ -896,7 +896,7 @@ public abstract class CompanyPlanningModel implements ICompanyPlanningModel {
Resource resource, EffortDuration assignedDuration) {
ICalendar calendar = resource.getCalendarOrDefault();
EffortDuration workableDuration = calendar
.getCapacityDurationAt(day);
.getCapacityOn(day);
if (assignedDuration.compareTo(workableDuration) > 0) {
return assignedDuration.minus(workableDuration);
}

4
navalplanner-webapp/src/main/java/org/navalplanner/web/resourceload/ResourceLoadController.java
View file

@ -698,7 +698,7 @@ public class ResourceLoadController implements Composer {
EffortDuration assignedDuration = resourceWithDuration
.getValue();
EffortDuration resourceCapacity = resource
.getCalendarOrDefault().getCapacityDurationAt(day);
.getCalendarOrDefault().getCapacityOn(day);
result = result
.plus(min(assignedDuration, resourceCapacity));
}
@ -720,7 +720,7 @@ public class ResourceLoadController implements Composer {
EffortDuration assignedDuration = resourceWithDuration
.getValue();
EffortDuration resourceCapacity = resource
.getCalendarOrDefault().getCapacityDurationAt(day);
.getCalendarOrDefault().getCapacityOn(day);
EffortDuration overloadIncrement = assignedDuration
.minus(min(resourceCapacity, assignedDuration));
result = result.plus(overloadIncrement);