From ed100d903c021422028d75da1684c6792944aceb Mon Sep 17 00:00:00 2001 From: Susana Montes Pedreira Date: Mon, 16 Nov 2009 13:11:33 +0100 Subject: [PATCH] ItEr34S07CUObtencionRequisitosEnProxectoTraballoItEr33S07 : Assign HoursGroup to OrderElements and assign criterion requirements to HoursGroups. --- .../entities/CriterionRequirementHandler.java | 4 + .../business/orders/entities/HoursGroup.java | 29 +- .../business/orders/entities/OrderLine.java | 1 + .../orders/entities/OrderLineGroup.java | 1 - .../business/orders/entities/Orders.hbm.xml | 2 +- ...onRequirementToOrderElementController.java | 205 ++++++++++++- ...iterionRequirementToOrderElementModel.java | 218 +++++++++++++- .../orders/CriterionRequirementWrapper.java | 64 +++- .../web/orders/HoursGroupWrapper.java | 274 ++++++++++++++++++ ...iterionRequirementToOrderElementModel.java | 27 ++ .../_listHoursGroupCriterionRequirement.zul | 91 ++++++ ..._listOrderElementCriterionRequirements.zul | 61 +++- .../listHoursGroupCriterionRequirement.zul | 34 +++ 13 files changed, 962 insertions(+), 49 deletions(-) create mode 100644 navalplanner-webapp/src/main/java/org/navalplanner/web/orders/HoursGroupWrapper.java create mode 100644 navalplanner-webapp/src/main/webapp/orders/_listHoursGroupCriterionRequirement.zul create mode 100644 navalplanner-webapp/src/main/webapp/planner/listHoursGroupCriterionRequirement.zul diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java index 2ee31c708..04ffc7986 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java @@ -319,18 +319,22 @@ public class CriterionRequirementHandler implements IndirectCriterionRequirement getCurrentIndirectRequirement( Set oldIndirects, CriterionRequirement requirement) { + IndirectCriterionRequirement indirect; DirectCriterionRequirement parent; + boolean valid = true; if (requirement instanceof DirectCriterionRequirement) { parent = (DirectCriterionRequirement) requirement; indirect = findIndirectRequirementByParent(oldIndirects, parent); } else { parent = ((IndirectCriterionRequirement) requirement).getParent(); indirect = findIndirectRequirementByParent(oldIndirects, parent); + valid = ((IndirectCriterionRequirement) requirement).isIsValid(); } if (indirect == null) { indirect = IndirectCriterionRequirement.create(parent, requirement .getCriterion()); + indirect.setIsValid(valid); } return (IndirectCriterionRequirement) indirect; } 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 50661534e..74c86ef71 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 @@ -89,12 +89,8 @@ public class HoursGroup extends BaseEntity implements Cloneable { */ public void setPercentage(BigDecimal proportion) throws IllegalArgumentException { - BigDecimal oldPercentage = this.percentage; - - this.percentage = proportion; - - if (!parentOrderLine.isPercentageValid()) { - this.percentage = oldPercentage; + if (proportion.compareTo(new BigDecimal(1).setScale(2)) > 0) { + this.percentage = new BigDecimal(0).setScale(2); throw new IllegalArgumentException( "Total percentage should be less than 100%"); } @@ -141,7 +137,7 @@ public class HoursGroup extends BaseEntity implements Cloneable { } } - private boolean canAddCriterionRequirement( + public boolean canAddCriterionRequirement( CriterionRequirement newRequirement) { for (CriterionRequirement requirement : criterionRequirements) { if (requirement.getCriterion() @@ -153,9 +149,8 @@ public class HoursGroup extends BaseEntity implements Cloneable { } /* TO REMOVE */ - public void removeDirectCriterionRequirement(Criterion criterion){ - CriterionRequirement oldCriterionRequirement = - getDirectCriterionRequirementByCriterion(criterion); + public void removeDirectCriterionRequirement(Criterion criterion) { + CriterionRequirement oldCriterionRequirement = getDirectCriterionRequirementByCriterion(criterion); if (oldCriterionRequirement != null) { removeCriterionRequirement(oldCriterionRequirement); } @@ -173,23 +168,23 @@ public class HoursGroup extends BaseEntity implements Cloneable { requirement.setOrderElement(null); } - /* TO REMOVE */ + // /* TO REMOVE */ public CriterionRequirement getDirectCriterionRequirementByCriterion( Criterion criterion) { for (CriterionRequirement requirement : getDirectCriterionRequirement()) { - Criterion oldCriterion = requirement.getCriterion(); + Criterion oldCriterion = requirement.getCriterion(); if ((oldCriterion != null) && (criterion.getId().equals(oldCriterion.getId()))) { - return requirement; - } + return requirement; + } } return null; } /* TO REMOVE */ public void addDirectRequirementCriterion(Criterion criterion) { - CriterionRequirement newCriterionRequirement = - DirectCriterionRequirement.create(criterion); + CriterionRequirement newCriterionRequirement = DirectCriterionRequirement + .create(criterion); addCriterionRequirement(newCriterionRequirement); } @@ -219,7 +214,7 @@ public class HoursGroup extends BaseEntity implements Cloneable { criterionRequirementHandler.addNewsIndirects(this, currentIndirects); } - Set getIndirectCriterionRequirement() { + public Set getIndirectCriterionRequirement() { Set list = new HashSet(); for(CriterionRequirement criterionRequirement : criterionRequirements ){ if(criterionRequirement instanceof IndirectCriterionRequirement){ 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 8c28e4839..236cdd363 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 @@ -116,6 +116,7 @@ public class OrderLine extends OrderElement { public void addHoursGroup(HoursGroup hoursGroup) { hoursGroup.setParentOrderLine(this); + hoursGroup.updateMyCriterionRequirements(); hoursGroups.add(hoursGroup); recalculateHoursGroups(); hoursGroupAdded(hoursGroup); diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java index 3ad3f1ac5..37799758b 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java @@ -102,7 +102,6 @@ public class OrderLineGroup extends OrderElement implements IOrderLineGroup { @Override public void add(OrderElement orderElement) { getManipulator().add(orderElement); - addIndirectAdvanceAssignments(orderElement); } 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 e225574ae..786a0c50c 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 @@ -89,7 +89,7 @@ - + diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementController.java index 54046e0e7..c4c3deb45 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementController.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementController.java @@ -22,9 +22,12 @@ package org.navalplanner.web.orders; import static org.navalplanner.web.I18nHelper._; +import java.math.BigDecimal; import java.util.List; +import org.navalplanner.business.orders.entities.HoursGroup; import org.navalplanner.business.orders.entities.OrderElement; +import org.navalplanner.business.orders.entities.OrderLine; import org.navalplanner.business.resources.entities.CriterionWithItsType; import org.navalplanner.business.workreports.entities.WorkReportLine; import org.navalplanner.web.common.IMessagesForUser; @@ -35,8 +38,13 @@ import org.zkoss.zk.ui.Component; import org.zkoss.zk.ui.WrongValueException; import org.zkoss.zk.ui.util.GenericForwardComposer; import org.zkoss.zul.Bandbox; +import org.zkoss.zul.Constraint; +import org.zkoss.zul.Detail; +import org.zkoss.zul.Grid; import org.zkoss.zul.Hbox; import org.zkoss.zul.Listitem; +import org.zkoss.zul.Messagebox; +import org.zkoss.zul.Panel; import org.zkoss.zul.Row; import org.zkoss.zul.Rows; import org.zkoss.zul.Vbox; @@ -53,18 +61,24 @@ public class AssignedCriterionRequirementToOrderElementController extends private Vbox vbox; + private Vbox containerHoursGroup; + private NewDataSortableGrid listingRequirements; + private Grid listHoursGroups; + private IMessagesForUser messages; private Component messagesContainer; + private Detail detail; + @Override public void doAfterCompose(Component comp) throws Exception { super.doAfterCompose(comp); - if (messagesContainer == null) + if (containerHoursGroup == null) throw new RuntimeException(_("MessagesContainer is needed")); - messages = new MessagesForUser(messagesContainer); + messages = new MessagesForUser(containerHoursGroup); comp.setVariable("assignedCriterionRequirementController", this, true); vbox = (Vbox) comp; } @@ -139,15 +153,10 @@ setValidCriterionRequirementWrapper(requirement, true); if (!assignedCriterionRequirementToOrderElementModel .canSetCriterionWithItsType(criterionRequirementWrapper, criterionAndType)) { - bandbox.setValue(""); criterionRequirementWrapper.setCriterionWithItsType(null); - throw new WrongValueException( - bandbox, - _("The criterion " - + criterionAndType.getNameAndType() - + " is not valid," - + " exist the same criterion into the order element or into its children.")); + showInvalidConstraint(bandbox, criterionAndType); } + Util.reloadBindings(listHoursGroups); }else{ bandbox.setValue(""); } @@ -155,6 +164,7 @@ setValidCriterionRequirementWrapper(requirement, true); private void reload() { Util.reloadBindings(listingRequirements); + Util.reloadBindings(listHoursGroups); } private boolean showInvalidValues() { @@ -176,10 +186,9 @@ setValidCriterionRequirementWrapper(requirement, true); if(listingRequirements != null){ // Find which listItem contains CriterionSatisfaction inside listBox Row row = findRowOfCriterionRequirementWrapper(listingRequirements - .getRows(), - requirementWrapper); + .getRows(), requirementWrapper); if (row != null) { - Bandbox bandType = getBandType(row); + Bandbox bandType = getBandType(requirementWrapper, row); bandType.setValue(null); throw new WrongValueException(bandType, _("The criterion and its type cannot be null")); @@ -193,6 +202,7 @@ setValidCriterionRequirementWrapper(requirement, true); * @param CriterionRequirementWrapper * @return */ + private Row findRowOfCriterionRequirementWrapper(Rows rows, CriterionRequirementWrapper requirementWrapper) { List listRows = (List) rows.getChildren(); @@ -210,8 +220,177 @@ setValidCriterionRequirementWrapper(requirement, true); * @param row * @return Bandbox */ - private Bandbox getBandType(Row row) { + private Bandbox getBandType(CriterionRequirementWrapper wrapper, Row row) { + if (wrapper.isNewException()) { + return (Bandbox) ((Hbox) row.getChildren().get(0)).getChildren() + .get(1); + } return (Bandbox)((Hbox) row.getChildren().get(0)) .getChildren().get(0); } + + private Rows getRequirementRows(Row row) { + Panel panel = (Panel) row.getFirstChild().getFirstChild(); + NewDataSortableGrid grid = (NewDataSortableGrid) panel.getFirstChild() + .getFirstChild(); + return grid.getRows(); + } + + private HoursGroupWrapper getHoursGroupOfRequirementWrapper( + Row rowRequirement) { + NewDataSortableGrid grid = (NewDataSortableGrid) rowRequirement + .getParent().getParent(); + Panel panel = (Panel) grid.getParent().getParent(); + return (HoursGroupWrapper) ((Row) panel.getParent().getParent()) + .getValue(); + } + /* + * Operations to manage OrderElement's hoursGroups and to assign criterion + * requirements to this hoursGroups. + */ + + public boolean isReadOnly() { + return !isEditableHoursGroup(); + } + + public boolean isEditableHoursGroup() { + if (getOrderElement() != null) { + if (getOrderElement() instanceof OrderLine) + return true; + } + return false; + } + + public List getHoursGroupWrappers() { + return assignedCriterionRequirementToOrderElementModel + .getHoursGroupsWrappers(); + } + + /** + * Adds a new {@link HoursGroup} to the current {@link OrderElement} The + * {@link OrderElement} should be a {@link OrderLine} + */ + public void addHoursGroup() { + assignedCriterionRequirementToOrderElementModel + .addNewHoursGroupWrapper(); + Util.reloadBindings(listHoursGroups); + } + + /** + * Deletes the selected {@link HoursGroup} for the current + * {@link OrderElement} The {@link OrderElement} should be a + * {@link OrderLine} + */ + public void deleteHoursGroups(Component self) throws InterruptedException { + if (getHoursGroupWrappers().size() < 2) { + Messagebox.show(_("At least one HoursGroup is needed"), _("Error"), Messagebox.OK, + Messagebox.ERROR); + return; + }else{ + HoursGroupWrapper hoursGroupWrapper = getHoursGroupWrapper(self); + if (hoursGroupWrapper != null) { + assignedCriterionRequirementToOrderElementModel + .deleteHoursGroupWrapper(hoursGroupWrapper); + Util.reloadBindings(listHoursGroups); + } + } + } + + public void addCriterionToHoursGroup(Component self) { + HoursGroupWrapper hoursGroupWrapper = getHoursGroupWrapper(self); + if (hoursGroupWrapper != null) { + assignedCriterionRequirementToOrderElementModel + .addCriterionToHoursGroupWrapper(hoursGroupWrapper); + Util.reloadBindings(listHoursGroups); + } + } + + public void addExceptionToHoursGroups(Component self) { + HoursGroupWrapper hoursGroupWrapper = getHoursGroupWrapper(self); + if (hoursGroupWrapper != null) { + assignedCriterionRequirementToOrderElementModel + .addExceptionToHoursGroupWrapper(hoursGroupWrapper); + Util.reloadBindings(listHoursGroups); + } + } + + public void removeCriterionToHoursGroup(Component self){ + try { + System.out.println("remove in Controller"); + Row row = (Row) self.getParent().getParent(); + CriterionRequirementWrapper requirementWrapper = (CriterionRequirementWrapper) row.getValue(); + HoursGroupWrapper hoursGroupWrapper = getHoursGroupOfRequirementWrapper(row); + + assignedCriterionRequirementToOrderElementModel + .deleteCriterionToHoursGroup(hoursGroupWrapper, + requirementWrapper); + Util.reloadBindings(listHoursGroups); + } catch (Exception e) { + } + } + + public void selectCriterionToHoursGroup(Listitem item, Bandbox bandbox, + CriterionRequirementWrapper requirementWrapper) { + if (item != null) { + + Row row = (Row) bandbox.getParent().getParent(); + CriterionWithItsType criterionAndType = (CriterionWithItsType) item + .getValue(); + HoursGroupWrapper hoursGroupWrapper = getHoursGroupOfRequirementWrapper(row); + + bandbox.close(); + bandbox.setValue(criterionAndType.getNameAndType()); + + if (!assignedCriterionRequirementToOrderElementModel + .selectCriterionToHoursGroup(hoursGroupWrapper, + requirementWrapper, criterionAndType)) { + requirementWrapper.setCriterionWithItsType(null); + showInvalidConstraint(bandbox, criterionAndType); + } + Util.reloadBindings(listHoursGroups); + } else { + bandbox.setValue(""); + } + } + + private void showInvalidConstraint(Bandbox bandbox, + CriterionWithItsType criterionAndType) { + bandbox.setValue(""); + throw new WrongValueException( + bandbox, + _("The criterion " + + criterionAndType.getNameAndType() + + " is not valid," + + " exist the same criterion into the order element or into its children.")); + } + + private HoursGroupWrapper getHoursGroupWrapper(Component self) { + try { + return ((HoursGroupWrapper) (((Row) (self.getParent().getParent())) + .getValue())); + } catch (Exception e) { + return null; + } + } + + /* + * Operations to manage the data hoursGroup, for example validate the + * percentage and its number of hours or set the fixed percentage + */ + + public Constraint validatePercentage() { + return new Constraint() { + @Override + public void validate(Component comp, Object value) + throws WrongValueException { + HoursGroupWrapper hoursGroupWrapper = (HoursGroupWrapper) ((Row) comp + .getParent()).getValue(); + hoursGroupWrapper.setPercentage((BigDecimal) value); + if (!assignedCriterionRequirementToOrderElementModel.isPercentageValid()) { + throw new WrongValueException( + comp,_("Total percentage should be less than 100%")); + } + } + }; + } } \ No newline at end of file diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementModel.java index 3907cb93f..2ec2388b8 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementModel.java @@ -20,6 +20,7 @@ package org.navalplanner.web.orders; +import java.math.BigDecimal; import java.util.ArrayList; import java.util.List; import java.util.Map; @@ -32,6 +33,7 @@ import org.navalplanner.business.orders.entities.OrderElement; import org.navalplanner.business.orders.entities.OrderLine; import org.navalplanner.business.requirements.entities.CriterionRequirement; import org.navalplanner.business.requirements.entities.DirectCriterionRequirement; +import org.navalplanner.business.requirements.entities.IndirectCriterionRequirement; import org.navalplanner.business.resources.entities.Criterion; import org.navalplanner.business.resources.entities.CriterionType; import org.navalplanner.business.resources.entities.CriterionWithItsType; @@ -63,6 +65,8 @@ public class AssignedCriterionRequirementToOrderElementModel implements private List criterionRequirementWrappers = new ArrayList(); + private List hoursGroupsWrappers = new ArrayList(); + @Override public OrderElement getOrderElement() { return orderElement; @@ -81,6 +85,7 @@ public class AssignedCriterionRequirementToOrderElementModel implements reattachOrderElement(); initializeWrappers(); initializeCriterionWithItsType(); + initializeHoursGroupWrappers(); } } @@ -148,14 +153,19 @@ public class AssignedCriterionRequirementToOrderElementModel implements @Transactional(readOnly = true) public void assignCriterionRequirementWrapper() { if((orderModel != null) && (orderElement != null)){ - CriterionRequirement newRequirement = DirectCriterionRequirement - .create(); - CriterionRequirementWrapper requirement = new CriterionRequirementWrapper( - newRequirement, true); - criterionRequirementWrappers.add(requirement); + CriterionRequirementWrapper newRequirementWrapper = createCriterionRequirementWreapper(); + criterionRequirementWrappers.add(newRequirementWrapper); } } + private CriterionRequirementWrapper createCriterionRequirementWreapper() { + CriterionRequirement newRequirement = DirectCriterionRequirement + .create(); + CriterionRequirementWrapper newRequirementWrapper = new CriterionRequirementWrapper( + newRequirement, true); + return newRequirementWrapper; + } + public boolean canSetCriterionWithItsType( CriterionRequirementWrapper requirementWrapper, CriterionWithItsType criterionAndType) { @@ -206,6 +216,13 @@ public class AssignedCriterionRequirementToOrderElementModel implements public void setValidCriterionRequirementWrapper( CriterionRequirementWrapper requirementWrapper, boolean valid) { requirementWrapper.setValid(valid); + IndirectCriterionRequirement requirement = (IndirectCriterionRequirement) requirementWrapper + .getCriterionRequirement(); + getOrderElement().setValidCriterionRequirement(requirement, valid); + if (requirementWrapper.getCriterionWithItsType() != null) { + updateExceptionInHoursGroups(requirementWrapper + .getCriterionWithItsType(), valid); + } } public CriterionRequirementWrapper validateWrappers() { @@ -216,4 +233,195 @@ public class AssignedCriterionRequirementToOrderElementModel implements } return null; } + + + /* + * Operations to manage the hours groups (add new hours group, delete a + * hours group , edit a hours group ), and assign criterions requirements to + * the hoursGroup + */ + + private OrderLine asOrderLine() { + if (getOrderElement() instanceof OrderLine) { + return (OrderLine) getOrderElement(); + } else { + return new OrderLine(); + } + } + + private void initializeHoursGroupWrappers() { + hoursGroupsWrappers = new ArrayList(); + for (HoursGroup hoursGroup : orderElement.getHoursGroups()) { + addNewHoursGroupWrapper(hoursGroup); + } + } + + public void addNewHoursGroupWrapper() { + if ((orderModel != null) && (getOrderElement() != null)) { + HoursGroup newHoursGroup = createNewHoursGroup(); + addNewHoursGroupWrapper(newHoursGroup); + } + } + + private void addNewHoursGroupWrapper(HoursGroup newHoursGroup) { + HoursGroupWrapper newHoursGroupWrapper = new HoursGroupWrapper( + newHoursGroup, getOrderElement()); + hoursGroupsWrappers.add(newHoursGroupWrapper); + } + + private HoursGroup createNewHoursGroup() { + HoursGroup newHoursGroup = HoursGroup +.create(asOrderLine()); + (asOrderLine()).addHoursGroup(newHoursGroup); + return newHoursGroup; + } + + public List getHoursGroupsWrappers() { + if ((orderModel != null) && (getOrderElement() != null)) { + return hoursGroupsWrappers; + } + return new ArrayList(); + } + + public void deleteHoursGroupWrapper(HoursGroupWrapper hoursGroupWrapper) { + HoursGroup hoursGroup = hoursGroupWrapper.getHoursGroup(); + asOrderLine().deleteHoursGroup(hoursGroup); + hoursGroupsWrappers.remove(hoursGroupWrapper); + } + + /* + * Operation to manage the criterion Requirements for the hoursGroups. The + * operations is add new direct criterion requirement, delete criterion + * requirement, add new Exception and delete Exception + */ + public void addCriterionToHoursGroupWrapper( + HoursGroupWrapper hoursGroupWrapper) { + if ((orderModel != null) && (orderElement != null)) { + CriterionRequirementWrapper requirement = createCriterionRequirementWreapper(); + hoursGroupWrapper.assignCriterionRequirementWrapper(requirement); + } + } + + public boolean selectCriterionToHoursGroup(HoursGroupWrapper hoursGroupWrapper, + CriterionRequirementWrapper requirementWrapper, + CriterionWithItsType criterionAndType){ + if (requirementWrapper.isDirect()) { + return selectCriterionToDirectRequirementWrapper(hoursGroupWrapper, + requirementWrapper, criterionAndType); + } else { + return selectCriterionToExceptionRequirementWrapper( + hoursGroupWrapper, requirementWrapper, criterionAndType); + } + } + + private boolean selectCriterionToDirectRequirementWrapper( + HoursGroupWrapper hoursGroupWrapper, + CriterionRequirementWrapper direct, + CriterionWithItsType criterionAndType) { + direct.setCriterionWithItsType(criterionAndType); + if (hoursGroupWrapper.canSelectCriterion(direct)) { + hoursGroupWrapper.selectCriterionToDirectRequirementWrapper(direct); + return true; + } + return false; + } + + public CriterionRequirementWrapper addExceptionToHoursGroupWrapper( + HoursGroupWrapper hoursGroupWrapper) { + if ((orderModel != null) && (orderElement != null)) { + CriterionRequirementWrapper exceptionWrapper = new CriterionRequirementWrapper( + CriterionRequirementWrapper.INDIRECT); + exceptionWrapper.setNewException(true); + hoursGroupWrapper.addExceptionRequirementWrappers(exceptionWrapper); + return exceptionWrapper; + } + return null; + } + + private boolean selectCriterionToExceptionRequirementWrapper( + HoursGroupWrapper hoursGroupWrapper, + CriterionRequirementWrapper exception, + CriterionWithItsType criterionAndType) { + hoursGroupWrapper +.selectCriterionToExceptionRequirementWrapper( + exception, criterionAndType); + return true; + } + + public void deleteCriterionToHoursGroup( + HoursGroupWrapper hoursGroupWrapper, + CriterionRequirementWrapper requirementWrapper) { + if (requirementWrapper.isDirect()) { + deleteDirectToHoursGroup(hoursGroupWrapper, requirementWrapper); + } else { + deleteExceptionToHoursGroup(hoursGroupWrapper, requirementWrapper); + } + } + + private void deleteDirectToHoursGroup(HoursGroupWrapper hoursGroupWrapper, + CriterionRequirementWrapper direct) { + hoursGroupWrapper.removeDirectCriterionRequirementWrapper(direct); + } + + private void deleteExceptionToHoursGroup( + HoursGroupWrapper hoursGroupWrapper, + CriterionRequirementWrapper exception) { + hoursGroupWrapper.removeExceptionCriterionRequirementWrapper(exception); + } + + private void updateExceptionInHoursGroups( + CriterionWithItsType criterionAndType, boolean valid) { + Criterion criterion = criterionAndType.getCriterion(); + for (HoursGroupWrapper hoursGroupWrapper : hoursGroupsWrappers) { + CriterionRequirementWrapper exception = findExceptionByCriterion( + hoursGroupWrapper, criterion); + if ((exception == null) && (!valid)) { + addOldException(hoursGroupWrapper, criterionAndType); + } + if ((exception != null) && (valid)) { + hoursGroupWrapper + .removeExceptionCriterionRequirementWrapper(exception); + } + } + } + + private CriterionRequirementWrapper findExceptionByCriterion( + HoursGroupWrapper hoursGroupWrapper, + Criterion criterion) { + for (CriterionRequirementWrapper requirement : hoursGroupWrapper + .getExceptionRequirementWrappers()) { + if ((requirement.getCriterionWithItsType() != null) + && (requirement.getCriterionWithItsType().getCriterion() + .equals(criterion))) { + return requirement; + } + } + return null; + } + + private void addOldException(HoursGroupWrapper hoursGroupWrapper, + CriterionWithItsType criterionAndType) { + CriterionRequirementWrapper exception = addExceptionToHoursGroupWrapper(hoursGroupWrapper); + exception.setNewException(false); + exception.setCriterionWithItsType(criterionAndType); + exception.setValid(false); + } + + /* Operations to control the data hoursGroup */ + public boolean isPercentageValid() { + BigDecimal newPercentage = new BigDecimal(0).setScale(2); + for (HoursGroupWrapper hoursGroupWrapper : hoursGroupsWrappers) { + if (hoursGroupWrapper.getFixedPercentage()) { + BigDecimal percentage = hoursGroupWrapper.getPercentage(); + percentage = percentage.divide(new BigDecimal(100), + BigDecimal.ROUND_DOWN); + newPercentage = newPercentage.add(percentage); + } + } + if (newPercentage.compareTo(new BigDecimal(1).setScale(2)) > 0) { + return false; + } + return true; + } + } \ No newline at end of file diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/CriterionRequirementWrapper.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/CriterionRequirementWrapper.java index 65358abe8..13c5b5e30 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/CriterionRequirementWrapper.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/CriterionRequirementWrapper.java @@ -21,9 +21,9 @@ import org.navalplanner.business.resources.entities.CriterionWithItsType; */ public class CriterionRequirementWrapper implements INewObject { - private static final String DIRECT = _("Direct"); + public static final String DIRECT = _("Direct"); - private static final String INDIRECT = _("Indirect"); + public static final String INDIRECT = _("Indirect"); private String type; @@ -35,12 +35,19 @@ public class CriterionRequirementWrapper implements INewObject { private Boolean valid = true; + private Boolean newException = false; + private CriterionWithItsType criterionWithItsType; + public CriterionRequirementWrapper(String type) { + this.newObject = true; + this.type = type; + } + public CriterionRequirementWrapper(CriterionRequirement criterionRequirement, boolean isNewObject) { this.criterionAndType = ""; - this.setCriterionRequirement(criterionRequirement); + this.criterionRequirement = criterionRequirement; this.initType(criterionRequirement); this.initValid(criterionRequirement); this.setNewObject(isNewObject); @@ -58,11 +65,13 @@ public class CriterionRequirementWrapper implements INewObject { public void setCriterionWithItsType(CriterionWithItsType criterionWithItsType) { this.criterionWithItsType = criterionWithItsType; - if (criterionWithItsType != null) { - criterionRequirement.setCriterion(criterionWithItsType + if (criterionRequirement != null) { + if (criterionWithItsType != null) { + criterionRequirement.setCriterion(criterionWithItsType .getCriterion()); - } else { - criterionRequirement.setCriterion(null); + } else { + criterionRequirement.setCriterion(null); + } } } @@ -90,6 +99,7 @@ public class CriterionRequirementWrapper implements INewObject { public void setCriterionRequirement(CriterionRequirement criterionRequirement) { this.criterionRequirement = criterionRequirement; + this.initValid(criterionRequirement); } public CriterionRequirement getCriterionRequirement() { @@ -105,13 +115,20 @@ public class CriterionRequirementWrapper implements INewObject { } private void initType(CriterionRequirement criterionRequirement) { - if(criterionRequirement instanceof DirectCriterionRequirement){ + if (criterionRequirement instanceof DirectCriterionRequirement) { type = DIRECT; - }else if(criterionRequirement instanceof IndirectCriterionRequirement){ + } else if (criterionRequirement instanceof IndirectCriterionRequirement) { type = INDIRECT; } } + public String getTypeToHoursGroup() { + if (isDirect()) { + return type; + } + return "Exception " + type; + } + public boolean isDirect(){ return (type.equals(DIRECT)) ? true : false; } @@ -126,7 +143,11 @@ public class CriterionRequirementWrapper implements INewObject { public void setValid(Boolean valid) { this.valid = valid; - ((IndirectCriterionRequirement) criterionRequirement).setIsValid(valid); + if ((criterionRequirement != null) + && (criterionRequirement instanceof IndirectCriterionRequirement)) { + ((IndirectCriterionRequirement) criterionRequirement) + .setIsValid(valid); + } } private void initValid(CriterionRequirement requirement) { @@ -137,6 +158,11 @@ public class CriterionRequirementWrapper implements INewObject { } public boolean isValid() { + if ((criterionRequirement != null) + && (criterionRequirement instanceof IndirectCriterionRequirement)) { + return ((IndirectCriterionRequirement) criterionRequirement) + .isIsValid(); + } return valid == null ? false : valid; } @@ -156,7 +182,23 @@ public class CriterionRequirementWrapper implements INewObject { return isNewObject(); } - public boolean isUnmodifiable(){ + public boolean isUnmodifiable() { return !isUpdatable(); } + + public boolean isNewDirect() { + return (isNewObject() && isDirect()); + } + + public void setNewException(boolean newException) { + this.newException = newException; + } + + public boolean isNewException() { + return newException; + } + + public boolean isOldDirectOrException() { + return (!isNewDirect() && !isNewException()); + } } \ No newline at end of file diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/HoursGroupWrapper.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/HoursGroupWrapper.java new file mode 100644 index 000000000..34d0a042a --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/HoursGroupWrapper.java @@ -0,0 +1,274 @@ +/* + * This file is part of ###PROJECT_NAME### + * + * Copyright (C) 2009 Fundación para o Fomento da Calidade Industrial e + * Desenvolvemento Tecnolóxico de Galicia + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package org.navalplanner.web.orders; + +import java.math.BigDecimal; +import java.util.ArrayList; +import java.util.List; + +import org.hibernate.validator.NotNull; +import org.navalplanner.business.INewObject; +import org.navalplanner.business.orders.entities.HoursGroup; +import org.navalplanner.business.orders.entities.OrderElement; +import org.navalplanner.business.orders.entities.OrderLineGroup; +import org.navalplanner.business.requirements.entities.CriterionRequirement; +import org.navalplanner.business.requirements.entities.IndirectCriterionRequirement; +import org.navalplanner.business.resources.entities.Criterion; +import org.navalplanner.business.resources.entities.CriterionType; +import org.navalplanner.business.resources.entities.CriterionWithItsType; + +/** + * Wrapper represents the handled data in the form of assigning criterion + * requirement. + * @author Susana Montes Pedreira + */ +public class HoursGroupWrapper implements INewObject { + + private Boolean newObject = false; + + private List directRequirementWrappers = new ArrayList(); + + private List exceptionRequirementWrappers = new ArrayList(); + + @NotNull + private Integer workingHours = 0; + + private BigDecimal percentage = new BigDecimal(0).setScale(2); + + private Boolean fixedPercentage = false; + + private OrderElement orderElement; + + private HoursGroup hoursGroup; + + public HoursGroupWrapper(HoursGroup hoursGroup, OrderElement orderElement) { + this.workingHours = hoursGroup.getWorkingHours(); + this.percentage = hoursGroup.getPercentage(); + this.fixedPercentage = hoursGroup.isFixedPercentage(); + this.orderElement = orderElement; + this.hoursGroup = hoursGroup; + initRequirementWrappers(hoursGroup); + } + + // public HoursGroupWrapper(OrderElement orderElement, + // List list) { + // this.orderElement = orderElement; + // this.newObject = true; + // initRequirementWrappers(list); + // initExceptions(); + // } + + private void initRequirementWrappers(HoursGroup hoursGroup) { + directRequirementWrappers = new ArrayList(); + for (CriterionRequirement requirement : hoursGroup + .getDirectCriterionRequirement()) { + CriterionRequirementWrapper wrapper = new CriterionRequirementWrapper( + requirement, false); + directRequirementWrappers.add(wrapper); + } + + exceptionRequirementWrappers = new ArrayList(); + for (CriterionRequirement requirement : getInvalidIndirectCriterionRequirement()) { + CriterionRequirementWrapper wrapper = new CriterionRequirementWrapper( + requirement, false); + exceptionRequirementWrappers.add(wrapper); + } + } + + public void setNewObject(Boolean isNewObject) { + this.newObject = isNewObject; + } + + public boolean isOldObject() { + return !isNewObject(); + } + + @Override + public boolean isNewObject() { + return newObject == null ? false : newObject; + } + + public List getDirectRequirementWrappers() { + return directRequirementWrappers; + } + + public List getExceptionRequirementWrappers() { + return exceptionRequirementWrappers; + } + + public Integer getWorkingHours() { + return workingHours; + } + + public void setWorkingHours(Integer workingHours) { + this.workingHours = workingHours; + } + + public BigDecimal getPercentage() { + if (orderElement instanceof OrderLineGroup) { + return getPercentageInOrderLineGroup(); + } + return percentage.scaleByPowerOfTen(2); + } + + private BigDecimal getPercentageInOrderLineGroup() { + BigDecimal workingHours = new BigDecimal(hoursGroup.getWorkingHours()) + .setScale(2); + BigDecimal total = new BigDecimal(orderElement.getWorkHours()) + .setScale(2); + if (total.equals(new BigDecimal(0).setScale(2))) { + return new BigDecimal(0).setScale(2); + } + return workingHours.divide(total, BigDecimal.ROUND_DOWN) + .scaleByPowerOfTen(2); + } + + public void setPercentage(BigDecimal percentage) { + if (percentage != null) { + this.percentage = percentage.divide(new BigDecimal(100), + BigDecimal.ROUND_DOWN); + } else { + this.percentage = new BigDecimal(0).setScale(2); + } + + } + + public Boolean getFixedPercentage() { + return fixedPercentage; + } + + public void setFixedPercentage(Boolean fixedPercentage) { + this.fixedPercentage = fixedPercentage; + } + + public HoursGroup getHoursGroup() { + return hoursGroup; + } + + public void setHoursGroup(HoursGroup hoursGroup) { + this.hoursGroup = hoursGroup; + } + + /* Operations to manage the criterions requirements */ + public void assignCriterionRequirementWrapper( + CriterionRequirementWrapper newRequirementWrapper) { + directRequirementWrappers.add(newRequirementWrapper); + } + + public boolean canSelectCriterion( + CriterionRequirementWrapper requirementWrapper) { + return hoursGroup.canAddCriterionRequirement(requirementWrapper + .getCriterionRequirement()); + } + + public void selectCriterionToDirectRequirementWrapper( + CriterionRequirementWrapper requirementWrapper) { + hoursGroup.addCriterionRequirement(requirementWrapper + .getCriterionRequirement()); + } + + public void addExceptionRequirementWrappers( + CriterionRequirementWrapper exceptionWrapper) { + exceptionRequirementWrappers.add(exceptionWrapper); + } + + public void selectCriterionToExceptionRequirementWrapper( + CriterionRequirementWrapper exception, + CriterionWithItsType criterionAndType) { + exception.setCriterionWithItsType(criterionAndType); + IndirectCriterionRequirement indirect = findValidRequirementByCriterion(criterionAndType + .getCriterion()); + exception.setCriterionRequirement(indirect); + exception.setValid(false); + } + + public void removeDirectCriterionRequirementWrapper( + CriterionRequirementWrapper directWrapper) { + if (directWrapper.getCriterionWithItsType() != null) { + CriterionRequirement direct = directWrapper + .getCriterionRequirement(); + hoursGroup.removeCriterionRequirement(direct); + } + getDirectRequirementWrappers().remove(directWrapper); + } + + public void removeExceptionCriterionRequirementWrapper( + CriterionRequirementWrapper exception) { + if (exception.getCriterionWithItsType() != null) { + exception.setValid(true); + } + getExceptionRequirementWrappers().remove(exception); + } + + public List getCriterionRequirementWrappersView() { + List list = new ArrayList(); + list.addAll(getDirectRequirementWrappers()); + list.addAll(getExceptionRequirementWrappers()); + return list; + } + + public List getValidCriterions() { + List list = new ArrayList(); + for (IndirectCriterionRequirement requirement : getValidIndirectCriterionRequirement()) { + Criterion criterion = requirement.getCriterion(); + CriterionType type = criterion.getType(); + list.add(new CriterionWithItsType(type, criterion)); + } + return list; + } + + public boolean dontExistValidCriterions() { + return !(getValidCriterions().size() > 0); + } + + private IndirectCriterionRequirement findValidRequirementByCriterion( + Criterion criterion) { + for (IndirectCriterionRequirement requirement : getValidIndirectCriterionRequirement()) { + if (requirement.getCriterion().equals(criterion)) { + return requirement; + } + } + return null; + } + + private List getInvalidIndirectCriterionRequirement() { + List result = new ArrayList(); + for (IndirectCriterionRequirement requirement : hoursGroup + .getIndirectCriterionRequirement()) { + if (!requirement.isIsValid()) { + result.add(requirement); + } + } + return result; + } + + public List getValidIndirectCriterionRequirement() { + List result = new ArrayList(); + for (IndirectCriterionRequirement requirement : hoursGroup + .getIndirectCriterionRequirement()) { + if (requirement.isIsValid()) { + result.add(requirement); + } + } + return result; + } + +} \ No newline at end of file diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IAssignedCriterionRequirementToOrderElementModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IAssignedCriterionRequirementToOrderElementModel.java index 1339176c9..646e0ad7a 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IAssignedCriterionRequirementToOrderElementModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IAssignedCriterionRequirementToOrderElementModel.java @@ -17,14 +17,18 @@ import org.navalplanner.business.resources.entities.CriterionWithItsType; */ public interface IAssignedCriterionRequirementToOrderElementModel { OrderElement getOrderElement(); + void setOrderElement(OrderElement orderElement); + void init(OrderElement orderElement); void assignCriterionRequirementWrapper(); void deleteCriterionRequirementWrapper( CriterionRequirementWrapper requirement); + void confirm()throws ValidationException; + void setOrderModel(IOrderModel orderModel); List getCriterionRequirementWrappers(); @@ -38,4 +42,27 @@ public interface IAssignedCriterionRequirementToOrderElementModel { void setValidCriterionRequirementWrapper( CriterionRequirementWrapper requirement, boolean valid); + + // Operations to manage the hours Groups + public void addNewHoursGroupWrapper(); + + List getHoursGroupsWrappers(); + + void deleteHoursGroupWrapper(HoursGroupWrapper hoursGroupWrapper); + + void addCriterionToHoursGroupWrapper( + HoursGroupWrapper hoursGroupWrapper); + + CriterionRequirementWrapper addExceptionToHoursGroupWrapper( + HoursGroupWrapper hoursGroupWrapper); + + boolean selectCriterionToHoursGroup( + HoursGroupWrapper hoursGroupWrapper, + CriterionRequirementWrapper exception, + CriterionWithItsType criterionAndType); + + void deleteCriterionToHoursGroup(HoursGroupWrapper hoursGroupWrapper, + CriterionRequirementWrapper requirementWrapper); + + boolean isPercentageValid(); } \ No newline at end of file diff --git a/navalplanner-webapp/src/main/webapp/orders/_listHoursGroupCriterionRequirement.zul b/navalplanner-webapp/src/main/webapp/orders/_listHoursGroupCriterionRequirement.zul new file mode 100644 index 000000000..d87178a98 --- /dev/null +++ b/navalplanner-webapp/src/main/webapp/orders/_listHoursGroupCriterionRequirement.zul @@ -0,0 +1,91 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/navalplanner-webapp/src/main/webapp/orders/_listOrderElementCriterionRequirements.zul b/navalplanner-webapp/src/main/webapp/orders/_listOrderElementCriterionRequirements.zul index 72157d4b5..3901d7397 100644 --- a/navalplanner-webapp/src/main/webapp/orders/_listOrderElementCriterionRequirements.zul +++ b/navalplanner-webapp/src/main/webapp/orders/_listOrderElementCriterionRequirements.zul @@ -18,6 +18,7 @@ along with this program. If not, see . --> + @@ -86,5 +87,63 @@ - + + + + + + + + + + +