From ccceab9c6f207ff13145eea844c78de958b608a1 Mon Sep 17 00:00:00 2001 From: Manuel Rego Casasnovas Date: Mon, 29 Jun 2009 11:52:48 +0200 Subject: [PATCH] ItEr14S11CUConfiguracionDeOrganizacionsDeTraballoConUnidadesTraballoItEr13S13: Implemented method setWorkHours of OrderLine class. Added test cases for this method. Removed fixedHours attribute of class OrderLine (not needed anymore). Pending changes in the interface. --- .../business/orders/entities/HoursGroup.java | 7 +- .../business/orders/entities/OrderLine.java | 285 +++- .../business/orders/entities/Orders.hbm.xml | 2 - .../test/orders/entities/OrderLineTest.java | 1317 +++++++++++++++++ .../web/orders/OrderElementController.java | 56 +- .../main/webapp/orders/_editOrderElement.zul | 1 - 6 files changed, 1568 insertions(+), 100 deletions(-) create mode 100644 navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderLineTest.java diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java index 654998c7c..d4fe2b073 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java @@ -2,7 +2,9 @@ package org.navalplanner.business.orders.entities; import java.math.BigDecimal; -public class HoursGroup { +import org.hibernate.validator.NotNull; + +public class HoursGroup implements Cloneable { private Long id; @@ -10,7 +12,8 @@ public class HoursGroup { return id; } - private Integer workingHours; + @NotNull + private Integer workingHours = 0; private BigDecimal percentage; diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java index c5fd170e1..4d4973e70 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java @@ -1,31 +1,25 @@ package org.navalplanner.business.orders.entities; +import java.math.BigDecimal; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; -public class OrderLine extends OrderElement { +import org.navalplanner.business.orders.entities.HoursGroup.HoursPolicies; - private Boolean fixedHours = false; +public class OrderLine extends OrderElement { private Set hoursGroups = new HashSet(); @Override public Integer getWorkHours() { - int result = 0; - List hoursGroups = getHoursGroups(); - for (HoursGroup hoursGroup : hoursGroups) { - Integer workingHours = hoursGroup.getWorkingHours(); - if (workingHours != null) { - result += workingHours; - } - } - return result; + return calculateTotalHours(hoursGroups); } @Override public List getChildren() { + // FIXME Shouldn't return null? return new ArrayList(); } @@ -45,35 +39,6 @@ public class OrderLine extends OrderElement { return result; } - public void setWorkHours(Integer workingHours) { - List hoursGroups = getHoursGroups(); - - // FIXME For the moment we have just one HoursGroup for each OrderLine - if (hoursGroups.isEmpty()) { - HoursGroup hourGroup = new HoursGroup(); - hourGroup.setWorkingHours(workingHours); - - hoursGroups.add(hourGroup); - } else { - HoursGroup hourGroup = hoursGroups.get(0); - hourGroup.setWorkingHours(workingHours); - } - - setHoursGroups(hoursGroups); - } - - public void setHoursGroups(List hoursGroups) { - this.hoursGroups = new HashSet(hoursGroups); - } - - public void addHoursGroup(HoursGroup hoursGroup) { - hoursGroups.add(hoursGroup); - } - - public void deleteHoursGroup(HoursGroup hoursGroup) { - hoursGroups.remove(hoursGroup); - } - @Override public List getHoursGroups() { return new ArrayList(hoursGroups); @@ -86,12 +51,244 @@ public class OrderLine extends OrderElement { } } - public void setFixedHours(Boolean fixedHours) { - this.fixedHours = fixedHours; + + public void addHoursGroup(HoursGroup hoursGroup) { + hoursGroups.add(hoursGroup); + recalculatePercentages(hoursGroups); } - public Boolean isFixedHours() { - return fixedHours; + public void deleteHoursGroup(HoursGroup hoursGroup) { + hoursGroups.remove(hoursGroup); + recalculatePercentages(hoursGroups); + } + + /** + * Set the total working hours of the {@link OrderLine} taking into account + * the {@link HoursGroup} policies. + * + * @param workHours + * The desired value to set as total working hours + * @throws IllegalArgumentException + * If parameter is less than 0 or if it's not possible to set + * this value taking into account {@link HoursGroup} policies. + */ + public void setWorkHours(Integer workHours) throws IllegalArgumentException { + + if (workHours < 0) { + throw new IllegalArgumentException( + "workHours should be greater or equals to 0"); + } + + if (hoursGroups.isEmpty()) { + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setWorkingHours(workHours); + hoursGroup.setPercentage((new BigDecimal(1).setScale(2))); + + hoursGroups.add(hoursGroup); + } else { + + if (!isTotalHoursValid(workHours)) { + // FIXME change exception type + throw new IllegalArgumentException( + "\"workHours\" value is not valid, taking into " + + "account the current list of HoursGroup"); + } + + updateHoursGroups(workHours); + } + } + + /** + * Makes the needed modifications in hoursGroups attribute in order to set + * the desired value of working hours. + * + * This method takes into account the different {@link HoursGroup} policies: + * + * {@link HoursGroup} with FIXED_HOURS policy don't change. + * + * If policy is FIXED_PERCENTAGE the new value is calculated for each + * {@link HoursGroup} with this policy. Using round down in order to avoid + * problems. + * + * Hours are proportionally distributed when there're {@link HoursGroup} + * with NO_FIXED policy. + * + * Finally, it creates new {@link HoursGroup} if the're some remaining hours + * (it could happen because of the round down used for operations). + * + * @param workHours + * The value to set as total working hours + */ + private void updateHoursGroups(Integer workHours) { + + Set newHoursGroups = new HashSet(); + + // Divide HourGroup depending on policy + Set fixedHoursGroups = new HashSet(); + Set fixedPercentageGroups = new HashSet(); + Set noFixedGroups = new HashSet(); + + for (HoursGroup hoursGroup : hoursGroups) { + switch (hoursGroup.getHoursPolicy()) { + case FIXED_HOURS: + fixedHoursGroups.add(hoursGroup); + break; + case FIXED_PERCENTAGE: + fixedPercentageGroups.add(hoursGroup); + break; + case NO_FIXED: + default: + noFixedGroups.add(hoursGroup); + break; + } + } + + // All the HourGroup with FIXED_HOURS will be kept without changes + newHoursGroups.addAll(fixedHoursGroups); + + // For every HourGroup with FIXED_PERCENTAGE, workingHours will be + // calculated + for (HoursGroup hoursGroup : fixedPercentageGroups) { + Integer hours = hoursGroup.getPercentage().multiply( + new BigDecimal(workHours).setScale(2)).toBigInteger() + .intValue(); + hoursGroup.setWorkingHours(hours); + newHoursGroups.add(hoursGroup); + } + + Integer newTotal = calculateTotalHours(newHoursGroups); + + if (newTotal.compareTo(workHours) > 0) { + throw new RuntimeException("Unreachable code"); + } else if (newTotal.compareTo(workHours) == 0) { + for (HoursGroup hoursGroup : noFixedGroups) { + hoursGroup.setWorkingHours(0); + newHoursGroups.add(hoursGroup); + } + } else if (newTotal.compareTo(workHours) < 0) { + // Proportional sharing + Integer oldNoFixed = calculateTotalHoursNoFixed(hoursGroups); + Integer newNoFixed = workHours - newTotal; + + for (HoursGroup hoursGroup : noFixedGroups) { + Integer newHours = (int) ((float) hoursGroup.getWorkingHours() + / oldNoFixed * newNoFixed); + hoursGroup.setWorkingHours(newHours); + + newHoursGroups.add(hoursGroup); + } + } + + // If there're remaining hours + newTotal = calculateTotalHours(newHoursGroups); + if (newTotal.compareTo(workHours) < 0) { + // Add a new HourGroup with the remaining hours + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setWorkingHours(workHours - newTotal); + newHoursGroups.add(hoursGroup); + } + + // Re-calculate percentages + recalculatePercentages(newHoursGroups); + + // Set the attribute with the new hours group calculated + hoursGroups = newHoursGroups; + } + + /** + * Check if the desired total number of hours is valid taking into account + * {@link HoursGroup} policy restrictions. + * + * @param total + * The desired value + * @return true if the value is valid + */ + private boolean isTotalHoursValid(Integer total) { + + Integer newTotal = 0; + + for (HoursGroup hoursGroup : hoursGroups) { + switch (hoursGroup.getHoursPolicy()) { + case FIXED_HOURS: + newTotal += hoursGroup.getWorkingHours(); + break; + case FIXED_PERCENTAGE: + newTotal += hoursGroup.getPercentage().multiply( + new BigDecimal(total).setScale(2)).toBigInteger() + .intValue(); + break; + case NO_FIXED: + default: + break; + } + } + + if (newTotal.compareTo(total) > 0) { + return false; + } + + return true; + } + + /** + * Calculates the total number of working hours in a set of + * {@link HoursGroup}. + * + * @param hoursGroups + * A {@link HoursGroup} set + * @return The sum of working hours + */ + private Integer calculateTotalHours(Set hoursGroups) { + Integer result = 0; + for (HoursGroup hoursGroup : hoursGroups) { + result += hoursGroup.getWorkingHours(); + } + return result; + } + + /** + * Calculates the total number of working hours in a set of + * {@link HoursGroup} taking into account just {@link HoursGroup} with + * NO_FIXED as policy. + * + * @param hoursGroups + * A {@link HoursGroup} set + * @return The sum of NO_FIXED {@link HoursGroup} + */ + private Integer calculateTotalHoursNoFixed(Set hoursGroups) { + Integer result = 0; + for (HoursGroup hoursGroup : hoursGroups) { + if (hoursGroup.getHoursPolicy() == HoursPolicies.NO_FIXED) { + result += hoursGroup.getWorkingHours(); + } + } + return result; + } + + /** + * Re-calculates the percentages in a {@link HoursGroup} set, without modify + * the {@link HoursGroup} with policy FIXED_PERCENTAGE. + * + * @param hoursGroups + * A {@link HoursGroup} set + */ + private void recalculatePercentages(Set hoursGroups) { + Integer total = calculateTotalHours(hoursGroups); + BigDecimal totalBigDecimal = new BigDecimal(total).setScale(2); + + for (HoursGroup hoursGroup : hoursGroups) { + if (hoursGroup.getHoursPolicy() != HoursPolicies.FIXED_PERCENTAGE) { + if (totalBigDecimal.equals(new BigDecimal(0).setScale(2))) { + hoursGroup.setPercentage(new BigDecimal(0).setScale(2)); + } else { + BigDecimal hoursBigDecimal = new BigDecimal(hoursGroup + .getWorkingHours()).setScale(2); + BigDecimal percentage = hoursBigDecimal.divide( + totalBigDecimal, BigDecimal.ROUND_DOWN); + hoursGroup.setPercentage(percentage); + } + } + } } } diff --git a/navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml b/navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml index 8b0c60d7b..4787ad4a0 100644 --- a/navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml +++ b/navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml @@ -43,8 +43,6 @@ - - diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderLineTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderLineTest.java new file mode 100644 index 000000000..0f1792d68 --- /dev/null +++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderLineTest.java @@ -0,0 +1,1317 @@ +package org.navalplanner.business.test.orders.entities; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.fail; + +import java.math.BigDecimal; + +import org.junit.Test; +import org.navalplanner.business.orders.entities.HoursGroup; +import org.navalplanner.business.orders.entities.OrderLine; +import org.navalplanner.business.orders.entities.HoursGroup.HoursPolicies; + +/** + * Tests for {@link OrderLine}.
+ * + * @author Manuel Rego Casasnovas + */ +public class OrderLineTest { + + /** + * An empty {@link OrderLine} without any {@link HoursGroup}. + * + * Trying to set work hours of {@link OrderLine} to 100h. + * + * Expected: {@link OrderLine} with 100h, with one {@link HoursGroup} with + * 100h NO_FIXED. + */ + @Test + public void testSetWorkHoursHoursEmptyOrderLine() { + + OrderLine orderLine = new OrderLine(); + + assertThat(orderLine.getWorkHours(), equalTo(0)); + + try { + orderLine.setWorkHours(100); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(100)); + assertThat(orderLine.getHoursGroups().size(), equalTo(1)); + HoursGroup hoursGroup = orderLine.getHoursGroups().get(0); + assertThat(hoursGroup.getWorkingHours(), equalTo(100)); + assertThat(hoursGroup.getPercentage(), equalTo(new BigDecimal(1) + .setScale(2))); + assertThat(hoursGroup.getHoursPolicy(), equalTo(HoursPolicies.NO_FIXED)); + } + + /** + * An empty {@link OrderLine} without any {@link HoursGroup}. + * + * Trying to set work hours of {@link OrderLine} to -100h. + * + * Expected: Exception. + */ + @Test + public void testSetWorkHoursHoursEmptyOrderLineIllegal() { + + OrderLine orderLine = new OrderLine(); + + assertThat(orderLine.getWorkHours(), equalTo(0)); + + try { + orderLine.setWorkHours(-100); + fail("It should throw an exception"); + } catch (IllegalArgumentException e) { + + } + + assertThat(orderLine.getWorkHours(), equalTo(0)); + assertThat(orderLine.getHoursGroups().size(), equalTo(0)); + + } + + /** + * An {@link OrderLine} with just one {@link HoursGroup} of 100h NO_FIXED. + * + * Trying to set work hours of {@link OrderLine} to 120h. + * + * Expected: {@link OrderLine} with 120h. {@link HoursGroup} with 120h. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(100); + orderLine.addHoursGroup(hoursGroup); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(120); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(120)); + assertThat(orderLine.getHoursGroups().size(), equalTo(1)); + assertThat(hoursGroup.getWorkingHours(), equalTo(120)); + } + + /** + * An {@link OrderLine} with just one {@link HoursGroup} of 100h NO_FIXED. + * + * Trying to set work hours of {@link OrderLine} to 75h. + * + * Expected: {@link OrderLine} with 75h. {@link HoursGroup} with 75h. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(100); + orderLine.addHoursGroup(hoursGroup); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(75); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(75)); + assertThat(orderLine.getHoursGroups().size(), equalTo(1)); + assertThat(hoursGroup.getWorkingHours(), equalTo(75)); + + } + + /** + * An {@link OrderLine} with just one {@link HoursGroup} of 100h + * FIXED_HOURS. + * + * Trying to set work hours of {@link OrderLine} to 120h. + * + * Expected: {@link OrderLine} with 120h. {@link HoursGroup} with 100h. + */ + @Test + public void testSetWorkHoursHoursGroupFixedHoursIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup.setWorkingHours(100); + orderLine.addHoursGroup(hoursGroup); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(120); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(120)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(100)); + + } + + /** + * An {@link OrderLine} with just one {@link HoursGroup} of 100h + * FIXED_HOURS. + * + * Trying to set work hours of {@link OrderLine} to 75h. + * + * Expected: Exception expected. {@link OrderLine} with 100h. + * {@link HoursGroup} with 100h. + */ + @Test + public void testSetWorkHoursHoursGroupFixedHoursDecreaseValueIllegal() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup.setWorkingHours(100); + orderLine.addHoursGroup(hoursGroup); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(75); + fail("It should throw an exception"); + } catch (IllegalArgumentException e) { + // OK + } + + assertThat(orderLine.getWorkHours(), equalTo(100)); + assertThat(orderLine.getHoursGroups().size(), equalTo(1)); + assertThat(hoursGroup.getWorkingHours(), equalTo(100)); + + } + + /** + * An {@link OrderLine} with just one {@link HoursGroup} of 100h 100% + * FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 120h. + * + * Expected: {@link OrderLine} with 120h. {@link HoursGroup} with 120h 100%. + */ + @Test + public void testSetWorkHoursHoursGroupFixedPercentageIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup.setWorkingHours(100); + hoursGroup.setPercentage(new BigDecimal(1).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(120); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(120)); + assertThat(orderLine.getHoursGroups().size(), equalTo(1)); + assertThat(hoursGroup.getWorkingHours(), equalTo(120)); + assertThat(hoursGroup.getPercentage(), equalTo(new BigDecimal(1) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with just one {@link HoursGroup} of 100h 100% + * FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 75h. + * + * Expected: {@link OrderLine} with 100h. {@link HoursGroup} with 75h 100%. + */ + @Test + public void testSetWorkHoursHoursGroupFixedPercentageDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup.setWorkingHours(100); + hoursGroup.setPercentage(new BigDecimal(1).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(75); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(75)); + assertThat(orderLine.getHoursGroups().size(), equalTo(1)); + assertThat(hoursGroup.getWorkingHours(), equalTo(75)); + assertThat(hoursGroup.getPercentage(), equalTo(new BigDecimal(1) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 100h and 50h + * NO_FIXED. + * + * Trying to set work hours of {@link OrderLine} to 200h. + * + * Expected: {@link OrderLine} with 200h. {@link HoursGroup} with 133h and + * HoursGroup with 66h. + */ + @Test + public void testSetWorkHoursTwoHoursGroupNoFixedIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(100); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(50); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(150)); + + try { + orderLine.setWorkHours(200); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(200)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(133)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(66)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 100h and 50h + * NO_FIXED. + * + * Trying to set work hours of {@link OrderLine} to 50h. + * + * Expected: {@link OrderLine} with 50h. {@link HoursGroup} with 33h and + * {@link HoursGroup} with 16h. + */ + @Test + public void testSetWorkHoursTwoHoursGroupNoFixedDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(100); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(50); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(150)); + + try { + orderLine.setWorkHours(50); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(50)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(33)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(16)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 100h FIXED_HOURS and + * 50h NO_FIXED. + * + * Trying to set work hours of {@link OrderLine} to 200h. + * + * Expected: {@link OrderLine} with 200h. {@link HoursGroup} with 100h and + * HoursGroup with 100h. + */ + @Test + public void testSetWorkHoursHoursGroupFixedHoursAndHoursGroupNoFixedIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup.setWorkingHours(100); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(50); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(150)); + + try { + orderLine.setWorkHours(200); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(200)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(100)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(100)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 100h FIXED_HOURS and + * 50h NO_FIXED. + * + * Trying to set work hours of {@link OrderLine} to 125h. + * + * Expected: {@link OrderLine} with 125h. {@link HoursGroup} with 100h and + * HoursGroup with 25h. + */ + @Test + public void testSetWorkHoursHoursGroupFixedHoursAndHoursGroupNoFixedDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup.setWorkingHours(100); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(50); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(150)); + + try { + orderLine.setWorkHours(125); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(125)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(100)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(25)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 100h FIXED_HOURS and + * 50h NO_FIXED. + * + * Trying to set work hours of {@link OrderLine} to 50h. + * + * Expected: Exception. {@link OrderLine} with 150h. {@link HoursGroup} with + * 100h and {@link HoursGroup} with 50h. + */ + @Test + public void testSetWorkHoursHoursGroupFixedHoursAndHoursGroupNoFixedDecreaseValueIllegal() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup.setWorkingHours(100); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(50); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(150)); + + try { + orderLine.setWorkHours(50); + fail("It should throw an exception"); + } catch (IllegalArgumentException e) { + // OK + } + + assertThat(orderLine.getWorkHours(), equalTo(150)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(100)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(50)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 75h 75% + * FIXED_PERCENTAGE and 25h NO_FIXED. + * + * Trying to set work hours of {@link OrderLine} to 200h. + * + * Expected: {@link OrderLine} with 200h. {@link HoursGroup} with 150h 75% + * and {@link HoursGroup} with 50h. + */ + @Test + public void testSetWorkHoursHoursGroupFixedPercentageAndHoursGroupNoFixedIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup.setWorkingHours(75); + hoursGroup.setPercentage(new BigDecimal(0.75).setScale(2)); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(25); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(200); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(200)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(150)); + assertThat(hoursGroup.getPercentage(), equalTo(new BigDecimal(0.75) + .setScale(2))); + assertThat(hoursGroup2.getWorkingHours(), equalTo(50)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 75h 75% + * FIXED_PERCENTAGE and 25h NO_FIXED. + * + * Trying to set work hours of {@link OrderLine} to 50h. + * + * Expected: {@link OrderLine} with 50h. {@link HoursGroup} with 37h 75% and + * HoursGroup with 13h. + */ + @Test + public void testSetWorkHoursHoursGroupFixedPercentageAndHoursGroupNoFixedDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup.setWorkingHours(75); + hoursGroup.setPercentage(new BigDecimal(0.75).setScale(2)); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(25); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(50); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(50)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(37)); + assertThat(hoursGroup.getPercentage(), equalTo(new BigDecimal(0.75) + .setScale(2))); + assertThat(hoursGroup2.getWorkingHours(), equalTo(13)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 75h FIXED_HOURS and + * 25h 25% FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 150h. + * + * Expected: {@link OrderLine} with 150h. {@link HoursGroup} with 75h and + * HoursGroup with 37h 25%. + */ + @Test + public void testSetWorkHoursHoursGroupFixedHoursAndHoursGroupFixedPercentageIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup.setWorkingHours(75); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup2.setWorkingHours(25); + hoursGroup2.setPercentage(new BigDecimal(0.25).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(150); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(150)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(75)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(37)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 75h FIXED_HOURS and + * 25h 25% FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 75h. + * + * Expected: Exception. {@link OrderLine} with 75h. {@link HoursGroup} with + * 75h and {@link HoursGroup} with 25h 25%. + */ + @Test + public void testSetWorkHoursHoursGroupFixedHoursAndHoursGroupFixedPercentageDecreaseValueIllegal() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup.setWorkingHours(75); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup2.setWorkingHours(25); + hoursGroup2.setPercentage(new BigDecimal(0.25).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(75); + fail("It should throw an exception"); + } catch (IllegalArgumentException e) { + // OK + } + + assertThat(orderLine.getWorkHours(), equalTo(100)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(75)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(25)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 75h and 25h + * FIXED_HOURS. + * + * Trying to set work hours of {@link OrderLine} to 150h. + * + * Expected: {@link OrderLine} with 150h. {@link HoursGroup} with 75h and + * {@link HoursGroup} with 25h. + */ + @Test + public void testSetWorkHoursHoursGroupFixedHoursAndHoursGroupFixedHoursIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup.setWorkingHours(75); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup2.setWorkingHours(25); + hoursGroup2.setPercentage(new BigDecimal(0.25).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(150); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(150)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(75)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(25)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 75h and 25h + * FIXED_HOURS. + * + * Trying to set work hours of {@link OrderLine} to 50h. + * + * Expected: Exception. {@link OrderLine} with 100h. {@link HoursGroup} with + * 75h and {@link HoursGroup} with 25h. + */ + @Test + public void testSetWorkHoursHoursGroupFixedHoursAndHoursGroupFixedHoursDecreaseValueIllegal() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup.setWorkingHours(75); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup2.setWorkingHours(25); + hoursGroup2.setPercentage(new BigDecimal(0.25).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(50); + fail("It should throw an exception"); + } catch (IllegalArgumentException e) { + // OK + } + + assertThat(orderLine.getWorkHours(), equalTo(100)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(75)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(25)); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 75h 75% and 25h 25% + * FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 200h. + * + * Expected: {@link OrderLine} with 200h. {@link HoursGroup} with 150h 75% + * and {@link HoursGroup} with 50h 25%. + */ + @Test + public void testSetWorkHoursHoursGroupFixedPercentageAndHoursGroupFixedPercentageIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup.setPercentage(new BigDecimal(0.75).setScale(2)); + hoursGroup.setWorkingHours(75); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup2.setWorkingHours(25); + hoursGroup2.setPercentage(new BigDecimal(0.25).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(200); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(200)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(150)); + assertThat(hoursGroup.getPercentage(), equalTo(new BigDecimal(0.75) + .setScale(2))); + assertThat(hoursGroup2.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup2.getPercentage(), equalTo(new BigDecimal(0.25) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with two {@link HoursGroup} of 75h 75% and 25h 25% + * FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 80h. + * + * Expected: {@link OrderLine} with 80h. {@link HoursGroup} with 60h 75% and + * {@link HoursGroup} with 20h 25%. + */ + @Test + public void testSetWorkHoursHoursGroupFixedPercentageAndHoursGroupFixedPercentageDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup.setPercentage(new BigDecimal(0.75).setScale(2)); + hoursGroup.setWorkingHours(75); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup2.setWorkingHours(25); + hoursGroup2.setPercentage(new BigDecimal(0.25).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + + assertThat(orderLine.getWorkHours(), equalTo(100)); + + try { + orderLine.setWorkHours(80); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(80)); + assertThat(orderLine.getHoursGroups().size(), equalTo(2)); + assertThat(hoursGroup.getWorkingHours(), equalTo(60)); + assertThat(hoursGroup.getPercentage(), equalTo(new BigDecimal(0.75) + .setScale(2))); + assertThat(hoursGroup2.getWorkingHours(), equalTo(20)); + assertThat(hoursGroup2.getPercentage(), equalTo(new BigDecimal(0.25) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 40h, 60h NO_FIXED + * and 100h FIXED_HOURS. + * + * Trying to set work hours of {@link OrderLine} to 300h. + * + * Expected: {@link OrderLine} with 300h. {@link HoursGroup} with 80h, + * {@link HoursGroup} with 120h and {@link HoursGroup} with 100h. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupNoFixedAndHoursGroupFixedHoursIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(40); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(60); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup3.setWorkingHours(100); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(300); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(300)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(80)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(120)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(100)); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h, 50h NO_FIXED + * and 50h FIXED_HOURS. + * + * Trying to set work hours of {@link OrderLine} to 70h. + * + * Expected: {@link OrderLine} with 70h. {@link HoursGroup} with 10h, + * {@link HoursGroup} with 10h and {@link HoursGroup} with 50h. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupNoFixedAndHoursGroupFixedHoursDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(50); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup3.setWorkingHours(50); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(150)); + + try { + orderLine.setWorkHours(70); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(70)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(10)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(10)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(50)); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h, 50h NO_FIXED + * and 50h FIXED_HOURS. + * + * Trying to set work hours of {@link OrderLine} to 25h. + * + * Expected: Exception. {@link OrderLine} with 150h. {@link HoursGroup} with + * 50h, {@link HoursGroup} with 50h and {@link HoursGroup} with 50h. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupNoFixedAndHoursGroupFixedHoursDecreaseValueIllegal() { + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(50); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup3.setWorkingHours(50); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(150)); + + try { + orderLine.setWorkHours(25); + fail("It should throw an exception"); + } catch (IllegalArgumentException e) { + // OK + } + + assertThat(orderLine.getWorkHours(), equalTo(150)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(50)); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h, 50h NO_FIXED + * and 100h 50% FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 300h. + * + * Expected: {@link OrderLine} with 300h. {@link HoursGroup} with 75h, + * {@link HoursGroup} with 75h and {@link HoursGroup} with 150h 50%. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupNoFixedAndHoursGroupFixedPercentageIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(50); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup3.setWorkingHours(100); + hoursGroup3.setPercentage(new BigDecimal(0.50).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(300); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(300)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(75)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(75)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(150)); + assertThat(hoursGroup3.getPercentage(), equalTo(new BigDecimal(0.50) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 40h, 60h NO_FIXED + * and 100h 50% FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 100h. + * + * Expected: {@link OrderLine} with 100h. {@link HoursGroup} with 20h, + * {@link HoursGroup} with 30h and {@link HoursGroup} with 50h 50%. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupNoFixedAndHoursGroupFixedPercentageDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(40); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup2.setWorkingHours(60); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup3.setWorkingHours(100); + hoursGroup3.setPercentage(new BigDecimal(0.50).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(100); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(100)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(20)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(30)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup3.getPercentage(), equalTo(new BigDecimal(0.50) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h NO_FIXED, 50h + * FIXED_HOURS and 100h 50% FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 300h. + * + * Expected: {@link OrderLine} with 300h. {@link HoursGroup} with 100h, + * {@link HoursGroup} with 50h and {@link HoursGroup} with 150h 50%. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupFixedHoursAndHoursGroupFixedPercentageIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup2.setWorkingHours(50); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup3.setWorkingHours(100); + hoursGroup3.setPercentage(new BigDecimal(0.50).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(300); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(300)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(100)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(150)); + assertThat(hoursGroup3.getPercentage(), equalTo(new BigDecimal(0.50) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h NO_FIXED, 50h + * FIXED_HOURS and 100h 50% FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 150h. + * + * Expected: {@link OrderLine} with 150h. {@link HoursGroup} with 25h, + * {@link HoursGroup} with 50h and {@link HoursGroup} with 75h 50%. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupFixedHoursAndHoursGroupFixedPercentageDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup2.setWorkingHours(50); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup3.setWorkingHours(100); + hoursGroup3.setPercentage(new BigDecimal(0.50).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(150); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(150)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(25)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(75)); + assertThat(hoursGroup3.getPercentage(), equalTo(new BigDecimal(0.50) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h NO_FIXED, 50h + * FIXED_HOURS and 100h 50% FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 50h. + * + * Expected: Exception. {@link OrderLine} with 200h. {@link HoursGroup} with + * 50h, {@link HoursGroup} with 50h and {@link HoursGroup} with 100h 50%. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupFixedHoursAndHoursGroupFixedPercentageDecreaseValueIllegal() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup2.setWorkingHours(50); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup3.setWorkingHours(100); + hoursGroup3.setPercentage(new BigDecimal(0.50).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(50); + fail("It should throw an exception"); + } catch (IllegalArgumentException e) { + // OK + } + + assertThat(orderLine.getWorkHours(), equalTo(200)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(100)); + assertThat(hoursGroup3.getPercentage(), equalTo(new BigDecimal(0.50) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h NO_FIXED, 50h + * and 100h FIXED_HOURS. + * + * Trying to set work hours of {@link OrderLine} to 400h. + * + * Expected: {@link OrderLine} with 400h. {@link HoursGroup} with 250h, + * {@link HoursGroup} with 50h and {@link HoursGroup} with 100h. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupFixedHoursAndHoursGroupFixedHoursIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup2.setWorkingHours(50); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup3.setWorkingHours(100); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(400); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(400)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(250)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(100)); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h NO_FIXED, 50h + * and 100h FIXED_HOURS. + * + * Trying to set work hours of {@link OrderLine} to 175h. + * + * Expected: {@link OrderLine} with 175h. {@link HoursGroup} with 25h, + * {@link HoursGroup} with 50h and {@link HoursGroup} with 100h. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupFixedHoursAndHoursGroupFixedHoursDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup2.setWorkingHours(50); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_HOURS); + hoursGroup3.setWorkingHours(100); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(175); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(175)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(25)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup3.getWorkingHours(), equalTo(100)); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h NO_FIXED, 50h + * 25% and 100h 50% FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 400h. + * + * Expected: {@link OrderLine} with 400h. {@link HoursGroup} with 100h, + * {@link HoursGroup} with 100h 25% and {@link HoursGroup} with 200h 50%. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupFixedPercentageAndHoursGroupFixedPercentageIncreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup2.setWorkingHours(50); + hoursGroup2.setPercentage(new BigDecimal(0.25).setScale(2)); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup3.setWorkingHours(100); + hoursGroup3.setPercentage(new BigDecimal(0.50).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(400); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(400)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(100)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(100)); + assertThat(hoursGroup2.getPercentage(), equalTo(new BigDecimal(0.25) + .setScale(2))); + assertThat(hoursGroup3.getWorkingHours(), equalTo(200)); + assertThat(hoursGroup3.getPercentage(), equalTo(new BigDecimal(0.50) + .setScale(2))); + + } + + /** + * An {@link OrderLine} with three {@link HoursGroup} of 50h NO_FIXED, 50h + * 25% and 100h 50% FIXED_PERCENTAGE. + * + * Trying to set work hours of {@link OrderLine} to 100h. + * + * Expected: {@link OrderLine} with 400h. {@link HoursGroup} with 25h, + * {@link HoursGroup} with 25h 25% and {@link HoursGroup} with 50h 50%. + */ + @Test + public void testSetWorkHoursHoursGroupNoFixedAndHoursGroupFixedPercentageAndHoursGroupFixedPercentageDecreaseValue() { + + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + hoursGroup.setHoursPolicy(HoursPolicies.NO_FIXED); + hoursGroup.setWorkingHours(50); + HoursGroup hoursGroup2 = new HoursGroup(); + hoursGroup2.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup2.setWorkingHours(50); + hoursGroup2.setPercentage(new BigDecimal(0.25).setScale(2)); + HoursGroup hoursGroup3 = new HoursGroup(); + hoursGroup3.setHoursPolicy(HoursPolicies.FIXED_PERCENTAGE); + hoursGroup3.setWorkingHours(100); + hoursGroup3.setPercentage(new BigDecimal(0.50).setScale(2)); + orderLine.addHoursGroup(hoursGroup); + orderLine.addHoursGroup(hoursGroup2); + orderLine.addHoursGroup(hoursGroup3); + + assertThat(orderLine.getWorkHours(), equalTo(200)); + + try { + orderLine.setWorkHours(100); + } catch (IllegalArgumentException e) { + fail("It should not throw an exception"); + } + + assertThat(orderLine.getWorkHours(), equalTo(100)); + assertThat(orderLine.getHoursGroups().size(), equalTo(3)); + assertThat(hoursGroup.getWorkingHours(), equalTo(25)); + assertThat(hoursGroup2.getWorkingHours(), equalTo(25)); + assertThat(hoursGroup2.getPercentage(), equalTo(new BigDecimal(0.25) + .setScale(2))); + assertThat(hoursGroup3.getWorkingHours(), equalTo(50)); + assertThat(hoursGroup3.getPercentage(), equalTo(new BigDecimal(0.50) + .setScale(2))); + + } + + @Test + public void testAddNewEmptyHoursGroup() { + OrderLine orderLine = new OrderLine(); + HoursGroup hoursGroup = new HoursGroup(); + + orderLine.addHoursGroup(hoursGroup); + + assertThat(orderLine.getWorkHours(), equalTo(0)); + assertThat(orderLine.getHoursGroups().size(), equalTo(1)); + } + +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementController.java index 4fb926d7e..a56990b0c 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementController.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementController.java @@ -1,7 +1,6 @@ package org.navalplanner.web.orders; import java.math.BigDecimal; -import java.util.ArrayList; import java.util.List; import java.util.Set; @@ -17,10 +16,8 @@ import org.zkoss.zk.ui.event.Event; import org.zkoss.zk.ui.event.EventListener; import org.zkoss.zk.ui.event.Events; import org.zkoss.zk.ui.util.GenericForwardComposer; -import org.zkoss.zul.Checkbox; import org.zkoss.zul.Decimalbox; import org.zkoss.zul.Intbox; -import org.zkoss.zul.Label; import org.zkoss.zul.Listbox; import org.zkoss.zul.Listcell; import org.zkoss.zul.Listitem; @@ -113,57 +110,11 @@ public class OrderElementController extends GenericForwardComposer { popup.getFellow("deleteHoursGroup").setVisible(true); } - fillFixedHoursCheckbox(orderElement); - Util.reloadBindings(popup); popup.open(popup.getParent(), "start-after"); } - /** - * Private method that just fills the Div with id "fixedHoursCheckbox" in - * the .zul. - * - * If the parameter is a {@link OrderLine} the method adds the needed - * checkbox. - * - * @param orderElement - * {@link OrderElement} that is been rendered - */ - private void fillFixedHoursCheckbox(final OrderElement orderElement) { - - // Get the Div with id "fixedHoursCheckbox" - Component fixedHoursCheckbox = popup.getFellow("fixedHoursCheckbox"); - - // Empty the content of the Div - // Making a copy to avoid a ConcurrentModificationException - List children = new ArrayList(fixedHoursCheckbox - .getChildren()); - for (Component component : children) { - fixedHoursCheckbox.removeChild(component); - } - - // If is a leaf - if (orderElement instanceof OrderLine) { - // Add specific fields - fixedHoursCheckbox.appendChild(Util.bind(new Checkbox(), - new Util.Getter() { - - @Override - public Boolean get() { - return ((OrderLine) orderElement).isFixedHours(); - } - }, new Util.Setter() { - - @Override - public void set(Boolean value) { - ((OrderLine) orderElement).setFixedHours(value); - } - })); - fixedHoursCheckbox.appendChild(new Label("Fixed hours")); - } - } - /** * Just close the {@link Popup} */ @@ -243,6 +194,9 @@ public class OrderElementController extends GenericForwardComposer { listitem.setParent(hoursPolicyListBox); } + Decimalbox decimalBox = new Decimalbox(); + decimalBox.setScale(2); + // If is a container if (orderElement instanceof OrderLineGroup) { // Just getters are needed @@ -258,7 +212,7 @@ public class OrderElementController extends GenericForwardComposer { })); // Percentage - cellPercentage.appendChild(Util.bind(new Decimalbox(), + cellPercentage.appendChild(Util.bind(decimalBox, new Util.Getter() { @Override @@ -290,7 +244,7 @@ public class OrderElementController extends GenericForwardComposer { } }); - final Decimalbox percentage = Util.bind(new Decimalbox(), + final Decimalbox percentage = Util.bind(decimalBox, new Util.Getter() { @Override diff --git a/navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul b/navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul index 9e5ec2b5c..acfe99c4f 100644 --- a/navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul +++ b/navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul @@ -37,7 +37,6 @@