diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssigment.java b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssigment.java index e71750192..845728fdc 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssigment.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceAssigment.java @@ -1,13 +1,15 @@ package org.navalplanner.business.advance.entities; +import java.math.BigDecimal; import java.util.SortedSet; import java.util.TreeSet; +import org.hibernate.validator.NotNull; import org.navalplanner.business.common.BaseEntity; import org.navalplanner.business.orders.entities.OrderElement; public class AdvanceAssigment extends BaseEntity { - public enum Type { DIRECTO, CALCULADO }; + public enum Type { DIRECT, CALCULATED }; public static AdvanceAssigment create() { AdvanceAssigment advanceAssigment = new AdvanceAssigment(); @@ -15,14 +17,17 @@ public class AdvanceAssigment extends BaseEntity { return advanceAssigment; } - public static AdvanceAssigment create(boolean reportGlobalAdvance) { - AdvanceAssigment advanceAssigment = new AdvanceAssigment(reportGlobalAdvance); + public static AdvanceAssigment create(boolean reportGlobalAdvance, BigDecimal maxValue) { + AdvanceAssigment advanceAssigment = new AdvanceAssigment(reportGlobalAdvance, maxValue); advanceAssigment.setNewObject(true); return advanceAssigment; } private boolean reportGlobalAdvance; + @NotNull + private BigDecimal maxValue; + private Type type; private OrderElement orderElement; @@ -36,8 +41,10 @@ public class AdvanceAssigment extends BaseEntity { this.reportGlobalAdvance = false; } - private AdvanceAssigment(boolean reportGlobalAdvance) { + private AdvanceAssigment(boolean reportGlobalAdvance,BigDecimal maxValue) { this.reportGlobalAdvance = reportGlobalAdvance; + this.maxValue = maxValue; + this.maxValue.setScale(2,BigDecimal.ROUND_HALF_UP); } public void setReportGlobalAdvance(boolean reportGlobalAdvance) { @@ -48,6 +55,15 @@ public class AdvanceAssigment extends BaseEntity { return this.reportGlobalAdvance; } + public BigDecimal getMaxValue() { + return this.maxValue; + } + + public void setMaxValue(BigDecimal maxValue) { + this.maxValue = maxValue; + this.maxValue.setScale(2); + } + public void setOrderElement(OrderElement orderElement) { this.orderElement = orderElement; } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurement.java b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurement.java index 189cd2db6..ed1758a1a 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurement.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurement.java @@ -8,10 +8,9 @@ import org.navalplanner.business.common.BaseEntity; public class AdvanceMeasurement extends BaseEntity { - public static AdvanceMeasurement create(Date date, BigDecimal value, - BigDecimal maxValue) { + public static AdvanceMeasurement create(Date date, BigDecimal value) { AdvanceMeasurement advanceMeasurement = new AdvanceMeasurement(date, - value, maxValue); + value); advanceMeasurement.setNewObject(true); return advanceMeasurement; } @@ -28,21 +27,20 @@ public class AdvanceMeasurement extends BaseEntity { @NotNull private BigDecimal value; - @NotNull - private BigDecimal maxValue; - @NotNull private AdvanceAssigment advanceAssigment; + private int numIndirectSons; + public AdvanceMeasurement() { + this.numIndirectSons = 0; } - private AdvanceMeasurement(Date date, BigDecimal value, BigDecimal maxValue) { + private AdvanceMeasurement(Date date, BigDecimal value) { this.date = date; this.value = value; this.value.setScale(2,BigDecimal.ROUND_HALF_UP); - this.maxValue = maxValue; - this.maxValue.setScale(2,BigDecimal.ROUND_HALF_UP); + this.numIndirectSons = 0; } public void setDate(Date date) { @@ -62,15 +60,6 @@ public class AdvanceMeasurement extends BaseEntity { return this.value; } - public BigDecimal getMaxValue() { - return this.maxValue; - } - - public void setMaxValue(BigDecimal maxValue) { - this.maxValue = maxValue; - this.maxValue.setScale(2); - } - public void setAdvanceAssigment(AdvanceAssigment advanceAssigment) { this.advanceAssigment = advanceAssigment; } @@ -78,4 +67,20 @@ public class AdvanceMeasurement extends BaseEntity { public AdvanceAssigment getAdvanceAssigment() { return this.advanceAssigment; } + + public int getNumIndirectSons() { + return numIndirectSons; + } + + public void setNumIndirectSons(int numIndirectSons) { + this.numIndirectSons = numIndirectSons; + } + + public void incrementNumIndirectSons() { + this.numIndirectSons = this.numIndirectSons + 1; + } + + public void decrementNumIndirectSons() { + this.numIndirectSons = this.numIndirectSons - 1; + } } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurementComparator.java b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurementComparator.java index 272138bba..c916b17f1 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurementComparator.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/advance/entities/AdvanceMeasurementComparator.java @@ -18,6 +18,6 @@ public class AdvanceMeasurementComparator implements Comparator + org.navalplanner.business.advance.entities.AdvanceAssigment$Type @@ -58,7 +59,7 @@ - + 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 086ef38af..dae70b556 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 @@ -46,7 +46,7 @@ - + diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssigmentsToOrderElementTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssigmentsToOrderElementTest.java index e60333939..972fad1df 100644 --- a/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssigmentsToOrderElementTest.java +++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/AddAdvanceAssigmentsToOrderElementTest.java @@ -10,6 +10,7 @@ import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING import java.math.BigDecimal; +import java.util.Date; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.junit.Test; @@ -17,6 +18,7 @@ import org.junit.runner.RunWith; import org.navalplanner.business.advance.daos.IAdvanceAssigmentDAO; import org.navalplanner.business.advance.daos.IAdvanceTypeDAO; import org.navalplanner.business.advance.entities.AdvanceAssigment; +import org.navalplanner.business.advance.entities.AdvanceMeasurement; import org.navalplanner.business.advance.entities.AdvanceType; import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssigmentForOrderElementException; import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException; @@ -90,10 +92,17 @@ public class AddAdvanceAssigmentsToOrderElementTest { return advanceType; } + private AdvanceMeasurement createValidAdvanceMeasurement() { + AdvanceMeasurement advanceMeasurement = AdvanceMeasurement.create( + new Date(), new BigDecimal(0)); + return advanceMeasurement; + } + private AdvanceAssigment createValidAdvanceAssigment( boolean reportGlobalAdvance) { AdvanceAssigment advanceAssigment = AdvanceAssigment.create( - reportGlobalAdvance); + reportGlobalAdvance,new BigDecimal(0)); + advanceAssigment.setType(AdvanceAssigment.Type.DIRECT); return advanceAssigment; } @@ -203,13 +212,17 @@ public class AddAdvanceAssigmentsToOrderElementTest { OrderLine son = createValidLeaf("bla", "132"); container.add(son); + AdvanceMeasurement advanceMeasurement = createValidAdvanceMeasurement(); + AdvanceType advanceTypeA = createAndSaveType("tipoA"); AdvanceType advanceTypeB = createAndSaveType("tipoB"); AdvanceAssigment advanceAssigmentA = createValidAdvanceAssigment(true); advanceAssigmentA.setAdvanceType(advanceTypeA); + advanceAssigmentA.getAdvanceMeasurements().add(advanceMeasurement); AdvanceAssigment advanceAssigmentB = createValidAdvanceAssigment(false); advanceAssigmentB.setAdvanceType(advanceTypeB); + advanceAssigmentB.getAdvanceMeasurements().add(advanceMeasurement); container.addAvanceAssigment(advanceAssigmentA); @@ -270,12 +283,15 @@ public class AddAdvanceAssigmentsToOrderElementTest { OrderLine grandSon = createValidLeaf("GranSon", "75757"); son.add(grandSon); + AdvanceMeasurement advanceMeasurement = createValidAdvanceMeasurement(); AdvanceType advanceTypeA = createAndSaveType("tipoA"); AdvanceAssigment advanceAssigmentA = createValidAdvanceAssigment(true); advanceAssigmentA.setAdvanceType(advanceTypeA); + advanceAssigmentA.getAdvanceMeasurements().add(advanceMeasurement); AdvanceAssigment advanceAssigmentB = createValidAdvanceAssigment(false); advanceAssigmentB.setAdvanceType(advanceTypeA); + advanceAssigmentB.getAdvanceMeasurements().add(advanceMeasurement); grandSon.addAvanceAssigment(advanceAssigmentA); diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceAssigmentDTO.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceAssigmentDTO.java new file mode 100644 index 000000000..8b3a24dc4 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceAssigmentDTO.java @@ -0,0 +1,142 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ + +package org.navalplanner.web.orders; +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.TreeSet; +import java.util.SortedSet; +import org.navalplanner.business.advance.entities.AdvanceAssigment; +import org.navalplanner.business.advance.entities.AdvanceMeasurement; +import org.navalplanner.business.advance.entities.AdvanceMeasurementComparator; +import org.navalplanner.business.advance.entities.AdvanceType; +import org.navalplanner.business.util.ListSorter; + +/** + * + * @author Susana Montes Pedreira + */ +public class AdvanceAssigmentDTO { + + private AdvanceType advanceType; + + private SortedSet advanceMeasurements = + new TreeSet(new AdvanceMeasurementComparator()); + + private ListSorter advanceMeasurementDTOs = + ListSorter.create(new ArrayList(), new AdvanceMeasurementDTOComparator()); + + private AdvanceAssigment advanceAssigment; + + private BigDecimal maxValue; + + private boolean reportGlobalAdvance; + + private AdvanceAssigment.Type type; + + private boolean isNewObject = true; + + private boolean isNewDTO = true; + + private boolean selectedRemove = false; + + public AdvanceAssigmentDTO() { + this.reportGlobalAdvance = false; + this.isNewDTO = true; + this.isNewObject = false; + this.type = AdvanceAssigment.Type.DIRECT; + } + + public AdvanceAssigmentDTO(AdvanceType advanceType, + AdvanceAssigment advanceAssigment, + SortedSet advanceMeasurements) { + this.advanceType = advanceType; + this.advanceMeasurements = advanceMeasurements; + this.advanceAssigment = advanceAssigment; + + this.maxValue = advanceAssigment.getMaxValue(); + this.reportGlobalAdvance = advanceAssigment.getReportGlobalAdvance(); + this.type = advanceAssigment.getType(); + + this.isNewDTO = false; + if(advanceAssigment.getVersion()==null){ + this.isNewObject = true; + }else{ + this.isNewObject = false; + } + } + + public boolean getIsNewObject() { + return this.isNewObject; + } + + public boolean getIsNewDTO() { + return this.isNewDTO; + } + + public void setAdvanceType(AdvanceType advanceType){ + this.advanceType = advanceType; + } + + public AdvanceType getAdvanceType() { + return this.advanceType; + } + + public AdvanceAssigment getAdvanceAssigment() { + return this.advanceAssigment; + } + + public void setAdvanceAssigment(AdvanceAssigment advanceAssigment) { + this.advanceAssigment = advanceAssigment; + } + + public SortedSet getAdvanceMeasurements() { + return this.advanceMeasurements; + } + + public void setAdvanceMeasurements(SortedSet advanceMeasurements) { + this.advanceMeasurements = advanceMeasurements; + } + + public ListSorter getAdvanceMeasurementDTOs() { + return this.advanceMeasurementDTOs; + } + + public void setAdvanceMeasurementDTOs(ListSorter advanceMeasurementDTOs) { + this.advanceMeasurementDTOs = advanceMeasurementDTOs; + } + + public void setReportGlobalAdvance(boolean reportGlobalAdvance) { + this.reportGlobalAdvance = reportGlobalAdvance; + } + + public boolean getReportGlobalAdvance() { + return this.reportGlobalAdvance; + } + + public BigDecimal getMaxValue(){ + return this.maxValue; + } + + public void setMaxValue(BigDecimal maxValue) { + this.maxValue = maxValue; + } + + public AdvanceAssigment.Type getType(){ + return this.type; + } + + public void setType(AdvanceAssigment.Type type) { + this.type = type; + } + + public boolean isSelectedForRemove(){ + return this.selectedRemove; + } + + public void setSelectedForRemove(boolean selectedRemove){ + this.selectedRemove = selectedRemove; + } +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceMeasurementDTO.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceMeasurementDTO.java index 29337f546..797f4644d 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceMeasurementDTO.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceMeasurementDTO.java @@ -3,26 +3,18 @@ package org.navalplanner.web.orders; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.Date; -import org.navalplanner.business.advance.entities.AdvanceAssigment; import org.navalplanner.business.advance.entities.AdvanceMeasurement; -import org.navalplanner.business.advance.entities.AdvanceType; public class AdvanceMeasurementDTO{ - private AdvanceType advanceType; - private AdvanceMeasurement advanceMeasurement; - private AdvanceAssigment advanceAssigment; + private AdvanceAssigmentDTO advanceAssigmentDTO; private Date date; - private BigDecimal maxValue; - private BigDecimal value; - private boolean reportGlobalAdvance; - private boolean isNewObject = true; private boolean isNewDTO = true; @@ -32,36 +24,28 @@ public class AdvanceMeasurementDTO{ private String percentage; public AdvanceMeasurementDTO() { - this.reportGlobalAdvance = false; this.date = new Date(); - this.percentage = new String(""); + this.percentage = new String("0 %"); this.isNewDTO = true; this.isNewObject = false; } - public AdvanceMeasurementDTO(AdvanceType advanceType, - AdvanceAssigment advanceAssigment, - AdvanceMeasurement advanceMeasurement) { - this.advanceType = advanceType; + public AdvanceMeasurementDTO(AdvanceMeasurement advanceMeasurement){ this.advanceMeasurement = advanceMeasurement; this.date = advanceMeasurement.getDate(); - this.maxValue = advanceMeasurement.getMaxValue(); this.value = advanceMeasurement.getValue(); - this.advanceAssigment = advanceAssigment; - this.reportGlobalAdvance = advanceAssigment.getReportGlobalAdvance(); - - this.percentage = new String(""); + this.percentage = new String("0 %"); this.isNewDTO = false; - if(advanceAssigment.getVersion()==null){ + if(advanceMeasurement.getVersion()==null){ this.isNewObject = true; }else{ this.isNewObject = false; } } - public boolean getIsNewObject() { + public boolean getIsNewObject(){ return this.isNewObject; } @@ -69,45 +53,40 @@ public class AdvanceMeasurementDTO{ return this.isNewDTO; } - public void setAdvanceType(AdvanceType advanceType){ - this.advanceType = advanceType; + public AdvanceAssigmentDTO getAdvanceAssigmentDTO() { + return this.advanceAssigmentDTO; } - public AdvanceType getAdvanceType() { - return this.advanceType; - } - - public AdvanceAssigment getAdvanceAssigment() { - return this.advanceAssigment; + public void setAdvanceAssigmentDTO(AdvanceAssigmentDTO advanceAssigmentDTO) { + this.advanceAssigmentDTO = advanceAssigmentDTO; } public AdvanceMeasurement getAdvanceMeasurement() { return this.advanceMeasurement; } + public void setAdvanceMeasurement(AdvanceMeasurement advanceMeasurement) { + this.advanceMeasurement = advanceMeasurement; + } + public void setPercentage(String percentage) { this.percentage = percentage; } public String getPercentage() { - if((value != null)&&(maxValue != null)){ + if(advanceAssigmentDTO == null) return "0 %"; + if(value == null) return "0 %"; + if(advanceAssigmentDTO.getMaxValue() != null){ + BigDecimal maxValue = advanceAssigmentDTO.getMaxValue(); BigDecimal percentage = new BigDecimal(0); BigDecimal division = (value.divide(maxValue,4,RoundingMode.HALF_UP)); division.setScale(2, RoundingMode.HALF_UP); percentage = division.multiply(new BigDecimal(100)); percentage = percentage.setScale(2, RoundingMode.HALF_UP); - this.percentage = percentage.toString(); + this.percentage = percentage.toString()+" %"; return this.percentage; } - return ""; - } - - public void setReportGlobalAdvance(boolean reportGlobalAdvance) { - this.reportGlobalAdvance = reportGlobalAdvance; - } - - public boolean getReportGlobalAdvance() { - return this.reportGlobalAdvance; + return "0 %"; } public void setDate(Date date) { @@ -126,14 +105,6 @@ public class AdvanceMeasurementDTO{ return this.value; } - public BigDecimal getMaxValue() { - return this.maxValue; - } - - public void setMaxValue(BigDecimal maxValue) { - this.maxValue = maxValue; - } - public boolean isSelectedForRemove(){ return this.selectedRemove; } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceMeasurementDTOComparator.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceMeasurementDTOComparator.java new file mode 100644 index 000000000..878e547e4 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AdvanceMeasurementDTOComparator.java @@ -0,0 +1,16 @@ +package org.navalplanner.web.orders; +import java.util.Comparator; +/** + * + * @author Susana Montes Pedreira + */ +public class AdvanceMeasurementDTOComparator implements Comparator { + + public AdvanceMeasurementDTOComparator(){ + } + + @Override + public int compare(AdvanceMeasurementDTO arg0, AdvanceMeasurementDTO arg1) { + return arg1.getDate().compareTo(arg0.getDate()); + } +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IManageOrderElementAdvancesModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IManageOrderElementAdvancesModel.java index bfdc38508..31f0932a7 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IManageOrderElementAdvancesModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IManageOrderElementAdvancesModel.java @@ -14,21 +14,40 @@ import org.navalplanner.business.orders.entities.OrderElement; * @author Susana Montes Pedreira */ public interface IManageOrderElementAdvancesModel { - public List getAdvanceMeasurements(); + + public void prepareEditAdvanceMeasurements(AdvanceAssigmentDTO advanceAssigmentDTO); + + public List getAdvanceMeasurementDTOs(); + + public List getAdvanceAssigmentDTOs(); public void init(OrderElement orderElement); - public void addNewLine(); + public void addNewLineAdvaceAssigment(); - public void removeLine(AdvanceMeasurementDTO advanceDTO); + public void addNewLineAdvaceMeasurement(); + + public void removeLineAdvanceAssigment(AdvanceAssigmentDTO advanceDTO); + + public void removeLineAdvanceMeasurement(AdvanceMeasurementDTO advanceDTO); public List getActivesAdvanceTypes(); - public boolean isPrecisionValid(AdvanceMeasurementDTO advanceDTO, BigDecimal value); + public boolean isReadOnlyAdvanceMeasurementDTOs(); - public boolean greatThanMaxValue(AdvanceMeasurementDTO advanceDTO, BigDecimal value); + public void cleanAdvance(); - public boolean isGreatValidDate(AdvanceMeasurementDTO advanceDTO, Date value); + public boolean isPrecisionValid(BigDecimal value); + + public boolean greatThanMaxValue(BigDecimal value); + + public boolean isGreatValidDate(Date value); + + public BigDecimal getUnitPrecision(); + + public AdvanceMeasurementDTO getFirstAdvanceMeasurement(AdvanceAssigmentDTO advanceAssigmentDTO); + + public void modifyListAdvanceMeasurement(AdvanceMeasurementDTO advanceMeasurementDTO); public void accept()throws InstanceNotFoundException, DuplicateAdvanceAssigmentForOrderElementException, diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesController.java index e6ccf4ce6..e321d5625 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesController.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesController.java @@ -7,6 +7,8 @@ import static org.navalplanner.web.I18nHelper._; import java.math.BigDecimal; import java.util.Date; import java.util.List; +import java.util.SortedSet; +import org.navalplanner.business.advance.entities.AdvanceAssigment; import org.navalplanner.business.advance.entities.AdvanceType; import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssigmentForOrderElementException; import org.navalplanner.web.common.IMessagesForUser; @@ -19,6 +21,7 @@ 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.Combobox; import org.zkoss.zul.Comboitem; import org.zkoss.zul.Constraint; @@ -30,6 +33,7 @@ import org.zkoss.zul.Listcell; import org.zkoss.zul.Listitem; import org.zkoss.zul.ListitemRenderer; import org.zkoss.zul.Radio; +import org.zkoss.zul.Textbox; import org.zkoss.zul.Window; /** @@ -44,6 +48,8 @@ public class ManageOrderElementAdvancesController extends private Window window; + private int indexSelectedItem = -1; + private IManageOrderElementAdvancesModel manageOrderElementAdvancesModel; private AdvanceTypeListRenderer advanceTypeListRenderer = new AdvanceTypeListRenderer(); @@ -57,7 +63,11 @@ public class ManageOrderElementAdvancesController extends } public List getAdvanceMeasurementDTOs() { - return manageOrderElementAdvancesModel.getAdvanceMeasurements(); + return manageOrderElementAdvancesModel.getAdvanceMeasurementDTOs(); + } + + public List getAdvanceAssigmentDTOs() { + return manageOrderElementAdvancesModel.getAdvanceAssigmentDTOs(); } public void cancel() { @@ -94,40 +104,79 @@ public class ManageOrderElementAdvancesController extends public void openWindow(IOrderElementModel orderElementModel) { this.manageOrderElementAdvancesModel.init(orderElementModel .getOrderElement()); - } - - public void goToCreateLine() { - manageOrderElementAdvancesModel.addNewLine(); + this.indexSelectedItem = -1; Util.reloadBindings(window); } - public void goToRemoveLine(){ + public void prepareEditAdvanceMeasurements(AdvanceAssigmentDTO advanceAssigmentDTO){ + manageOrderElementAdvancesModel.prepareEditAdvanceMeasurements(advanceAssigmentDTO); + Listbox listAdvances = ((Listbox) window.getFellow("editAdvances")); + this.indexSelectedItem = listAdvances.getIndexOfItem(listAdvances.getSelectedItem()); + Util.reloadBindings(window); + } + + public void goToCreateLineAdvanceAssigment() { + manageOrderElementAdvancesModel.addNewLineAdvaceAssigment(); + Util.reloadBindings(window); + } + + public void goToCreateLineAdvanceMeasurement() { + manageOrderElementAdvancesModel.addNewLineAdvaceMeasurement(); + Util.reloadBindings(window); + } + + public void goToRemoveLineAdvanceAssigment(){ Listbox listAdvances = (Listbox) window.getFellow("editAdvances"); - Listitem listItem = listAdvances.getSelectedItem(); + Listitem listItem = listAdvances.getItemAtIndex(indexSelectedItem); if(listItem != null){ - AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO) listItem.getValue(); - manageOrderElementAdvancesModel.removeLine(advanceDTO); + + AdvanceAssigmentDTO advanceAssigmentDTO = (AdvanceAssigmentDTO) listItem.getValue(); + manageOrderElementAdvancesModel.removeLineAdvanceAssigment(advanceAssigmentDTO); Util.reloadBindings(window); } } + public void goToRemoveLineAdvanceMeasurement(){ + Listbox listAdvancesMeasurement = (Listbox)window.getFellow("editAdvancesMeasurement"); + Listitem selectedItem = listAdvancesMeasurement.getSelectedItem(); + if(selectedItem != null){ + AdvanceMeasurementDTO advanceMeasurementDTO = (AdvanceMeasurementDTO) selectedItem.getValue(); + if(advanceMeasurementDTO != null){ + manageOrderElementAdvancesModel.removeLineAdvanceMeasurement(advanceMeasurementDTO); + Util.reloadBindings(window); + } + } + } + public List getActivesAdvanceType() { return manageOrderElementAdvancesModel.getActivesAdvanceTypes(); } + public boolean isReadOnlyAdvanceMeasurementDTOs(){ + return manageOrderElementAdvancesModel.isReadOnlyAdvanceMeasurementDTOs(); + } + public AdvanceTypeListRenderer getAdvancesRenderer() { return advanceTypeListRenderer; } + public void updatesValue(final Decimalbox item){ + this.setPercentage(); + this.setCurrentValue(); + this.cleanDate((Listitem)item.getParent().getParent()); + this.setCurrentDate(); + } + public class AdvanceTypeListRenderer implements ListitemRenderer { @Override public void render(Listitem listItem, Object data) throws Exception { - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO) data; + final AdvanceAssigmentDTO advanceDTO = (AdvanceAssigmentDTO) data; listItem.setValue(advanceDTO); listItem.setDraggable("true"); listItem.setDroppable("true"); - if ((advanceDTO.getIsNewObject())||(advanceDTO.getIsNewDTO())){ + if((advanceDTO.getType().equals(AdvanceAssigment.Type.DIRECT)) + && ((advanceDTO.getIsNewObject())||(advanceDTO.getIsNewDTO()))){ appendComboboxAdvancType(listItem); } else { appendLabelAdvanceType(listItem); @@ -137,11 +186,12 @@ public class ManageOrderElementAdvancesController extends appendLabelPercentage(listItem); appendDateBoxDate(listItem); appendRadioSpread(listItem); + appendCalculatedCheckbox(listItem); } } private void appendComboboxAdvancType(final Listitem listItem){ - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO)listItem.getValue(); + final AdvanceAssigmentDTO advanceDTO = (AdvanceAssigmentDTO)listItem.getValue(); final Combobox comboAdvanceTypes = new Combobox(); final List listAdvanceType = manageOrderElementAdvancesModel .getActivesAdvanceTypes(); @@ -160,8 +210,8 @@ public class ManageOrderElementAdvancesController extends @Override public void onEvent(Event event) throws Exception { setMaxValue(listItem,comboAdvanceTypes); - cleanFields(listItem); - setPercentage(listItem); + cleanFields(); + setPercentage(); } }); @@ -188,7 +238,7 @@ public class ManageOrderElementAdvancesController extends } private void appendLabelAdvanceType(final Listitem listItem){ - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO)listItem.getValue(); + final AdvanceAssigmentDTO advanceDTO = (AdvanceAssigmentDTO)listItem.getValue(); Label unitName = new Label(advanceDTO.getAdvanceType().getUnitName()); Listcell listCell = new Listcell(); listCell.appendChild(unitName); @@ -196,27 +246,31 @@ public class ManageOrderElementAdvancesController extends } private void appendDecimalBoxMaxValue(final Listitem listItem){ - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO)listItem.getValue(); + final AdvanceAssigmentDTO advanceAssigmentDTO = (AdvanceAssigmentDTO)listItem.getValue(); Decimalbox maxValue = new Decimalbox(); maxValue.setScale(2); + + if(advanceAssigmentDTO.getType().equals(AdvanceAssigment.Type.CALCULATED)) + maxValue.setDisabled(true); + Util.bind(maxValue, new Util.Getter() { @Override public BigDecimal get() { - return advanceDTO.getMaxValue(); + return advanceAssigmentDTO.getMaxValue(); } }, new Util.Setter() { @Override public void set(BigDecimal value) { - advanceDTO.setMaxValue(value); + advanceAssigmentDTO.setMaxValue(value); } }); maxValue.addEventListener(Events.ON_CHANGE, new EventListener() { @Override public void onEvent(Event event) throws Exception { - setPercentage(listItem); + setPercentage(); } }); @@ -226,83 +280,106 @@ public class ManageOrderElementAdvancesController extends } private void appendDecimalBoxValue(final Listitem listItem){ - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO)listItem.getValue(); + final AdvanceAssigmentDTO advanceAssigmentDTO = (AdvanceAssigmentDTO)listItem.getValue(); Decimalbox value = new Decimalbox(); value.setScale(2); - Util.bind(value, new Util.Getter() { - @Override - public BigDecimal get() { - return advanceDTO.getValue(); - } - }, new Util.Setter() { + value.setDisabled(true); + + final AdvanceMeasurementDTO advanceMeasurementDTO = + this.manageOrderElementAdvancesModel.getFirstAdvanceMeasurement(advanceAssigmentDTO); + if(advanceMeasurementDTO != null){ + Util.bind(value, new Util.Getter() { + @Override + public BigDecimal get() { + return advanceMeasurementDTO.getValue(); + } + }, new Util.Setter() { @Override public void set(BigDecimal value) { - advanceDTO.setValue(value); + advanceMeasurementDTO.setValue(value); } - }); - value.setConstraint(checkValidValue()); - value.addEventListener(Events.ON_CHANGE, - new EventListener() { - @Override - public void onEvent(Event event) throws Exception { - setPercentage(listItem); - cleanDate(listItem); - } - }); - + }); + } Listcell listCell = new Listcell(); listCell.appendChild(value); listItem.appendChild(listCell); } private void appendLabelPercentage(final Listitem listItem){ - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO)listItem.getValue(); + final AdvanceAssigmentDTO advanceAssigmentDTO = (AdvanceAssigmentDTO)listItem.getValue(); Label percentage = new Label(); - percentage.setValue(advanceDTO.getPercentage() + " %"); + + final AdvanceMeasurementDTO advanceMeasurementDTO = + this.manageOrderElementAdvancesModel.getFirstAdvanceMeasurement(advanceAssigmentDTO); + if(advanceMeasurementDTO != null){ + percentage.setValue(advanceMeasurementDTO.getPercentage()); + } + Listcell listCell = new Listcell(); listCell.appendChild(percentage); listItem.appendChild(listCell); } private void appendDateBoxDate(final Listitem listItem){ - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO)listItem.getValue(); + final AdvanceAssigmentDTO advanceAssigmentDTO = (AdvanceAssigmentDTO)listItem.getValue(); Datebox date = new Datebox(); - Util.bind(date, new Util.Getter() { + date.setDisabled(true); + + final AdvanceMeasurementDTO advanceMeasurementDTO = + this.manageOrderElementAdvancesModel.getFirstAdvanceMeasurement(advanceAssigmentDTO); + if(advanceMeasurementDTO != null){ + + Util.bind(date, new Util.Getter() { @Override public Date get() { - return advanceDTO.getDate(); + return advanceMeasurementDTO.getDate(); } - }, new Util.Setter() { + }, new Util.Setter() { @Override public void set(Date value) { - advanceDTO.setDate(value); + advanceMeasurementDTO.setDate(value); } - }); - date.setConstraint(checkValidDate()); + }); + } Listcell listCell = new Listcell(); listCell.appendChild(date); listItem.appendChild(listCell); } private void appendRadioSpread(final Listitem listItem){ - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO)listItem.getValue(); + final AdvanceAssigmentDTO advanceAssigmentDTO = (AdvanceAssigmentDTO)listItem.getValue(); Radio reportGlobalAdvance = new Radio(); - reportGlobalAdvance.setChecked(advanceDTO.getReportGlobalAdvance()); + reportGlobalAdvance.setChecked(advanceAssigmentDTO.getReportGlobalAdvance()); + + if(advanceAssigmentDTO.getType().equals(AdvanceAssigment.Type.CALCULATED)) + reportGlobalAdvance.setDisabled(true); reportGlobalAdvance.addEventListener(Events.ON_CHECK, - new EventListener() { - @Override - public void onEvent(Event event) throws Exception { - setReportGlobalAdvance(listItem); - } + new EventListener() { + @Override + public void onEvent(Event event) throws Exception { + setReportGlobalAdvance(listItem); + } }); Listcell listCell = new Listcell(); listCell.appendChild(reportGlobalAdvance); listItem.appendChild(listCell); } + private void appendCalculatedCheckbox(final Listitem listItem){ + final AdvanceAssigmentDTO advanceDTO = (AdvanceAssigmentDTO)listItem.getValue(); + Checkbox calculated = new Checkbox(); + boolean isCalculated = advanceDTO.getType().equals(AdvanceAssigment.Type.CALCULATED); + calculated.setChecked(isCalculated); + calculated.setDisabled(true); + + Listcell listCell = new Listcell(); + listCell.appendChild(calculated); + listItem.appendChild(listCell); + } + private void setMaxValue(final Listitem item,Combobox comboAdvanceTypes) { Listcell listCell = (Listcell)item.getChildren().get(1); Decimalbox miBox = ((Decimalbox) listCell.getFirstChild()); @@ -310,44 +387,80 @@ public class ManageOrderElementAdvancesController extends if(selectedItem != null){ AdvanceType advanceType = ((AdvanceType) selectedItem.getValue()); if(advanceType != null){ - AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO)item.getValue(); + AdvanceAssigmentDTO advanceDTO = (AdvanceAssigmentDTO)item.getValue(); advanceDTO.setMaxValue(advanceType.getDefaultMaxValue()); miBox.setValue(advanceType.getDefaultMaxValue()); } } } - private void setPercentage(final Listitem item){ - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO) item.getValue(); - Listcell celdaPercentage = (Listcell)item.getChildren().get(3); - ((Label)celdaPercentage.getFirstChild()).setValue(advanceDTO.getPercentage()+" %"); + private void setPercentage(){ + if(this.indexSelectedItem >= 0){ + Listbox listAdvances = ((Listbox) window.getFellow("editAdvances")); + Listitem selectedItem = listAdvances.getItemAtIndex(indexSelectedItem); + AdvanceAssigmentDTO advanceAssigmentDTO = + (AdvanceAssigmentDTO) selectedItem.getValue(); + + final AdvanceMeasurementDTO greatAdvanceMeasurementDTO = + this.manageOrderElementAdvancesModel.getFirstAdvanceMeasurement(advanceAssigmentDTO); + if(greatAdvanceMeasurementDTO != null){ + Listcell percentage = (Listcell)selectedItem.getChildren().get(3); + ((Label)percentage.getFirstChild()).setValue(greatAdvanceMeasurementDTO.getPercentage()); + } + } + } + + private void setCurrentValue(){ + if(this.indexSelectedItem >= 0){ + Listbox listAdvances = ((Listbox) window.getFellow("editAdvances")); + Listitem selectedItem = listAdvances.getItemAtIndex(indexSelectedItem); + AdvanceAssigmentDTO advanceAssigmentDTO = + (AdvanceAssigmentDTO) selectedItem.getValue(); + final AdvanceMeasurementDTO greatAdvanceMeasurementDTO = + this.manageOrderElementAdvancesModel.getFirstAdvanceMeasurement(advanceAssigmentDTO); + if(greatAdvanceMeasurementDTO != null){ + Listcell value = (Listcell)selectedItem.getChildren().get(2); + ((Decimalbox)value.getFirstChild()).setValue(greatAdvanceMeasurementDTO.getValue()); + } + } + + } + + public void setCurrentDate(Listitem item){ + this.manageOrderElementAdvancesModel.modifyListAdvanceMeasurement( + (AdvanceMeasurementDTO)item.getValue()); + Util.reloadBindings(window.getFellow("editAdvancesMeasurement")); + + setCurrentDate(); + this.setPercentage(); + this.setCurrentValue(); + } + + private void setCurrentDate(){ + if(this.indexSelectedItem >= 0){ + Listbox listAdvances = ((Listbox) window.getFellow("editAdvances")); + Listitem selectedItem = listAdvances.getItemAtIndex(indexSelectedItem); + AdvanceAssigmentDTO advanceAssigmentDTO = + (AdvanceAssigmentDTO) selectedItem.getValue(); + final AdvanceMeasurementDTO greatAdvanceMeasurementDTO = + this.manageOrderElementAdvancesModel.getFirstAdvanceMeasurement(advanceAssigmentDTO); + if(greatAdvanceMeasurementDTO != null){ + Listcell date = (Listcell)selectedItem.getChildren().get(4); + ((Datebox)date.getFirstChild()).setValue(greatAdvanceMeasurementDTO.getDate()); + } + } } private void cleanDate(final Listitem item){ - final AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO) item.getValue(); - advanceDTO.setDate(null); - Listcell celdaDate = (Listcell)item.getChildren().get(4); + final AdvanceMeasurementDTO advanceMeasurementDTO = (AdvanceMeasurementDTO) item.getValue(); + advanceMeasurementDTO.setDate(null); + Listcell celdaDate = (Listcell)item.getChildren().get(2); ((Datebox)celdaDate.getFirstChild()).setValue(null); } - private void cleanFields(final Listitem item){ - AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO) item.getValue(); - - Listcell celdaValue = (Listcell) item.getChildren().get(2); - ((Decimalbox)celdaValue.getFirstChild()).setValue(null); - advanceDTO.setValue(null); - - Listcell celdaPercentage = (Listcell) item.getChildren().get(3); - ((Label)celdaPercentage.getFirstChild()).setValue(" %"); - advanceDTO.setPercentage(""); - - Listcell celdaDate = (Listcell) item.getChildren().get(4); - ((Datebox)celdaDate.getFirstChild()).setValue(null); - advanceDTO.setDate(null); - - Listcell celdaSpread = (Listcell) item.getChildren().get(5); - ((Radio)celdaSpread.getFirstChild()).setChecked(false); - advanceDTO.setReportGlobalAdvance(false); + private void cleanFields(){ + this.manageOrderElementAdvancesModel.cleanAdvance(); + Util.reloadBindings(window); } private void setReportGlobalAdvance(final Listitem item){ @@ -356,33 +469,35 @@ public class ManageOrderElementAdvancesController extends if(listAdvances.getChildren().get(i) instanceof Listitem){ Listitem listItem = (Listitem) listAdvances.getChildren().get(i); Listcell celdaSpread = (Listcell) listItem.getChildren().get(5); - ((Radio)celdaSpread.getFirstChild()).setChecked(false); - ((AdvanceMeasurementDTO)listItem.getValue()).setReportGlobalAdvance(false); + Radio radioSpread = ((Radio)celdaSpread.getFirstChild()); + if(!radioSpread.isDisabled()){ + radioSpread.setChecked(false); + ((AdvanceAssigmentDTO)listItem.getValue()).setReportGlobalAdvance(false); + } } } Listcell celdaSpread = (Listcell) item.getChildren().get(5); ((Radio)celdaSpread.getFirstChild()).setChecked(true); - ((AdvanceMeasurementDTO)item.getValue()).setReportGlobalAdvance(true); + ((AdvanceAssigmentDTO)item.getValue()).setReportGlobalAdvance(true); } - private Constraint checkValidValue() { + + public Constraint checkValidValue() { Constraint newConstraint = new Constraint() { @Override public void validate(Component comp, Object value) throws WrongValueException { if (((BigDecimal) value) != null){ - Listitem listItem = ((Listitem)comp.getParent().getParent()); - AdvanceMeasurementDTO advanceDTO = ((AdvanceMeasurementDTO)listItem.getValue()); - if(manageOrderElementAdvancesModel.greatThanMaxValue(advanceDTO,(BigDecimal)value)){ + if(manageOrderElementAdvancesModel.greatThanMaxValue((BigDecimal)value)){ throw new WrongValueException( comp, _("Value is not valid, the current value must be less than max value")); } - if (!(manageOrderElementAdvancesModel.isPrecisionValid(advanceDTO,(BigDecimal)value))) { + if (!(manageOrderElementAdvancesModel.isPrecisionValid((BigDecimal)value))) { throw new WrongValueException( comp, _("Value is not valid, the Precision value must be exact " - +advanceDTO.getAdvanceType().getUnitPrecision())); + +manageOrderElementAdvancesModel.getUnitPrecision())); } } } @@ -390,15 +505,13 @@ public class ManageOrderElementAdvancesController extends return newConstraint; } - private Constraint checkValidDate() { + public Constraint checkValidDate() { Constraint newConstraint = new Constraint() { @Override public void validate(Component comp, Object value) throws WrongValueException { if (((Date) value) != null) { - Listitem listItem = ((Listitem)comp.getParent().getParent()); - AdvanceMeasurementDTO advanceDTO = ((AdvanceMeasurementDTO)listItem.getValue()); - if(!manageOrderElementAdvancesModel.isGreatValidDate(advanceDTO,(Date)value)){ + if(!manageOrderElementAdvancesModel.isGreatValidDate((Date)value)){ throw new WrongValueException( comp, _("The date is not valid, the date must be great than the current date of the other advances measurement")); @@ -410,13 +523,29 @@ public class ManageOrderElementAdvancesController extends } private boolean validateDataForm(){ + return ((validateListAdvanceAssigment()) + &&(validateListAdvanceMeasurement())); + } + + private boolean validateListAdvanceAssigment(){ Listbox listAdvances = (Listbox) window.getFellow("editAdvances"); for(int i=0; i< listAdvances.getChildren().size(); i++){ if(listAdvances.getChildren().get(i) instanceof Listitem){ Listitem listItem = (Listitem) listAdvances.getChildren().get(i); - AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO) listItem.getValue(); + AdvanceAssigmentDTO advanceDTO = (AdvanceAssigmentDTO) listItem.getValue(); if(advanceDTO.getAdvanceType() == null)return false; if(advanceDTO.getMaxValue() == null)return false; + } + } + return true; + } + + private boolean validateListAdvanceMeasurement(){ + Listbox listAdvances = (Listbox) window.getFellow("editAdvancesMeasurement"); + for(int i=0; i< listAdvances.getChildren().size(); i++){ + if(listAdvances.getChildren().get(i) instanceof Listitem){ + Listitem listItem = (Listitem) listAdvances.getChildren().get(i); + AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO) listItem.getValue(); if(advanceDTO.getValue() == null)return false; if(advanceDTO.getDate() == null)return false; } @@ -429,11 +558,14 @@ public class ManageOrderElementAdvancesController extends boolean existItems = false; for(int i=0; i< listAdvances.getChildren().size(); i++){ if(listAdvances.getChildren().get(i) instanceof Listitem){ - existItems = true; Listitem listItem = (Listitem) listAdvances.getChildren().get(i); - AdvanceMeasurementDTO advanceDTO = (AdvanceMeasurementDTO) listItem.getValue(); - if(advanceDTO.getReportGlobalAdvance()) - return true; + AdvanceAssigmentDTO advanceAssigmentDTO = (AdvanceAssigmentDTO) listItem.getValue(); + if(advanceAssigmentDTO.getType().equals(AdvanceAssigment.Type.DIRECT)){ + existItems = true; + if(advanceAssigmentDTO.getReportGlobalAdvance()){ + return true; + } + } } } if(!existItems) return true; diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesModel.java index 19414ab9f..5e5878619 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/ManageOrderElementAdvancesModel.java @@ -4,15 +4,19 @@ package org.navalplanner.web.orders; import java.math.BigDecimal; import java.util.Date; import java.util.ArrayList; +import java.util.Iterator; import java.util.List; import java.util.SortedSet; +import java.util.TreeSet; import org.navalplanner.business.common.exceptions.InstanceNotFoundException; import org.apache.commons.lang.Validate; +import org.hibernate.HibernateException; import org.navalplanner.business.advance.daos.IAdvanceAssigmentDAO; import org.navalplanner.business.advance.daos.IAdvanceMeasurementDAO; import org.navalplanner.business.advance.daos.IAdvanceTypeDAO; import org.navalplanner.business.advance.entities.AdvanceAssigment; import org.navalplanner.business.advance.entities.AdvanceMeasurement; +import org.navalplanner.business.advance.entities.AdvanceMeasurementComparator; import org.navalplanner.business.advance.entities.AdvanceType; import org.navalplanner.business.orders.daos.IOrderElementDAO; import org.navalplanner.business.orders.entities.OrderElement; @@ -40,12 +44,16 @@ public class ManageOrderElementAdvancesModel implements private OrderElement orderElement; - private List advanceMeasurementDTOs; + private AdvanceAssigmentDTO advanceAssigmentDTO; + + private List advanceAssigmentDTOs; + + private List listAdvanceAssigments; + + private SortedSet listAdvanceMeasurements; private List listAdvanceTypes; - private List listAdvanceMeasurement; - @Autowired public ManageOrderElementAdvancesModel( IAdvanceMeasurementDAO advanceMeasurementDAO, @@ -59,52 +67,92 @@ public class ManageOrderElementAdvancesModel implements @Override @Transactional(readOnly = true) - public List getAdvanceMeasurements() { - if (this.orderElement == null) { + public List getAdvanceMeasurementDTOs() { + if((this.advanceAssigmentDTO == null) || + (this.orderElement == null)) { return new ArrayList(); } - return this.advanceMeasurementDTOs; + return this.advanceAssigmentDTO.getAdvanceMeasurementDTOs().toListView(); + } + + @Override + @Transactional(readOnly = true) + public List getAdvanceAssigmentDTOs(){ + if(this.orderElement == null){ + return new ArrayList(); + } + return this.advanceAssigmentDTOs; + } + + @Override + public void prepareEditAdvanceMeasurements(AdvanceAssigmentDTO advanceAssigmentDTO){ + this.advanceAssigmentDTO = advanceAssigmentDTO; } @Override @Transactional(readOnly = true) public void init(OrderElement orderElement) { this.orderElement = orderElement; + this.advanceAssigmentDTO = null; if (orderElement != null){ loadAdvanceTypes(); - reattchmentOrderElement(); - createAdvanceMeasurementDTOs(); + reattachmentOrderElement(); + createAdvanceDTOs(); } } - public void reattchmentOrderElement() { + public void reattachmentOrderElement() { orderElementDAO.save(orderElement); } - public void createAdvanceMeasurementDTOs() { - this.listAdvanceMeasurement = new ArrayList(); - this.advanceMeasurementDTOs = new ArrayList(); + public void createAdvanceDTOs() { + this.advanceAssigmentDTOs = new ArrayList(); + this.listAdvanceAssigments = new ArrayList(); + this.listAdvanceMeasurements = new TreeSet(new AdvanceMeasurementComparator()); for (AdvanceAssigment advanceAssigment : this.orderElement - .getAdvanceAssigments()) { - AdvanceMeasurement advanceMeasurement = ((SortedSet) advanceAssigment - .getAdvanceMeasurements()).last(); - AdvanceMeasurementDTO advanceDTO = new AdvanceMeasurementDTO( - advanceAssigment.getAdvanceType(), advanceAssigment, + .getAdvanceAssigments()) { + AdvanceAssigmentDTO advanceAssigmentDTO = new AdvanceAssigmentDTO( + advanceAssigment.getAdvanceType(), advanceAssigment, + advanceAssigment.getAdvanceMeasurements()); + + for (AdvanceMeasurement advanceMeasurement : advanceAssigment. + getAdvanceMeasurements()) { + AdvanceMeasurementDTO advanceMeasurementDTO = new AdvanceMeasurementDTO( advanceMeasurement); - this.listAdvanceMeasurement.add(advanceMeasurement); - this.advanceMeasurementDTOs.add(advanceDTO); + + advanceAssigmentDTO.getAdvanceMeasurementDTOs().add(advanceMeasurementDTO); + advanceMeasurementDTO.setAdvanceAssigmentDTO(advanceAssigmentDTO); + this.listAdvanceMeasurements.add(advanceMeasurement); + } + this.advanceAssigmentDTOs.add(advanceAssigmentDTO); + this.listAdvanceAssigments.add(advanceAssigment); } } @Override - public void addNewLine() { - AdvanceMeasurementDTO newAdvance = new AdvanceMeasurementDTO(); - this.advanceMeasurementDTOs.add(newAdvance); + public void addNewLineAdvaceAssigment() { + AdvanceAssigmentDTO newAdvance = new AdvanceAssigmentDTO(); + this.advanceAssigmentDTOs.add(newAdvance); } @Override - public void removeLine(AdvanceMeasurementDTO advanceDTO) { - this.advanceMeasurementDTOs.remove(advanceDTO); + public void addNewLineAdvaceMeasurement() { + if(this.advanceAssigmentDTO != null){ + AdvanceMeasurementDTO newAdvance = new AdvanceMeasurementDTO(); + newAdvance.setAdvanceAssigmentDTO(advanceAssigmentDTO); + this.advanceAssigmentDTO.getAdvanceMeasurementDTOs().add(newAdvance); + } + } + + @Override + public void removeLineAdvanceAssigment(AdvanceAssigmentDTO advanceDTO) { + this.advanceAssigmentDTOs.remove(advanceDTO); + this.advanceAssigmentDTO = null; + } + + @Override + public void removeLineAdvanceMeasurement(AdvanceMeasurementDTO advanceDTO) { + this.advanceAssigmentDTO.getAdvanceMeasurementDTOs().remove(advanceDTO); } @Override @@ -120,114 +168,571 @@ public class ManageOrderElementAdvancesModel implements this.listAdvanceTypes = this.advanceTypeDAO.findActivesAdvanceTypes(orderElement); } + @Override + public boolean isReadOnlyAdvanceMeasurementDTOs(){ + if(this.advanceAssigmentDTO == null) return true; + return this.advanceAssigmentDTO.getType().equals(AdvanceAssigment.Type.CALCULATED); + } + + @Override + public void cleanAdvance(){ + if(this.advanceAssigmentDTO != null){ + this.advanceAssigmentDTO.setReportGlobalAdvance(false); + List listAdvanceMeasurementDTOs = + this.advanceAssigmentDTO.getAdvanceMeasurementDTOs().toListView(); + for(AdvanceMeasurementDTO advanceMeasurementDTO : listAdvanceMeasurementDTOs){ + advanceMeasurementDTO.setValue(BigDecimal.ZERO); + advanceMeasurementDTO.setDate(null); + } + } + } + @Override @Transactional(readOnly = true) public void accept()throws InstanceNotFoundException, DuplicateAdvanceAssigmentForOrderElementException, DuplicateValueTrueReportGlobalAdvanceException{ orderElementDAO.checkVersion(orderElement); + reattachmentOrderElement(); validateBasicData(); } private void validateBasicData() throws InstanceNotFoundException, - DuplicateAdvanceAssigmentForOrderElementException, - DuplicateValueTrueReportGlobalAdvanceException{ - updateRemoveAdvanceMeasurement(); - for(AdvanceMeasurementDTO advanceDTO : this.advanceMeasurementDTOs){ - validateBasicData(advanceDTO); + DuplicateAdvanceAssigmentForOrderElementException, + DuplicateValueTrueReportGlobalAdvanceException{ + updateRemoveAdvances(); + for(AdvanceAssigmentDTO advanceAssigmentDTO : this.advanceAssigmentDTOs){ + validateBasicData(advanceAssigmentDTO); } } - private void updateRemoveAdvanceMeasurement(){ - for(AdvanceMeasurement advanceMeasurement : this.listAdvanceMeasurement){ - if(!yetExistAdvanceMeasurement(advanceMeasurement)){ - removeAdvanceMeasurement(advanceMeasurement); + private void updateRemoveAdvances(){ + for(AdvanceAssigment advanceAssigment : this.listAdvanceAssigments){ + AdvanceAssigmentDTO advanceAssigmentDTO = yetExistAdvanceAssigment(advanceAssigment); + if(advanceAssigmentDTO == null){ + updateRemoveCalculatedAdvanceAssigment(orderElement,advanceAssigment); + removeAdvanceAssigment(advanceAssigment); + }else{ + for(AdvanceMeasurement advanceMeasurement : this.listAdvanceMeasurements){ + if(!yetExistAdvanceMeasurement(advanceAssigmentDTO,advanceMeasurement)){ + updateRemoveCalculatedAdvanceMeasurement(orderElement, + advanceAssigment,advanceMeasurement); + removeAdvanceMeasurement(advanceMeasurement); + } + } } } } - private void validateBasicData(AdvanceMeasurementDTO advanceDTO) - throws InstanceNotFoundException,DuplicateAdvanceAssigmentForOrderElementException, + private void validateBasicData(AdvanceAssigmentDTO advanceAssigmentDTO) + throws InstanceNotFoundException,DuplicateAdvanceAssigmentForOrderElementException, DuplicateValueTrueReportGlobalAdvanceException{ - if(advanceDTO.getIsNewDTO()){ - AdvanceAssigment newAdvanceAssigment = createNewAdvance(advanceDTO); + if(advanceAssigmentDTO.getIsNewDTO()){ + AdvanceAssigment newAdvanceAssigment = createNewAdvance(advanceAssigmentDTO); + addCalculatedAdvanceAssigmentToAncestors(this.orderElement, + advanceAssigmentDTO,newAdvanceAssigment); addAdvanceAssigment(newAdvanceAssigment); }else{ - if((advanceDTO.getIsNewObject())|| - (advanceDTO.getAdvanceMeasurement().getDate().compareTo(advanceDTO.getDate()) == 0)){ - updateAdvanceMeasurement(advanceDTO); + AdvanceAssigment newAdvanceAssigment = advanceAssigmentDTO.getAdvanceAssigment(); + addCalculatedAdvanceAssigmentToAncestors(this.orderElement, + advanceAssigmentDTO,newAdvanceAssigment); + updateAdvanceAssigment(advanceAssigmentDTO); + } + } + + private void updateAdvanceAssigment(AdvanceAssigmentDTO advanceAssigmentDTO){ + //Removed the advance and add a new advanceAssigment + AdvanceAssigment advanceAssigment = advanceAssigmentDTO.getAdvanceAssigment(); + for(AdvanceMeasurementDTO advanceMeasurementDTO : + advanceAssigmentDTO.getAdvanceMeasurementDTOs().toListView()){ + if(advanceMeasurementDTO.getIsNewDTO()){ + AdvanceMeasurement newAdvanceMeasurement = + createAdvanceMeasurement(advanceMeasurementDTO); + advanceAssigment.getAdvanceMeasurements().add(newAdvanceMeasurement); }else{ - addAdvanceMeasurement(advanceDTO); + AdvanceMeasurement newAdvanceMeasurement = + createAdvanceMeasurement(advanceMeasurementDTO); + removeAdvanceMeasurement(advanceMeasurementDTO.getAdvanceMeasurement()); + advanceAssigment.getAdvanceMeasurements().add(newAdvanceMeasurement); + //updateAdvanceMeasurement(advanceMeasurementDTO); } } + //Update changes in AdvanceAssigment + advanceAssigment.setReportGlobalAdvance(advanceAssigmentDTO.getReportGlobalAdvance()); + advanceAssigment.setMaxValue(advanceAssigmentDTO.getMaxValue()); + advanceAssigment.setAdvanceType(advanceAssigmentDTO.getAdvanceType()); } - private void updateAdvanceMeasurement(AdvanceMeasurementDTO advanceDTO){ - AdvanceAssigment advanceAssigment = advanceDTO.getAdvanceAssigment(); - advanceAssigment.setReportGlobalAdvance(advanceDTO.getReportGlobalAdvance()); - AdvanceMeasurement advanceMeasurement = advanceDTO.getAdvanceMeasurement(); - advanceMeasurement.setValue(advanceDTO.getValue()); - advanceMeasurement.setMaxValue(advanceDTO.getMaxValue()); - if(advanceDTO.getIsNewObject()){ - advanceMeasurement.setDate(advanceDTO.getDate()); - advanceAssigment.setAdvanceType(advanceDTO.getAdvanceType()); - } - } - - private void addAdvanceMeasurement(AdvanceMeasurementDTO advanceDTO){ - AdvanceMeasurement newAdvanceMeasurement = AdvanceMeasurement.create(advanceDTO.getDate(), - advanceDTO.getValue(),advanceDTO.getMaxValue()); - AdvanceAssigment advanceAssigment = advanceDTO.getAdvanceAssigment(); + private AdvanceMeasurement createAdvanceMeasurement(AdvanceMeasurementDTO advanceMeasurementDTO){ + AdvanceMeasurement newAdvanceMeasurement = AdvanceMeasurement.create( + advanceMeasurementDTO.getDate(),advanceMeasurementDTO.getValue()); + AdvanceAssigment advanceAssigment = advanceMeasurementDTO.getAdvanceAssigmentDTO(). + getAdvanceAssigment(); newAdvanceMeasurement.setAdvanceAssigment(advanceAssigment); - advanceAssigment.getAdvanceMeasurements().add(newAdvanceMeasurement); + return newAdvanceMeasurement; } - private boolean yetExistAdvanceMeasurement(AdvanceMeasurement advanceMeasurement){ - for(AdvanceMeasurementDTO advanceDTO : this.advanceMeasurementDTOs){ + private void updateAdvanceMeasurement(AdvanceMeasurementDTO advanceMeasurementDTO){ + AdvanceMeasurement advanceMeasurement = advanceMeasurementDTO.getAdvanceMeasurement(); + advanceMeasurement.setValue(advanceMeasurementDTO.getValue()); + advanceMeasurement.setDate(advanceMeasurementDTO.getDate()); + } + + private AdvanceAssigmentDTO yetExistAdvanceAssigment(AdvanceAssigment advanceAssigment){ + for(AdvanceAssigmentDTO advanceDTO : this.advanceAssigmentDTOs){ if((!advanceDTO.getIsNewDTO()) && - (advanceDTO.getAdvanceMeasurement().equals(advanceMeasurement))) + (advanceDTO.getAdvanceAssigment().getId() == advanceAssigment.getId())) + return advanceDTO; + } + return null; + } + + private boolean yetExistAdvanceMeasurement(AdvanceAssigmentDTO advanceAssigmentDTO, + AdvanceMeasurement advanceMeasurement){ + for(AdvanceMeasurementDTO advanceDTO : + advanceAssigmentDTO.getAdvanceMeasurementDTOs().toListView()){ + if((!advanceDTO.getIsNewDTO()) && + (advanceDTO.getAdvanceMeasurement().getId() == advanceMeasurement.getId())) return true; } return false; } @Transactional(readOnly = true) - private AdvanceAssigment createNewAdvance(AdvanceMeasurementDTO advanceDTO) - throws InstanceNotFoundException{ - //create AdvanceMeasurement - AdvanceMeasurement newAdvanceMeasurement = AdvanceMeasurement.create(advanceDTO.getDate(), - advanceDTO.getValue(),advanceDTO.getMaxValue()); + private AdvanceAssigment createNewAdvance(AdvanceAssigmentDTO advanceAssigmentDTO) + throws InstanceNotFoundException{ + //create AdvanceAssigment + AdvanceAssigment newAdvanceAssigment = AdvanceAssigment.create( + advanceAssigmentDTO.getReportGlobalAdvance(), + advanceAssigmentDTO.getMaxValue()); + newAdvanceAssigment.setAdvanceType(advanceAssigmentDTO.getAdvanceType()); + newAdvanceAssigment.setOrderElement(this.orderElement); + newAdvanceAssigment.setType(AdvanceAssigment.Type.DIRECT); - //create AdvanceAssigment - AdvanceAssigment newAdvanceAssigment = AdvanceAssigment.create( - advanceDTO.getReportGlobalAdvance()); - newAdvanceAssigment.setAdvanceType(advanceDTO.getAdvanceType()); - newAdvanceAssigment.setOrderElement(this.orderElement); + //create AdvanceMeasurement + for(AdvanceMeasurementDTO advanceMeasurementDTO + :advanceAssigmentDTO.getAdvanceMeasurementDTOs().toListView()){ + AdvanceMeasurement newAdvanceMeasurement = AdvanceMeasurement.create( + advanceMeasurementDTO.getDate(),advanceMeasurementDTO.getValue()); //link AdvanceMeasurement to AdvanceAssigment newAdvanceMeasurement.setAdvanceAssigment(newAdvanceAssigment); newAdvanceAssigment.getAdvanceMeasurements().add(newAdvanceMeasurement); - - return newAdvanceAssigment; + } + advanceAssigmentDTO.setAdvanceAssigment(newAdvanceAssigment); + return newAdvanceAssigment; } @Transactional(readOnly = true) private void addAdvanceAssigment(AdvanceAssigment newAdvanceAssigment) throws DuplicateAdvanceAssigmentForOrderElementException, DuplicateValueTrueReportGlobalAdvanceException{ - this.orderElementDAO.save(this.orderElement); this.orderElement.addAvanceAssigment(newAdvanceAssigment); } - private void removeAdvanceMeasurement(AdvanceMeasurement advanceMeasurement){ - AdvanceAssigment advanceAssigment = advanceMeasurement.getAdvanceAssigment(); + private void removeAdvanceAssigment(AdvanceAssigment advanceAssigment){ orderElement.getAdvanceAssigments().remove(advanceAssigment); } + private void removeAdvanceMeasurement(AdvanceMeasurement advanceMeasurement){ + AdvanceAssigment advanceAssigment = advanceMeasurement.getAdvanceAssigment(); + advanceAssigment.getAdvanceMeasurements().remove(advanceMeasurement); + } + + private void updateRemoveCalculatedAdvanceAssigment(OrderElement orderElement, + AdvanceAssigment advanceAssigment){ + OrderElement parent = orderElement.getParent(); + if(parent != null){ + removeCalculatedAdvanceAssigment(parent,advanceAssigment); + updateRemoveCalculatedAdvanceAssigment(parent,advanceAssigment); + } + } + + private void updateRemoveCalculatedAdvanceMeasurement(OrderElement orderElement, + AdvanceAssigment advanceAssigment,AdvanceMeasurement advanceMeasurement){ + OrderElement parent = orderElement.getParent(); + if(parent != null){ + AdvanceAssigment indirectAdvanceAssigment = + findCalculatedAdvanceInParent(parent,advanceAssigment.getAdvanceType().getId()); + if(indirectAdvanceAssigment != null){ + removeCalculatedAdvanceMeasurement(advanceMeasurement,indirectAdvanceAssigment); + updateRemoveCalculatedAdvanceMeasurement(parent,advanceAssigment,advanceMeasurement); + } + } + } + + public void addCalculatedAdvanceAssigmentToAncestors(OrderElement orderElement, + AdvanceAssigmentDTO newAdvanceAssigmentDTO,AdvanceAssigment newAdvanceAssigment) + throws DuplicateAdvanceAssigmentForOrderElementException, + DuplicateValueTrueReportGlobalAdvanceException{ + + if (orderElement.getParent() != null) { + OrderElement parent = orderElement.getParent(); + if(checkChangeTheAdvanceType(newAdvanceAssigmentDTO)){ + removeCalculatedAdvanceAssigment(parent,newAdvanceAssigment); + } + + AdvanceAssigment indirectAdvanceAssigment = + findCalculatedAdvanceInParent(parent,newAdvanceAssigmentDTO.getAdvanceType().getId()); + if(indirectAdvanceAssigment == null){ + indirectAdvanceAssigment = initNewCalculatedAdvanceAssigment(parent,newAdvanceAssigmentDTO); + parent.addAvanceAssigment(indirectAdvanceAssigment); + } + addIncrementMaxValueToAdvanceAssigment(newAdvanceAssigmentDTO,indirectAdvanceAssigment); + addCalculatedAdvanceMeasurements(newAdvanceAssigmentDTO,indirectAdvanceAssigment); + addCalculatedAdvanceAssigmentToAncestors(parent,newAdvanceAssigmentDTO,newAdvanceAssigment); + } + } + + private void addIncrementMaxValueToAdvanceAssigment( + AdvanceAssigmentDTO newAdvanceAssigmentDTO, + AdvanceAssigment indirectAdvanceAssigment){ + BigDecimal incrementMaxValue = getIncrementMaxValue(newAdvanceAssigmentDTO); + BigDecimal currentMaxValue = indirectAdvanceAssigment.getMaxValue().add(incrementMaxValue); + indirectAdvanceAssigment.setMaxValue(currentMaxValue); + } + + private void addCalculatedAdvanceMeasurements( + AdvanceAssigmentDTO advanceAssigmentDTO, AdvanceAssigment indirectAdvanceAssigment){ + for(AdvanceMeasurementDTO advanceMeasurementDTO + :advanceAssigmentDTO.getAdvanceMeasurementDTOs().toListView()){ + if((advanceMeasurementDTO.getIsNewDTO()) + || (checkChangeTheAdvanceType(advanceAssigmentDTO))){ + addNewCalculatedAdvanceMeasurement(advanceMeasurementDTO,indirectAdvanceAssigment); + }else{ + _removeCalculatedAdvanceMeasurement(advanceMeasurementDTO,indirectAdvanceAssigment); + addNewCalculatedAdvanceMeasurement(advanceMeasurementDTO,indirectAdvanceAssigment); + } + } + } + + private void addNewCalculatedAdvanceMeasurement( + AdvanceMeasurementDTO advanceMeasurementDTO, + AdvanceAssigment indirectAdvanceAssigment){ + + AdvanceMeasurementDTO greatNeighbor = this.getGreatNeighborDTO(advanceMeasurementDTO); + AdvanceMeasurement lessNeighbor = this.getLessNeighbor(advanceMeasurementDTO); + incrementLaterCalculatedAdvances(lessNeighbor,greatNeighbor, + advanceMeasurementDTO,indirectAdvanceAssigment); + + AdvanceMeasurement previousAdvanceMeasurement = + findPreviousIndirectAdvanceMeasurement( + advanceMeasurementDTO.getDate(),indirectAdvanceAssigment); + if(previousAdvanceMeasurement == null){ + //create and add a new indirect AdvanceMeasurement + AdvanceMeasurement newIndirectAdvanceMeasurement = AdvanceMeasurement.create( + advanceMeasurementDTO.getDate(),advanceMeasurementDTO.getValue()); + newIndirectAdvanceMeasurement.setAdvanceAssigment(indirectAdvanceAssigment); + newIndirectAdvanceMeasurement.incrementNumIndirectSons(); + indirectAdvanceAssigment.getAdvanceMeasurements().add(newIndirectAdvanceMeasurement); + }else{ + if(previousAdvanceMeasurement.getDate().compareTo(advanceMeasurementDTO.getDate()) < 0){ + //create and add a new indirect AdvanceMeasurement + BigDecimal incrementValue = calculateIncrementValue(lessNeighbor,advanceMeasurementDTO); + BigDecimal currentValue = previousAdvanceMeasurement.getValue().add(incrementValue); + AdvanceMeasurement newIndirectAdvanceMeasurement = AdvanceMeasurement.create( + advanceMeasurementDTO.getDate(),currentValue); + newIndirectAdvanceMeasurement.setAdvanceAssigment(indirectAdvanceAssigment); + newIndirectAdvanceMeasurement.incrementNumIndirectSons(); + indirectAdvanceAssigment.getAdvanceMeasurements().add(newIndirectAdvanceMeasurement); + } + if(previousAdvanceMeasurement.getDate().compareTo(advanceMeasurementDTO.getDate()) == 0){ + previousAdvanceMeasurement.incrementNumIndirectSons(); + } + } + } + + private void removeCalculatedAdvanceMeasurement(AdvanceMeasurement advanceMeasurement, + AdvanceAssigment indirectAdvanceAssigment){ + //find the indirect advanceMeasurement + AdvanceMeasurement previousAdvanceMeasurement = + findPreviousIndirectAdvanceMeasurement( + advanceMeasurement.getDate(),indirectAdvanceAssigment); + //check if the indirect advanceMeasurement is the adding of several sons. + previousAdvanceMeasurement.decrementNumIndirectSons(); + if(previousAdvanceMeasurement.getNumIndirectSons() == 0){ + indirectAdvanceAssigment.getAdvanceMeasurements().remove(previousAdvanceMeasurement); + } + //update post indirect advanceMeasurement (substract the increment) + AdvanceMeasurement[] neighbors = getOldNeighborsAdvanceMeasurement(advanceMeasurement); + decrementLaterCalculatedAdvances(neighbors,advanceMeasurement,indirectAdvanceAssigment); + } + + private void _removeCalculatedAdvanceMeasurement(AdvanceMeasurementDTO advanceMeasurementDTO, + AdvanceAssigment indirectAdvanceAssigment){ + //find the indirect advanceMeasurement + AdvanceMeasurement advanceMeasurement = advanceMeasurementDTO.getAdvanceMeasurement(); + AdvanceMeasurement previousAdvanceMeasurement = + findPreviousIndirectAdvanceMeasurement( + advanceMeasurement.getDate(),indirectAdvanceAssigment); + //check if the indirect advanceMeasurement is the adding of several sons. + previousAdvanceMeasurement.decrementNumIndirectSons(); + if(previousAdvanceMeasurement.getNumIndirectSons() == 0){ + indirectAdvanceAssigment.getAdvanceMeasurements().remove(previousAdvanceMeasurement); + } + //update post indirect advanceMeasurement (substract the increment) + AdvanceMeasurement lessNeighbor = getLessNeighbor(advanceMeasurementDTO); + AdvanceMeasurementDTO greatNeighbor = getGreatNeighborDTO(advanceMeasurementDTO); + _decrementLaterCalculatedAdvances(lessNeighbor,greatNeighbor,advanceMeasurement,indirectAdvanceAssigment); + } + + private void removeCalculatedAdvanceAssigment(OrderElement parent, + AdvanceAssigment newAdvanceAssigment){ + AdvanceAssigment indirectAdvanceAssigment = + findCalculatedAdvanceInParent(parent,newAdvanceAssigment.getAdvanceType().getId()); + if(indirectAdvanceAssigment != null){ + if(decrementMaxValue(newAdvanceAssigment,indirectAdvanceAssigment)){ + parent.getAdvanceAssigments().remove(indirectAdvanceAssigment); + }else{ + for(AdvanceMeasurement advanceMeasurement : + newAdvanceAssigment.getAdvanceMeasurements()){ + removeCalculatedAdvanceMeasurement(advanceMeasurement,indirectAdvanceAssigment); + } + } + } + } + + private boolean decrementMaxValue(AdvanceAssigment newAdvanceAssigment, + AdvanceAssigment indirectAdvanceAssigment){ + BigDecimal maxValue = newAdvanceAssigment.getMaxValue(); + BigDecimal currentMaxValue = indirectAdvanceAssigment.getMaxValue().subtract(maxValue); + indirectAdvanceAssigment.setMaxValue(currentMaxValue); + if(currentMaxValue.compareTo(new BigDecimal(0)) == 0){ + return true; + } + return false; + } + + private boolean isAddingOfSeveralSons(AdvanceMeasurement previousAdvanceMeasurement){ + previousAdvanceMeasurement.decrementNumIndirectSons(); + if(previousAdvanceMeasurement.getNumIndirectSons() == 0) + return false; + else return true; + } + + private AdvanceMeasurementDTO getGreatNeighborDTO( + AdvanceMeasurementDTO advanceMeasurementDTO){ + AdvanceMeasurementDTO neighbor = null; + AdvanceAssigmentDTO advanceAssigmentDTO = + advanceMeasurementDTO.getAdvanceAssigmentDTO(); + List advanceMeasurementDTOs = + advanceAssigmentDTO.getAdvanceMeasurementDTOs().toListView(); + + for(int i=0; i < advanceMeasurementDTOs.size() ; i++){ + AdvanceMeasurementDTO advance = + (AdvanceMeasurementDTO) advanceMeasurementDTOs.get(i); + if(advance.equals(advanceMeasurementDTO)){ + if(i > 0){ + neighbor =((AdvanceMeasurementDTO) + advanceMeasurementDTOs.get(i-1)); + } + return neighbor; + } + } + return neighbor; + } + + private AdvanceMeasurement getLessNeighbor( + AdvanceMeasurementDTO advanceMeasurementDTO){ + AdvanceMeasurement neighbor = null; + + AdvanceAssigmentDTO advanceAssigmentDTO = advanceMeasurementDTO.getAdvanceAssigmentDTO(); + AdvanceAssigment advanceAssigment = advanceAssigmentDTO.getAdvanceAssigment(); + if(advanceAssigment == null) return neighbor; + + Object[] advanceMeasurements = advanceAssigment.getAdvanceMeasurements().toArray(); + for(int i=0; i < advanceMeasurements.length;i++){ + AdvanceMeasurement advance = (AdvanceMeasurement) advanceMeasurements[i]; + if(advance.getDate().compareTo(advanceMeasurementDTO.getDate()) < 0){ + neighbor=advance; + return neighbor; + } + } + return neighbor; + } + + private AdvanceMeasurement[] getOldNeighborsAdvanceMeasurement( + AdvanceMeasurement advanceMeasurement){ + AdvanceMeasurement neighbors[] = {null,null}; + AdvanceAssigment advanceAssigment = advanceMeasurement.getAdvanceAssigment(); + Object[] advanceMeasurements = advanceAssigment.getAdvanceMeasurements().toArray(); + + for(int i=0; i < advanceMeasurements.length;i++){ + AdvanceMeasurement advance = (AdvanceMeasurement) advanceMeasurements[i]; + if(advance.equals(advanceMeasurement)){ + if(i > 0){ + neighbors[1]=((AdvanceMeasurement) advanceMeasurements[i-1]); + } + if(i < advanceMeasurements.length-1){ + neighbors[0]=((AdvanceMeasurement) advanceMeasurements[i+1]); + } + return neighbors; + } + } + return neighbors; + } + + private void incrementLaterCalculatedAdvances(AdvanceMeasurement lessNeighbor, + AdvanceMeasurementDTO greatNeighbor, + AdvanceMeasurementDTO advanceMeasurementDTO, + AdvanceAssigment indirectAdvanceAssigment){ + + BigDecimal incrementValue = calculateIncrementValue(lessNeighbor,advanceMeasurementDTO); + + Date dateIni = advanceMeasurementDTO.getDate(); + Date dateFin = advanceMeasurementDTO.getDate(); + + for(AdvanceMeasurement indirectAdvanceMeasurement : + indirectAdvanceAssigment.getAdvanceMeasurements()){ + if((indirectAdvanceMeasurement.getDate().compareTo(dateIni) >= 0) + && (isIntoIntervalDateFin(greatNeighbor,dateFin,indirectAdvanceMeasurement))){ + indirectAdvanceMeasurement.setValue(indirectAdvanceMeasurement. + getValue().add(incrementValue)); + } + } + } + + private void _decrementLaterCalculatedAdvances(AdvanceMeasurement lessNeighbor, + AdvanceMeasurementDTO greatNeighbor, + AdvanceMeasurement advanceMeasurement, + AdvanceAssigment indirectAdvanceAssigment){ + + BigDecimal decrementValue = calculateDecrementValue(lessNeighbor,advanceMeasurement); + + Date dateFin = advanceMeasurement.getDate(); + Date dateIni = advanceMeasurement.getDate(); + + for(AdvanceMeasurement indirectAdvanceMeasurement : + indirectAdvanceAssigment.getAdvanceMeasurements()){ + if((indirectAdvanceMeasurement.getDate().compareTo(dateIni) >= 0) + && (isIntoIntervalDateFin(greatNeighbor,dateFin,indirectAdvanceMeasurement))){ + indirectAdvanceMeasurement.setValue( + indirectAdvanceMeasurement.getValue().subtract(decrementValue)); + } + } + } + + private void decrementLaterCalculatedAdvances(AdvanceMeasurement[] neighbors + ,AdvanceMeasurement advanceMeasurement, + AdvanceAssigment indirectAdvanceAssigment){ + + BigDecimal decrementValue = calculateDecrementValue(neighbors[0],advanceMeasurement); + + Date dateFin = advanceMeasurement.getDate(); + Date dateIni = advanceMeasurement.getDate(); + + for(AdvanceMeasurement indirectAdvanceMeasurement : + indirectAdvanceAssigment.getAdvanceMeasurements()){ + if((indirectAdvanceMeasurement.getDate().compareTo(dateIni) >= 0) + && (isIntoIntervalDateFin(neighbors[1],dateFin,indirectAdvanceMeasurement))){ + indirectAdvanceMeasurement.setValue( + indirectAdvanceMeasurement.getValue().subtract(decrementValue)); + } + } + } + + private boolean isIntoIntervalDateFin(AdvanceMeasurementDTO neighbor, + Date dateFin,AdvanceMeasurement advanceMeasurement){ + if(neighbor != null){ + dateFin = neighbor.getDate(); + if(advanceMeasurement.getDate().compareTo(dateFin) < 0) return true; + else return false; + } + return true; + } + + private boolean isIntoIntervalDateFin(AdvanceMeasurement neighbor, + Date dateFin,AdvanceMeasurement advanceMeasurement){ + if(neighbor != null){ + dateFin = neighbor.getDate(); + if(advanceMeasurement.getDate().compareTo(dateFin) < 0) return true; + else return false; + } + return true; + } + + private BigDecimal calculateIncrementValue(AdvanceMeasurement neighbor + ,AdvanceMeasurementDTO advanceMeasurementDTO){ + //Calculate the increment value + BigDecimal incrementValue = advanceMeasurementDTO.getValue(); + if(neighbor != null){ + BigDecimal previousValue = neighbor.getValue(); + incrementValue = incrementValue.subtract(previousValue); + } + return incrementValue; + } + + private BigDecimal calculateDecrementValue(AdvanceMeasurement neighbor + ,AdvanceMeasurement advanceMeasurement){ + //Calculate the decrement value + BigDecimal decrementValue = advanceMeasurement.getValue(); + if(neighbor != null){ + BigDecimal previousValue = neighbor.getValue(); + decrementValue = decrementValue.subtract(previousValue); + } + return decrementValue; + + } + + private BigDecimal getIncrementMaxValue(AdvanceAssigmentDTO advanceAssigmentDTO){ + BigDecimal incrementMaxValue= new BigDecimal(0); + if((advanceAssigmentDTO.getIsNewDTO()) + || (checkChangeTheAdvanceType(advanceAssigmentDTO))){ + incrementMaxValue = advanceAssigmentDTO.getMaxValue(); + }else{ + AdvanceAssigment advanceAssigment = advanceAssigmentDTO.getAdvanceAssigment(); + incrementMaxValue = advanceAssigmentDTO.getMaxValue().subtract(advanceAssigment.getMaxValue()); + } + return incrementMaxValue; + } + + private AdvanceAssigment initNewCalculatedAdvanceAssigment( + OrderElement orderElement,AdvanceAssigmentDTO advanceAssigmentDTO){ + //create AdvanceAssigment + AdvanceAssigment newAdvanceAssigment = AdvanceAssigment.create( + advanceAssigmentDTO.getReportGlobalAdvance(),new BigDecimal(0)); + newAdvanceAssigment.setAdvanceType(advanceAssigmentDTO.getAdvanceType()); + newAdvanceAssigment.setOrderElement(orderElement); + newAdvanceAssigment.setType(AdvanceAssigment.Type.CALCULATED); + + return newAdvanceAssigment; + } + + private AdvanceMeasurement findPreviousIndirectAdvanceMeasurement( + Date date,AdvanceAssigment indirectAdvanceAssigment){ + Object[] arrayAdvanceMeasurements = indirectAdvanceAssigment.getAdvanceMeasurements().toArray(); + for(int i=0; i < arrayAdvanceMeasurements.length; i++){ + AdvanceMeasurement advanceMeasurement = (AdvanceMeasurement)arrayAdvanceMeasurements[i]; + if(advanceMeasurement.getDate().compareTo(date) <= 0){ + return advanceMeasurement; + } + } + return null; + } + + private AdvanceAssigment findCalculatedAdvanceInParent( + OrderElement orderElement, Long id){ + for(AdvanceAssigment oldAdvanceAssigment : orderElement.getAdvanceAssigments()){ + if(oldAdvanceAssigment.getAdvanceType().getId().equals(id)) + return oldAdvanceAssigment; + } + return null; + } + + private boolean checkChangeTheAdvanceType(AdvanceAssigmentDTO newAdvanceAssigmentDTO){ + AdvanceAssigment advanceAssigment = newAdvanceAssigmentDTO.getAdvanceAssigment(); + AdvanceType advanceType = advanceAssigment.getAdvanceType(); + AdvanceType advanceTypeDTO = newAdvanceAssigmentDTO.getAdvanceType(); + if((newAdvanceAssigmentDTO.getIsNewObject()) + && (!advanceType.equals(advanceTypeDTO))) return true; + return false; + } + @Override - public boolean isPrecisionValid(AdvanceMeasurementDTO advanceDTO, BigDecimal value){ - if(advanceDTO.getAdvanceType() != null){ - BigDecimal precision = advanceDTO.getAdvanceType().getUnitPrecision(); + public boolean isPrecisionValid(BigDecimal value){ + if((this.advanceAssigmentDTO != null) + && (this.advanceAssigmentDTO.getAdvanceType() != null)){ + BigDecimal precision = this.advanceAssigmentDTO.getAdvanceType().getUnitPrecision(); BigDecimal result[] = value.divideAndRemainder(precision); if(result[1].compareTo(BigDecimal.ZERO) == 0) return true; return false; @@ -236,28 +741,63 @@ public class ManageOrderElementAdvancesModel implements } @Override - public boolean greatThanMaxValue(AdvanceMeasurementDTO advanceDTO, BigDecimal value){ - if(advanceDTO.getMaxValue() == null) + public boolean greatThanMaxValue(BigDecimal value){ + if((this.advanceAssigmentDTO == null) + ||(this.advanceAssigmentDTO.getMaxValue() == null)) return false; - if(value.compareTo(advanceDTO.getMaxValue())>0) + if(value.compareTo(this.advanceAssigmentDTO.getMaxValue())>0) return true; return false; } @Override - public boolean isGreatValidDate(AdvanceMeasurementDTO advanceDTO, Date value){ - if((advanceDTO.getIsNewDTO())||(advanceDTO.getIsNewObject())) + public boolean isGreatValidDate(Date value){ + if(this.advanceAssigmentDTO == null) return true; + if((this.advanceAssigmentDTO.getIsNewDTO())||(this.advanceAssigmentDTO.getIsNewObject())) return true; - AdvanceAssigment advanceAssigment = advanceDTO.getAdvanceAssigment(); - if(((SortedSet) advanceAssigment - .getAdvanceMeasurements()).size() > 0){ - AdvanceMeasurement advanceMeasurement = ((SortedSet) advanceAssigment - .getAdvanceMeasurements()).last(); - if(value.compareTo(advanceMeasurement.getDate()) < 0) - return false; + AdvanceAssigment advanceAssigment = this.advanceAssigmentDTO.getAdvanceAssigment(); + Iterator iterator = advanceAssigment.getAdvanceMeasurements().iterator(); + while(iterator.hasNext()){ + AdvanceMeasurement advanceMeasurement = iterator.next(); + if(advanceMeasurement.getVersion() != null){ + if(value.compareTo(advanceMeasurement.getDate()) < 0)return false; + else return true; + } } return true; } + @Override + public BigDecimal getUnitPrecision(){ + if(this.advanceAssigmentDTO == null){ + return new BigDecimal(0); + } + return this.advanceAssigmentDTO.getAdvanceType().getUnitPrecision(); + } + + @Override + public AdvanceMeasurementDTO getFirstAdvanceMeasurement(AdvanceAssigmentDTO advanceAssigmentDTO){ + if((advanceAssigmentDTO != null) && + (advanceAssigmentDTO.getAdvanceMeasurementDTOs().toListView().size()>0)){ + final AdvanceMeasurementDTO advanceMeasurementDTO = + (AdvanceMeasurementDTO) advanceAssigmentDTO.getAdvanceMeasurementDTOs().toListView().get(0); + return advanceMeasurementDTO; + } + return null; + } + + public AdvanceMeasurement getFirstAdvanceMeasurement(AdvanceAssigment advanceAssigment){ + if((advanceAssigment != null) && + (advanceAssigmentDTO.getAdvanceMeasurements().size()>0)){ + SortedSet listAM = (SortedSet) advanceAssigment.getAdvanceMeasurements(); + final AdvanceMeasurement advanceMeasurement = (AdvanceMeasurement) listAM.first(); + return advanceMeasurement; + } + return null; + } + + public void modifyListAdvanceMeasurement(AdvanceMeasurementDTO advanceMeasurementDTO){ + this.advanceAssigmentDTO.getAdvanceMeasurementDTOs().modified(advanceMeasurementDTO); + } } diff --git a/navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul b/navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul index 427ea6185..4f6c2640d 100644 --- a/navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul +++ b/navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul @@ -1,6 +1,6 @@ - + diff --git a/navalplanner-webapp/src/main/webapp/orders/_listOrderElementAdvances.zul b/navalplanner-webapp/src/main/webapp/orders/_listOrderElementAdvances.zul index 91f86fbea..67949e499 100644 --- a/navalplanner-webapp/src/main/webapp/orders/_listOrderElementAdvances.zul +++ b/navalplanner-webapp/src/main/webapp/orders/_listOrderElementAdvances.zul @@ -1,29 +1,74 @@ - +