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

Rename IWorkHours to ICalendar

Browse source 
IWorkHours no longer works with hours so its name was confusing.

FEA: ItEr60S19TimeUnitDataType
This commit is contained in:
Óscar González Fernández 2010-09-15 18:34:44 +02:00
parent 30bcdb2573
commit 85d0caf22c
13 changed files with 81 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -50,7 +50,7 @@ import org.navalplanner.business.workingday.ResourcesPerDay;
* some exceptions of its parent calendar.
* @author Manuel Rego Casasnovas <mrego@igalia.com>
*/
public class BaseCalendar extends IntegrationEntity implements IWorkHours {
public class BaseCalendar extends IntegrationEntity implements ICalendar {
private static final EffortDuration DEFAULT_VALUE = EffortDuration.zero();

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

@ -34,22 +34,22 @@ import org.joda.time.LocalDate;
import org.navalplanner.business.workingday.EffortDuration;
import org.navalplanner.business.workingday.ResourcesPerDay;
public abstract class CombinedWorkHours implements IWorkHours {
public abstract class CombinedWorkHours implements ICalendar {
private final List<IWorkHours> workHours;
private final List<ICalendar> calendars;
public CombinedWorkHours(Collection<? extends IWorkHours> workHours) {
Validate.notNull(workHours);
Validate.isTrue(!workHours.isEmpty());
this.workHours = notNull(workHours);
Validate.isTrue(!this.workHours.isEmpty(),
public CombinedWorkHours(Collection<? extends ICalendar> calendars) {
Validate.notNull(calendars);
Validate.isTrue(!calendars.isEmpty());
this.calendars = notNull(calendars);
Validate.isTrue(!this.calendars.isEmpty(),
"there should be at least one workHours not null");
}
private static List<IWorkHours> notNull(
Collection<? extends IWorkHours> workHours) {
List<IWorkHours> result = new ArrayList<IWorkHours>();
for (IWorkHours each : workHours) {
private static List<ICalendar> notNull(
Collection<? extends ICalendar> calendars) {
List<ICalendar> result = new ArrayList<ICalendar>();
for (ICalendar each : calendars) {
if (each != null) {
result.add(each);
}
@ -57,24 +57,24 @@ public abstract class CombinedWorkHours implements IWorkHours {
return result;
}
public static CombinedWorkHours minOf(IWorkHours... workHours) {
public static CombinedWorkHours minOf(ICalendar... workHours) {
Validate.notNull(workHours);
return new Min(asList(workHours));
}
public static CombinedWorkHours maxOf(IWorkHours... workHours) {
public static CombinedWorkHours maxOf(ICalendar... workHours) {
return maxOf(asList(workHours));
}
public static CombinedWorkHours maxOf(
Collection<? extends IWorkHours> workHours) {
return new Max(workHours);
Collection<? extends ICalendar> calendars) {
return new Max(calendars);
}
@Override
public EffortDuration getCapacityDurationAt(LocalDate date) {
EffortDuration current = null;
for (IWorkHours workHour : workHours) {
for (ICalendar workHour : calendars) {
current = current == null ? workHour.getCapacityDurationAt(date)
: updateCapacity(current,
workHour.getCapacityDurationAt(date));
@ -85,7 +85,7 @@ public abstract class CombinedWorkHours implements IWorkHours {
@Override
public EffortDuration asDurationOn(LocalDate day, ResourcesPerDay amount) {
EffortDuration result = null;
for (IWorkHours each : workHours) {
for (ICalendar each : calendars) {
result = result == null ? each.asDurationOn(day, amount)
: updateDuration(result, each.asDurationOn(day, amount));
}
@ -95,7 +95,7 @@ public abstract class CombinedWorkHours implements IWorkHours {
@Override
public AvailabilityTimeLine getAvailability() {
AvailabilityTimeLine result = AvailabilityTimeLine.allValid();
for (IWorkHours each : workHours) {
for (ICalendar each : calendars) {
result = compoundAvailability(result, each.getAvailability());
}
return result;
@ -120,8 +120,8 @@ public abstract class CombinedWorkHours implements IWorkHours {
class Min extends CombinedWorkHours {
public Min(List<IWorkHours> workHours) {
super(workHours);
public Min(List<ICalendar> calendars) {
super(calendars);
}
@Override
@ -146,8 +146,8 @@ class Min extends CombinedWorkHours {
class Max extends CombinedWorkHours {
public Max(Collection<? extends IWorkHours> workHours) {
super(workHours);
public Max(Collection<? extends ICalendar> calendars) {
super(calendars);
}
@Override

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

@ -24,7 +24,7 @@ import org.joda.time.LocalDate;
import org.navalplanner.business.workingday.EffortDuration;
import org.navalplanner.business.workingday.ResourcesPerDay;
public interface IWorkHours {
public interface ICalendar {
/**
* Translates the received amount into the corresponding duration at the

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

@ -25,7 +25,7 @@ import org.joda.time.LocalDate;
import org.navalplanner.business.workingday.EffortDuration;
import org.navalplanner.business.workingday.ResourcesPerDay;
public class SameWorkHoursEveryDay implements IWorkHours {
public class SameWorkHoursEveryDay implements ICalendar {
private static final SameWorkHoursEveryDay DEFAULT_WORKING_DAY = new SameWorkHoursEveryDay(
8);

14
navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/ThereAreHoursOnWorkHoursCalculator.java
View file

@ -43,7 +43,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
/**
* Caculates if there are enough hours
*/
public static boolean thereIsAvailableCapacityFor(IWorkHours workHours,
public static boolean thereIsAvailableCapacityFor(ICalendar calendar,
AvailabilityTimeLine availability,
ResourcesPerDay resourcesPerDay, EffortDuration effortToAllocate) {
if (effortToAllocate.isZero()) {
@ -52,7 +52,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
if (resourcesPerDay.isZero()) {
return false;
}
AvailabilityTimeLine realAvailability = workHours.getAvailability()
AvailabilityTimeLine realAvailability = calendar.getAvailability()
.and(availability);
List<Interval> validPeriods = realAvailability.getValidPeriods();
if (validPeriods.isEmpty()) {
@ -65,7 +65,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
|| first.getStart().equals(StartOfTime.create());
return isOpenEnded
|| thereAreCapacityOn(workHours, effortToAllocate,
|| thereAreCapacityOn(calendar, effortToAllocate,
resourcesPerDay,
validPeriods);
@ -75,7 +75,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
return validPeriods.get(validPeriods.size() - 1);
}
private static boolean thereAreCapacityOn(IWorkHours workHours,
private static boolean thereAreCapacityOn(ICalendar calendar,
EffortDuration effortToAllocate,
ResourcesPerDay resourcesPerDay, List<Interval> validPeriods) {
EffortDuration sum = zero();
@ -83,7 +83,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
FixedPoint start = (FixedPoint) each.getStart();
FixedPoint end = (FixedPoint) each.getEnd();
EffortDuration pending = effortToAllocate.minus(sum);
sum = sum.plus(sumDurationUntil(workHours, pending,
sum = sum.plus(sumDurationUntil(calendar, pending,
resourcesPerDay, start.getDate(), end.getDate()));
if (sum.compareTo(effortToAllocate) >= 0) {
return true;
@ -92,7 +92,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
return false;
}
private static EffortDuration sumDurationUntil(IWorkHours workHours,
private static EffortDuration sumDurationUntil(ICalendar calendar,
EffortDuration maximum,
ResourcesPerDay resourcesPerDay,
LocalDate start, LocalDate end) {
@ -100,7 +100,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
int days = org.joda.time.Days.daysBetween(start, end).getDays();
for (int i = 0; i < days; i++) {
LocalDate current = start.plusDays(i);
result = result.plus(workHours.asDurationOn(current, resourcesPerDay));
result = result.plus(calendar.asDurationOn(current, resourcesPerDay));
if (result.compareTo(maximum) >= 0) {
return maximum;
}

12
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/EffortDistributor.java
View file

@ -28,7 +28,7 @@ import java.util.List;
import org.apache.commons.lang.Validate;
import org.joda.time.LocalDate;
import org.navalplanner.business.calendars.entities.IWorkHours;
import org.navalplanner.business.calendars.entities.ICalendar;
import org.navalplanner.business.calendars.entities.ResourceCalendar;
import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
import org.navalplanner.business.resources.entities.Resource;
@ -88,7 +88,7 @@ public class EffortDistributor {
}
}
private static final IWorkHours generateWorkHoursFor(Resource resource) {
private static final ICalendar generateCalendarFor(Resource resource) {
if (resource.getCalendar() != null) {
return resource.getCalendar();
} else {
@ -128,12 +128,12 @@ public class EffortDistributor {
public final int capacityUnits;
public final IWorkHours workHours;
public final ICalendar calendar;
public ResourceWithDerivedData(Resource resource) {
this.resource = resource;
this.capacityUnits = getCapacityFor(resource);
this.workHours = generateWorkHoursFor(resource);
this.calendar = generateCalendarFor(resource);
}
}
@ -233,11 +233,11 @@ public class EffortDistributor {
for (int i = 0; i < resources.size(); i++) {
List<Share> shares = new ArrayList<Share>();
Resource resource = resources.get(i).resource;
IWorkHours workHoursForResource = resources.get(i).workHours;
ICalendar calendarForResource = resources.get(i).calendar;
EffortDuration alreadyAssigned = assignedHoursForResource
.getAssignedDurationAt(resource, day);
final int alreadyAssignedSeconds = alreadyAssigned.getSeconds();
Integer capacityEachOneSeconds = workHoursForResource.asDurationOn(
Integer capacityEachOneSeconds = calendarForResource.asDurationOn(
day, ONE).getSeconds();
final int capacityUnits = resources.get(i).capacityUnits;
assert capacityUnits >= 1;

6
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java
View file

@ -35,7 +35,7 @@ import java.util.Set;
import org.hibernate.validator.Valid;
import org.joda.time.LocalDate;
import org.navalplanner.business.calendars.entities.AvailabilityTimeLine;
import org.navalplanner.business.calendars.entities.IWorkHours;
import org.navalplanner.business.calendars.entities.ICalendar;
import org.navalplanner.business.planner.entities.EffortDistributor.IResourceSelector;
import org.navalplanner.business.planner.entities.EffortDistributor.ResourceWithAssignedDuration;
import org.navalplanner.business.planner.entities.allocationalgorithms.HoursModification;
@ -261,8 +261,8 @@ public class GenericResourceAllocation extends
}
@Override
protected IWorkHours getWorkHoursGivenTaskHours(IWorkHours taskWorkHours) {
return taskWorkHours;
protected ICalendar getCalendarGivenTaskCalendar(ICalendar taskCalendar) {
return taskCalendar;
}
public IAllocatable forResources(Collection<? extends Resource> resources) {

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

@ -45,7 +45,7 @@ import org.joda.time.LocalDate;
import org.navalplanner.business.calendars.entities.AvailabilityTimeLine;
import org.navalplanner.business.calendars.entities.BaseCalendar;
import org.navalplanner.business.calendars.entities.CombinedWorkHours;
import org.navalplanner.business.calendars.entities.IWorkHours;
import org.navalplanner.business.calendars.entities.ICalendar;
import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
import org.navalplanner.business.common.BaseEntity;
import org.navalplanner.business.common.Registry;
@ -228,22 +228,21 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
LocalDate start,
ResourcesPerDayModification resourcesPerDayModification,
EffortDuration effortToAllocate) {
IWorkHours workHoursPerDay = getWorkHoursPerDay(resourcesPerDayModification);
ICalendar calendar = getCalendar(resourcesPerDayModification);
ResourcesPerDay resourcesPerDay = resourcesPerDayModification
.getGoal();
AvailabilityTimeLine availability = resourcesPerDayModification
.getAvailability();
availability.invalidUntil(start);
return workHoursPerDay.thereAreCapacityFor(availability,
return calendar.thereAreCapacityFor(availability,
resourcesPerDay, effortToAllocate);
}
private CombinedWorkHours getWorkHoursPerDay(
private CombinedWorkHours getCalendar(
ResourcesPerDayModification resourcesPerDayModification) {
return CombinedWorkHours.minOf(resourcesPerDayModification
.getBeingModified().getTaskWorkHours(),
resourcesPerDayModification
.getResourcesWorkHoursPerDay());
.getBeingModified().getTaskCalendar(),
resourcesPerDayModification.getResourcesCalendar());
}
@Override
@ -634,7 +633,7 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
private Share getShareAt(LocalDate day,
AvailabilityTimeLine availability) {
if (availability.isValid(day)) {
EffortDuration capacityAtDay = getWorkHoursPerDay()
EffortDuration capacityAtDay = getAllocationCalendar()
.getCapacityDurationAt(day);
return new Share(-capacityAtDay.getSeconds());
} else {
@ -725,7 +724,7 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
final EffortDuration calculateTotalToDistribute(LocalDate day,
ResourcesPerDay resourcesPerDay) {
return getWorkHoursPerDay().asDurationOn(day, resourcesPerDay);
return getAllocationCalendar().asDurationOn(day, resourcesPerDay);
}
public ResourcesPerDay calculateResourcesPerDayFromAssignments() {
@ -739,7 +738,7 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
EffortDuration sumWorkableEffort = zero();
final ResourcesPerDay ONE_RESOURCE_PER_DAY = ResourcesPerDay.amount(1);
for (Entry<LocalDate, List<T>> entry : byDay.entrySet()) {
sumWorkableEffort = sumWorkableEffort.plus(getWorkHoursPerDay()
sumWorkableEffort = sumWorkableEffort.plus(getAllocationCalendar()
.asDurationOn(entry.getKey(), ONE_RESOURCE_PER_DAY));
sumTotalEffort = sumTotalEffort.plus(getAssignedDuration(entry
.getValue()));
@ -750,11 +749,11 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
return ResourcesPerDay.calculateFrom(sumTotalEffort, sumWorkableEffort);
}
private IWorkHours getWorkHoursPerDay() {
return getWorkHoursGivenTaskHours(getTaskWorkHours());
private ICalendar getAllocationCalendar() {
return getCalendarGivenTaskCalendar(getTaskCalendar());
}
private IWorkHours getTaskWorkHours() {
private ICalendar getTaskCalendar() {
if (getTask().getCalendar() == null) {
return SameWorkHoursEveryDay.getDefaultWorkingDay();
} else {
@ -762,8 +761,8 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
}
}
protected abstract IWorkHours getWorkHoursGivenTaskHours(
IWorkHours taskWorkHours);
protected abstract ICalendar getCalendarGivenTaskCalendar(
ICalendar taskCalendar);
private void resetGenericAssignmentsTo(List<DayAssignment> assignments) {
resetAssignmentsTo(cast(assignments));

6
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
View file

@ -38,7 +38,7 @@ import org.hibernate.validator.Valid;
import org.joda.time.LocalDate;
import org.navalplanner.business.calendars.entities.AvailabilityTimeLine;
import org.navalplanner.business.calendars.entities.CombinedWorkHours;
import org.navalplanner.business.calendars.entities.IWorkHours;
import org.navalplanner.business.calendars.entities.ICalendar;
import org.navalplanner.business.common.ProportionalDistributor;
import org.navalplanner.business.planner.entities.allocationalgorithms.HoursModification;
import org.navalplanner.business.planner.entities.allocationalgorithms.ResourcesPerDayModification;
@ -198,8 +198,8 @@ public class SpecificResourceAllocation extends
}
@Override
protected IWorkHours getWorkHoursGivenTaskHours(IWorkHours taskWorkHours) {
return CombinedWorkHours.minOf(taskWorkHours, getResource()
protected ICalendar getCalendarGivenTaskCalendar(ICalendar taskCalendar) {
return CombinedWorkHours.minOf(taskCalendar, getResource()
.getCalendar());
}

22
navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/allocationalgorithms/ResourcesPerDayModification.java
View file

@ -29,7 +29,7 @@ import org.apache.commons.lang.Validate;
import org.joda.time.LocalDate;
import org.navalplanner.business.calendars.entities.AvailabilityTimeLine;
import org.navalplanner.business.calendars.entities.CombinedWorkHours;
import org.navalplanner.business.calendars.entities.IWorkHours;
import org.navalplanner.business.calendars.entities.ICalendar;
import org.navalplanner.business.calendars.entities.ResourceCalendar;
import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
import org.navalplanner.business.planner.entities.AvailabilityCalculator;
@ -85,16 +85,16 @@ public abstract class ResourcesPerDayModification extends
}
@Override
public IWorkHours getResourcesWorkHoursPerDay() {
return CombinedWorkHours.maxOf(resourcesWorkHours());
public ICalendar getResourcesCalendar() {
return CombinedWorkHours.maxOf(resourcesCalendar());
}
private List<IWorkHours> resourcesWorkHours() {
List<IWorkHours> workHours = new ArrayList<IWorkHours>();
private List<ICalendar> resourcesCalendar() {
List<ICalendar> calendar = new ArrayList<ICalendar>();
for (Resource each : getResources()) {
workHours.add(workHoursFor(each));
calendar.add(calendarFor(each));
}
return workHours;
return calendar;
}
}
@ -140,8 +140,8 @@ public abstract class ResourcesPerDayModification extends
}
@Override
public IWorkHours getResourcesWorkHoursPerDay() {
return workHoursFor(getAssociatedResource());
public ICalendar getResourcesCalendar() {
return calendarFor(getAssociatedResource());
}
}
@ -183,7 +183,7 @@ public abstract class ResourcesPerDayModification extends
return result;
}
protected static IWorkHours workHoursFor(Resource associatedResource) {
protected static ICalendar calendarFor(Resource associatedResource) {
ResourceCalendar calendar = associatedResource.getCalendar();
return calendar != null ? calendar : SameWorkHoursEveryDay
.getDefaultWorkingDay();
@ -203,7 +203,7 @@ public abstract class ResourcesPerDayModification extends
return goal;
}
public abstract IWorkHours getResourcesWorkHoursPerDay();
public abstract ICalendar getResourcesCalendar();
public abstract void applyAllocationOnAllTaskLength();

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

@ -45,7 +45,7 @@ import org.hibernate.validator.Valid;
import org.joda.time.Days;
import org.joda.time.LocalDate;
import org.navalplanner.business.calendars.entities.BaseCalendar;
import org.navalplanner.business.calendars.entities.IWorkHours;
import org.navalplanner.business.calendars.entities.ICalendar;
import org.navalplanner.business.calendars.entities.ResourceCalendar;
import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
import org.navalplanner.business.common.IntegrationEntity;
@ -875,12 +875,12 @@ public abstract class Resource extends IntegrationEntity {
criterion);
}
public IWorkHours getCalendarOrDefault() {
public ICalendar getCalendarOrDefault() {
return getCalendar() != null ? getCalendar() : SameWorkHoursEveryDay
.getDefaultWorkingDay();
}
private int getTotalWorkHoursFor(IWorkHours calendar, LocalDate start,
private int getTotalWorkHoursFor(ICalendar calendar, LocalDate start,
LocalDate end, ICriterion criterionToSatisfy) {
EffortDuration sum = zero();
final int days = Days.daysBetween(start, end).getDays();

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

@ -31,40 +31,40 @@ import static org.junit.Assert.assertThat;
import org.joda.time.LocalDate;
import org.junit.Test;
import org.navalplanner.business.calendars.entities.CombinedWorkHours;
import org.navalplanner.business.calendars.entities.IWorkHours;
import org.navalplanner.business.calendars.entities.ICalendar;
import org.navalplanner.business.workingday.EffortDuration;
public class CombinedWorkHoursTest {
@Test(expected = IllegalArgumentException.class)
public void cannotAcceptOnlyNullElements() {
IWorkHours[] nullWorkHours = null;
ICalendar[] nullWorkHours = null;
CombinedWorkHours.minOf(nullWorkHours);
}
public void someElementsCanBeNull() {
CombinedWorkHours minOf = CombinedWorkHours.minOf(null,
createNiceMock(IWorkHours.class));
createNiceMock(ICalendar.class));
assertNotNull(minOf);
}
@Test(expected = IllegalArgumentException.class)
public void mustHaveatLeastOne() {
IWorkHours[] emptyArray = {};
ICalendar[] emptyArray = {};
CombinedWorkHours.minOf(emptyArray);
}
@Test
public void returnsTheMinOfCalendars() {
IWorkHours minOf = CombinedWorkHours
ICalendar minOf = CombinedWorkHours
.minOf(hours(4), hours(2), hours(7));
EffortDuration duration = minOf.getCapacityDurationAt(new LocalDate(
2000, 3, 3));
assertThat(duration, equalTo(EffortDuration.hours(2)));
}
private IWorkHours hours(int hours) {
IWorkHours result = createNiceMock(IWorkHours.class);
private ICalendar hours(int hours) {
ICalendar result = createNiceMock(ICalendar.class);
expect(result.getCapacityDurationAt(isA(LocalDate.class))).andReturn(
EffortDuration.hours(hours));
replay(result);

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

@ -41,7 +41,7 @@ import java.util.TreeMap;
import org.joda.time.LocalDate;
import org.navalplanner.business.calendars.entities.BaseCalendar;
import org.navalplanner.business.calendars.entities.IWorkHours;
import org.navalplanner.business.calendars.entities.ICalendar;
import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
import org.navalplanner.business.common.IAdHocTransactionService;
import org.navalplanner.business.common.IOnTransaction;
@ -894,7 +894,7 @@ public abstract class CompanyPlanningModel implements ICompanyPlanningModel {
private EffortDuration getOverloadAt(LocalDate day,
Resource resource, EffortDuration assignedDuration) {
IWorkHours calendar = resource.getCalendarOrDefault();
ICalendar calendar = resource.getCalendarOrDefault();
EffortDuration workableDuration = calendar
.getCapacityDurationAt(day);
if (assignedDuration.compareTo(workableDuration) > 0) {