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

ItEr34S07CUObtencionRequisitosEnProxectoTraballoItEr33S07 : Assign criterion requirements to order and its orderElements.

Browse source
This commit is contained in:
Susana Montes Pedreira 2009-11-09 18:31:35 +01:00 • committed by Javier Moran Rua
parent b9599c586f
commit d080447e25
31 changed files with 1677 additions and 66 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

414
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/CriterionRequirementHandler.java Normal file
View file

@ -0,0 +1,414 @@
/*
* 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 <http://www.gnu.org/licenses/>.
*/
package org.navalplanner.business.orders.entities;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
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;
/**
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
public class CriterionRequirementHandler implements
ICriterionRequirementHandler {
private static final CriterionRequirementHandler singleton = new CriterionRequirementHandler();
private CriterionRequirementHandler() {
}
public static CriterionRequirementHandler getInstance() {
return singleton;
}
// Operations to add a criterionRequirement
public void propagateDirectCriterionRequirementAddition(
OrderElement orderElement, CriterionRequirement directo) {
propagateIndirectCriterionRequirement(orderElement,
(DirectCriterionRequirement) directo);
}
private void propagateIndirectCriterionRequirement(
OrderElement orderElement,
CriterionRequirement directo) {
if (orderElement instanceof OrderLine) {
propagateIndirectCriterionRequirementToChildren(
(OrderLine) orderElement,
(DirectCriterionRequirement) directo);
} else {
propagateIndirectCriterionRequirementToChildren(
(OrderLineGroup) orderElement,
(DirectCriterionRequirement) directo);
}
}
void propagateIndirectCriterionRequirementToChildren(
OrderLineGroup orderLineGroup, DirectCriterionRequirement parent) {
Criterion criterion = parent.getCriterion();
for (OrderElement child : orderLineGroup.getChildren()) {
IndirectCriterionRequirement indirect = IndirectCriterionRequirement
.create(parent, criterion);
child.addIndirectCriterionRequirement(indirect);
propagateIndirectCriterionRequirement(child, parent);
}
}
void propagateIndirectCriterionRequirementToChildren(OrderLine orderLine,
DirectCriterionRequirement parent) {
Criterion criterion = parent.getCriterion();
for (HoursGroup hoursGroup : orderLine.getHoursGroups()) {
CriterionRequirement indirect = IndirectCriterionRequirement
.create(parent, criterion);
hoursGroup.addCriterionRequirement(indirect);
}
}
boolean canAddCriterionRequirement(OrderElement orderElement,
CriterionRequirement newRequirement) {
List<OrderElement> listOrderElements = orderElement.getAllChildren();
listOrderElements.add(orderElement);
for (OrderElement element : listOrderElements) {
if (existSameCriterionRequirement(element, newRequirement))
return false;
}
return true;
}
private boolean existSameCriterionRequirement(OrderElement orderElement,
CriterionRequirement newRequirement){
if (orderElement instanceof OrderLine) {
return existSameCriterionRequirementIntoOrderLine(
(OrderLine) orderElement,newRequirement);
} else {
return existSameCriterionRequirementIntoOrderElement(
(OrderLineGroup) orderElement, newRequirement);
}
}
private boolean existSameCriterionRequirementIntoOrderElement(
OrderElement orderElement,
CriterionRequirement newRequirement) {
Criterion criterion = newRequirement.getCriterion();
for (CriterionRequirement requirement : orderElement
.getCriterionRequirements()) {
if (requirement.getCriterion().equals(criterion))
return true;
}
return false;
}
boolean existSameCriterionRequirementIntoOrderLine(OrderLine orderLine,
CriterionRequirement newRequirement) {
if (existSameCriterionRequirementIntoOrderElement(orderLine,
newRequirement)) {
return true;
}
for (HoursGroup hoursGroup : orderLine.getHoursGroups()) {
if (hoursGroup.existSameCriterionRequirement(newRequirement))
return true;
}
return false;
}
/*
* Operations to set the valid value of a criterion Requirements and the
* criterion Requirement of its children.
*/
public void propagateValidCriterionRequirement(OrderElement orderElement,
DirectCriterionRequirement parent, boolean valid) {
if (orderElement instanceof OrderLine) {
setValidCriterionRequirementChildren((OrderLine) orderElement,
parent, valid);
} else {
setValidCriterionRequirementChildren((OrderLineGroup) orderElement,
parent, valid);
}
}
protected void setValidCriterionRequirementChildren(
OrderLineGroup orderLineGroup,
DirectCriterionRequirement parent, boolean valid) {
for (OrderElement child : orderLineGroup.getChildren()) {
IndirectCriterionRequirement indirect = findIndirectRequirementByParent(
child.getIndirectCriterionRequirement(), parent);
if (indirect != null) {
indirect.setIsValid(valid);
}
propagateValidCriterionRequirement(child, parent, valid);
}
}
protected void setValidCriterionRequirementChildren(OrderLine orderLine,
DirectCriterionRequirement parent, boolean valid) {
for (HoursGroup hoursGroup : orderLine.getHoursGroups()) {
IndirectCriterionRequirement indirect = findIndirectRequirementByParent(
hoursGroup.getIndirectCriterionRequirement(), parent);
if (indirect != null) {
indirect.setIsValid(valid);
}
}
}
/*
* Operation to update the criterions requirements of the orderElement and
* its children
*/
public void propagateRemoveCriterionRequirement(OrderElement orderElement,
DirectCriterionRequirement parent) {
if (orderElement instanceof OrderLine) {
removeIndirectCriterionRequirement((OrderLine) orderElement, parent);
} else {
removeIndirectCriterionRequirement((OrderLineGroup) orderElement,
parent);
}
}
protected void removeIndirectCriterionRequirement(
OrderLineGroup orderLineGroup, DirectCriterionRequirement parent) {
for (OrderElement child : orderLineGroup.getChildren()) {
IndirectCriterionRequirement indirect = findIndirectRequirementByParent(
child.getIndirectCriterionRequirement(), parent);
if (indirect != null) {
propagateRemoveCriterionRequirement(child, parent);
child.removeCriterionRequirement(indirect);
}
}
}
protected void removeIndirectCriterionRequirement(OrderLine orderLine,
DirectCriterionRequirement parent) {
for (HoursGroup hoursGroup : orderLine.getHoursGroups()) {
IndirectCriterionRequirement indirect = findIndirectRequirementByParent(
hoursGroup.getIndirectCriterionRequirement(), parent);
if (indirect != null) {
hoursGroup.removeCriterionRequirement(indirect);
}
}
}
/*
* Operation to update the criterions requirements of the orderElement and
* its children
*/
public void propagateUpdateCriterionRequirements(OrderElement orderElement) {
if (orderElement instanceof OrderLine) {
updateCriterionRequirementsIntoOrderLine((OrderLine) orderElement);
} else {
updateCriterionRequirementsIntoOrderLineGroup((OrderLineGroup) orderElement);
}
}
private void updateCriterionRequirementsIntoOrderLineGroup(
OrderElement orderLineGroup) {
for (OrderElement child : orderLineGroup.getChildren()) {
child.updateMyCriterionRequirements();
propagateUpdateCriterionRequirements(child);
}
}
private void updateCriterionRequirementsIntoOrderLine(OrderLine orderLine) {
for (HoursGroup hoursGroup : orderLine.getHoursGroups()) {
hoursGroup.updateMyCriterionRequirements();
}
}
void transformDirectToIndirectIfNeeded(OrderElement orderElement,
Set<IndirectCriterionRequirement> currents) {
for (DirectCriterionRequirement direct : orderElement
.getDirectCriterionRequirement()) {
IndirectCriterionRequirement indirect = findIndirectRequirementByCriterion(
currents, direct.getCriterion());
if (indirect != null) {
orderElement.removeDirectCriterionRequirement(direct);
}
}
}
void addNewsIndirects(OrderElement orderElement,
Set<IndirectCriterionRequirement> currents) {
Set<IndirectCriterionRequirement> indirects = orderElement
.getIndirectCriterionRequirement();
for (IndirectCriterionRequirement current : currents) {
if (!indirects.contains(current)) {
orderElement.addCriterionRequirement(current);
}
}
}
void removeOldIndirects(OrderElement orderElement,
Set<IndirectCriterionRequirement> currents) {
for (IndirectCriterionRequirement indirect : orderElement
.getIndirectCriterionRequirement()) {
if (!currents.contains(indirect)) {
orderElement.removeCriterionRequirement(indirect);
}
}
}
void transformDirectToIndirectIfNeeded(HoursGroup hoursGroup,
Set<IndirectCriterionRequirement> currents) {
for (DirectCriterionRequirement direct : hoursGroup
.getDirectCriterionRequirement()) {
IndirectCriterionRequirement indirect = findIndirectRequirementByCriterion(
currents, direct.getCriterion());
if (indirect != null) {
hoursGroup.removeCriterionRequirement(direct);
}
}
}
void addNewsIndirects(HoursGroup hoursGroup,
Set<IndirectCriterionRequirement> currents) {
Set<IndirectCriterionRequirement> indirects = hoursGroup
.getIndirectCriterionRequirement();
for (IndirectCriterionRequirement current : currents) {
if (!indirects.contains(current)) {
hoursGroup.addCriterionRequirement(current);
}
}
}
void removeOldIndirects(HoursGroup hoursGroup,
Set<IndirectCriterionRequirement> currents) {
for (IndirectCriterionRequirement indirect : hoursGroup
.getIndirectCriterionRequirement()) {
if (!currents.contains(indirect)) {
hoursGroup.removeCriterionRequirement(indirect);
}
}
}
Set<IndirectCriterionRequirement> getCurrentIndirectRequirements(
Set<IndirectCriterionRequirement> oldIndirects, OrderElement parent) {
Set<IndirectCriterionRequirement> currentIndirects = new HashSet<IndirectCriterionRequirement>();
for (CriterionRequirement requirement : parent
.getCriterionRequirements()) {
IndirectCriterionRequirement indirect = getCurrentIndirectRequirement(
oldIndirects, requirement);
currentIndirects.add(indirect);
}
return currentIndirects;
}
IndirectCriterionRequirement getCurrentIndirectRequirement(
Set<IndirectCriterionRequirement> oldIndirects,
CriterionRequirement requirement) {
IndirectCriterionRequirement indirect;
DirectCriterionRequirement parent;
if (requirement instanceof DirectCriterionRequirement) {
parent = (DirectCriterionRequirement) requirement;
indirect = findIndirectRequirementByParent(oldIndirects, parent);
} else {
parent = ((IndirectCriterionRequirement) requirement).getParent();
indirect = findIndirectRequirementByParent(oldIndirects, parent);
}
if (indirect == null) {
indirect = IndirectCriterionRequirement.create(parent, requirement
.getCriterion());
}
return (IndirectCriterionRequirement) indirect;
}
private IndirectCriterionRequirement findIndirectRequirementByParent(
Set<IndirectCriterionRequirement> indirects,
DirectCriterionRequirement newParent) {
for (IndirectCriterionRequirement requirement : indirects) {
if (requirement.getParent().equals(newParent)) {
return requirement;
}
}
return null;
}
private IndirectCriterionRequirement findIndirectRequirementByCriterion(
Set<IndirectCriterionRequirement> indirects, Criterion criterion) {
for (IndirectCriterionRequirement requirement : indirects) {
if (requirement.getCriterion().equals(criterion)) {
return requirement;
}
}
return null;
}
/*
* Operation to create and add to a orderElement new criterion requirements
* that it is copied of the criterion requirements of other orderElement
*/
protected void copyRequirementToOrderElement(OrderLine orderLine,
OrderLineGroup container) {
// copy the directCriterionRequirement
for (DirectCriterionRequirement newRequirement : copyDirectRequirements(orderLine
.getDirectCriterionRequirement())) {
container.addCriterionRequirement(newRequirement);
}
// copy the IndirectCriterionRequirement
for (IndirectCriterionRequirement newRequirement : copyIndirectRequirements(orderLine
.getIndirectCriterionRequirement())) {
container.addCriterionRequirement(newRequirement);
}
}
protected void copyRequirementToOrderElement(OrderLineGroup orderLineGroup,
OrderLine leaf) {
// copy the directCriterionRequirement
for (DirectCriterionRequirement newRequirement : copyDirectRequirements(orderLineGroup
.getDirectCriterionRequirement())) {
leaf.addDirectCriterionRequirement(newRequirement);
}
// copy the IndirectCriterionRequirement
for (IndirectCriterionRequirement newRequirement : copyIndirectRequirements(orderLineGroup
.getIndirectCriterionRequirement())) {
leaf.addIndirectCriterionRequirement(newRequirement);
propagateIndirectCriterionRequirementToChildren(leaf,
newRequirement.getParent());
}
}
private Set<DirectCriterionRequirement> copyDirectRequirements(Set<DirectCriterionRequirement> collection){
Set<DirectCriterionRequirement> result = new HashSet<DirectCriterionRequirement>();
for (DirectCriterionRequirement requirement : collection) {
DirectCriterionRequirement newRequirement = DirectCriterionRequirement
.create(requirement.getCriterion());
result.add(newRequirement);
}
return result;
}
private Set<IndirectCriterionRequirement> copyIndirectRequirements(
Set<IndirectCriterionRequirement> collection) {
Set<IndirectCriterionRequirement> result = new HashSet<IndirectCriterionRequirement>();
for (IndirectCriterionRequirement requirement : collection) {
DirectCriterionRequirement parent = requirement.getParent();
IndirectCriterionRequirement newRequirement = IndirectCriterionRequirement
.create(parent, requirement.getCriterion());
result.add(newRequirement);
}
return result;
}
}

55
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/HoursGroup.java
View file

@ -20,16 +20,16 @@
package org.navalplanner.business.orders.entities;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.hibernate.validator.NotNull;
import org.hibernate.validator.Valid;
import org.navalplanner.business.common.BaseEntity;
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;
@ -53,6 +53,9 @@ public class HoursGroup extends BaseEntity implements Cloneable {
@NotNull
private OrderLine parentOrderLine;
protected CriterionRequirementHandler criterionRequirementHandler = CriterionRequirementHandler
.getInstance();
/**
* Constructor for hibernate. Do not use!
*/
@ -113,6 +116,7 @@ public class HoursGroup extends BaseEntity implements Cloneable {
this.criterionRequirements = criterionRequirements;
}
@Valid
public Set<CriterionRequirement> getCriterionRequirements() {
return criterionRequirements;
}
@ -133,7 +137,7 @@ public class HoursGroup extends BaseEntity implements Cloneable {
throw new IllegalStateException(
" The "
+ requirement.getCriterion().getName()
+ " can not be assigned to this hoursGroup because it already exist in other hoursGroup");
+ " can not be assigned to this hoursGroup because it already exist into the hoursGroup");
}
}
@ -157,8 +161,16 @@ public class HoursGroup extends BaseEntity implements Cloneable {
}
}
public void removeCriterionRequirement(CriterionRequirement criterionRequirement) {
criterionRequirements.remove(criterionRequirement);
public void removeCriterionRequirement(CriterionRequirement requirement) {
criterionRequirements.remove(requirement);
if (requirement instanceof IndirectCriterionRequirement) {
((IndirectCriterionRequirement) requirement).getParent()
.getChildren().remove(
(IndirectCriterionRequirement) requirement);
}
requirement.setCriterion(null);
requirement.setHoursGroup(null);
requirement.setOrderElement(null);
}
/* TO REMOVE */
@ -198,8 +210,27 @@ public class HoursGroup extends BaseEntity implements Cloneable {
return parentOrderLine;
}
private List<DirectCriterionRequirement> getDirectCriterionRequirement() {
List<DirectCriterionRequirement> list = new ArrayList<DirectCriterionRequirement>();
void updateMyCriterionRequirements() {
OrderElement newParent = this.getParentOrderLine();
Set<IndirectCriterionRequirement> currentIndirects = criterionRequirementHandler
.getCurrentIndirectRequirements(
getIndirectCriterionRequirement(), newParent);
criterionRequirementHandler.removeOldIndirects(this, currentIndirects);
criterionRequirementHandler.addNewsIndirects(this, currentIndirects);
}
Set<IndirectCriterionRequirement> getIndirectCriterionRequirement() {
Set<IndirectCriterionRequirement> list = new HashSet<IndirectCriterionRequirement>();
for(CriterionRequirement criterionRequirement : criterionRequirements ){
if(criterionRequirement instanceof IndirectCriterionRequirement){
list.add((IndirectCriterionRequirement) criterionRequirement);
}
}
return list;
}
public Set<DirectCriterionRequirement> getDirectCriterionRequirement() {
Set<DirectCriterionRequirement> list = new HashSet<DirectCriterionRequirement>();
for(CriterionRequirement criterionRequirement : criterionRequirements ){
if(criterionRequirement instanceof DirectCriterionRequirement){
list.add((DirectCriterionRequirement) criterionRequirement);
@ -207,4 +238,14 @@ public class HoursGroup extends BaseEntity implements Cloneable {
}
return list;
}
public boolean existSameCriterionRequirement(CriterionRequirement newRequirement){
Criterion criterion = newRequirement.getCriterion();
for(CriterionRequirement requirement : getCriterionRequirements()){
if(requirement.getCriterion().equals(criterion))
return true;
}
return false;
}
}

28
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/ICriterionRequirementHandler.java Normal file
View file

@ -0,0 +1,28 @@
/*
* 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 <http://www.gnu.org/licenses/>.
*/
package org.navalplanner.business.orders.entities;
/**
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
public interface ICriterionRequirementHandler {
}

1
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/IOrderLineGroup.java
View file

@ -39,5 +39,4 @@ public interface IOrderLineGroup {
public void down(OrderElement orderElement);
public void add(int position, OrderElement orderElement);
}

109
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderElement.java
View file

@ -30,6 +30,7 @@ import java.util.Set;
import org.apache.commons.lang.Validate;
import org.hibernate.validator.NotEmpty;
import org.hibernate.validator.Valid;
import org.joda.time.LocalDate;
import org.navalplanner.business.advance.entities.AdvanceAssignment;
import org.navalplanner.business.advance.entities.AdvanceType;
@ -42,7 +43,9 @@ import org.navalplanner.business.labels.entities.Label;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
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;
public abstract class OrderElement extends BaseEntity {
@ -72,6 +75,9 @@ public abstract class OrderElement extends BaseEntity {
protected OrderLineGroup parent;
protected CriterionRequirementHandler criterionRequirementHandler = CriterionRequirementHandler
.getInstance();
public OrderLineGroup getParent() {
return parent;
}
@ -326,22 +332,98 @@ public abstract class OrderElement extends BaseEntity {
return result;
}
public void setCriterionRequirements(
Set<CriterionRequirement> criterionRequirements) {
this.criterionRequirements = criterionRequirements;
}
@Valid
public Set<CriterionRequirement> getCriterionRequirements() {
return Collections.unmodifiableSet(criterionRequirements);
}
public void removeCriterionRequirement(CriterionRequirement criterionRequirement){
//Remove the criterionRequirement into orderelement.
criterionRequirements.remove(criterionRequirement);
protected Set<CriterionRequirement> myCriterionRequirements() {
return criterionRequirements;
}
public void addCriterionRequirement(CriterionRequirement criterionRequirement){
criterionRequirement.setOrderElement(this);
this.criterionRequirements.add(criterionRequirement);
/*
* Operations to manage the criterion requirements of a orderElement
* (remove, adding, update of the criterion requirement of the orderElement
* such as the descendent's criterion requirement)
*/
public void setValidCriterionRequirement(IndirectCriterionRequirement requirement,boolean valid){
requirement.setIsValid(valid);
criterionRequirementHandler.propagateValidCriterionRequirement(this,
requirement.getParent(), valid);
}
protected List<IndirectCriterionRequirement> getIndirectCriterionRequirement() {
List<IndirectCriterionRequirement> list = new ArrayList<IndirectCriterionRequirement>();
public void removeDirectCriterionRequirement(DirectCriterionRequirement criterionRequirement){
criterionRequirementHandler.propagateRemoveCriterionRequirement(this,
criterionRequirement);
removeCriterionRequirement(criterionRequirement);
}
protected void removeCriterionRequirement(CriterionRequirement requirement) {
criterionRequirements.remove(requirement);
if(requirement instanceof IndirectCriterionRequirement){
((IndirectCriterionRequirement)requirement).getParent().
getChildren().remove((IndirectCriterionRequirement)requirement);
}
}
public void addDirectCriterionRequirement(
CriterionRequirement newRequirement) {
if (criterionRequirementHandler.canAddCriterionRequirement(this,
newRequirement)) {
addCriterionRequirement(newRequirement);
criterionRequirementHandler
.propagateDirectCriterionRequirementAddition(this,
newRequirement);
} else {
Criterion criterion = newRequirement.getCriterion();
throw new IllegalStateException(" The " + criterion.getName()
+ " already exist into other order element");
}
}
void addIndirectCriterionRequirement(
IndirectCriterionRequirement criterionRequirement) {
addCriterionRequirement(criterionRequirement);
}
protected void addCriterionRequirement(
CriterionRequirement criterionRequirement) {
criterionRequirement.setOrderElement(this);
this.criterionRequirements.add(criterionRequirement);
}
public void updateCriterionRequirements() {
updateMyCriterionRequirements();
criterionRequirementHandler.propagateUpdateCriterionRequirements(this);
}
void updateMyCriterionRequirements() {
OrderElement newParent = this.getParent();
Set<IndirectCriterionRequirement> currentIndirects = criterionRequirementHandler
.getCurrentIndirectRequirements(
getIndirectCriterionRequirement(), newParent);
criterionRequirementHandler.transformDirectToIndirectIfNeeded(this,
currentIndirects);
criterionRequirementHandler.removeOldIndirects(this, currentIndirects);
criterionRequirementHandler.addNewsIndirects(this, currentIndirects);
}
public boolean canAddCriterionRequirement(
DirectCriterionRequirement newRequirement) {
return criterionRequirementHandler.canAddCriterionRequirement(this,
newRequirement);
}
protected Set<IndirectCriterionRequirement> getIndirectCriterionRequirement() {
Set<IndirectCriterionRequirement> list = new HashSet<IndirectCriterionRequirement>();
for (CriterionRequirement criterionRequirement : criterionRequirements) {
if (criterionRequirement instanceof IndirectCriterionRequirement) {
list.add((IndirectCriterionRequirement) criterionRequirement);
@ -364,4 +446,15 @@ public abstract class OrderElement extends BaseEntity {
protected void applyStartConstraintTo(Task task) {
task.getStartConstraint().notEarlierThan(this.getInitDate());
}
public Set<DirectCriterionRequirement> getDirectCriterionRequirement() {
Set<DirectCriterionRequirement> list = new HashSet<DirectCriterionRequirement>();
for (CriterionRequirement criterionRequirement : criterionRequirements) {
if (criterionRequirement instanceof DirectCriterionRequirement) {
list.add((DirectCriterionRequirement) criterionRequirement);
}
}
return list;
}
}

31
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLine.java
View file

@ -29,6 +29,8 @@ import java.util.Set;
import org.joda.time.LocalDate;
import org.navalplanner.business.advance.entities.AdvanceType;
import org.navalplanner.business.advance.entities.DirectAdvanceAssignment;
import org.navalplanner.business.requirements.entities.CriterionRequirement;
import org.navalplanner.business.requirements.entities.DirectCriterionRequirement;
public class OrderLine extends OrderElement {
@ -85,6 +87,12 @@ public class OrderLine extends OrderElement {
result.setInitDate(getInitDate());
result.setDeadline(getDeadline());
// copy the criterion requirements to container
copyRequirementToOrderElement(result);
// removed the direct criterion requirements
removeAllDirectCriterionRequirement();
this.setName(getName() + " (copy)");
this.setCode(getCode() + " (copy)");
result.add(this);
@ -92,6 +100,14 @@ public class OrderLine extends OrderElement {
return result;
}
private void removeAllDirectCriterionRequirement() {
Set<DirectCriterionRequirement> directRequirements = new HashSet<DirectCriterionRequirement>(
getDirectCriterionRequirement());
for (DirectCriterionRequirement requirement : directRequirements) {
removeDirectCriterionRequirement(requirement);
}
}
@Override
public List<HoursGroup> getHoursGroups() {
return new ArrayList<HoursGroup>(hoursGroups);
@ -386,7 +402,6 @@ public class OrderLine extends OrderElement {
protected Set<DirectAdvanceAssignment> getAllDirectAdvanceAssignments(
AdvanceType advanceType) {
Set<DirectAdvanceAssignment> result = new HashSet<DirectAdvanceAssignment>();
for (DirectAdvanceAssignment directAdvanceAssignment : directAdvanceAssignments) {
if (directAdvanceAssignment.getAdvanceType().getUnitName().equals(
advanceType.getUnitName())) {
@ -394,7 +409,6 @@ public class OrderLine extends OrderElement {
return result;
}
}
return result;
}
@ -406,7 +420,6 @@ public class OrderLine extends OrderElement {
@Override
protected Set<DirectAdvanceAssignment> getAllDirectAdvanceAssignmentsReportGlobal() {
Set<DirectAdvanceAssignment> result = new HashSet<DirectAdvanceAssignment>();
for (DirectAdvanceAssignment directAdvanceAssignment : directAdvanceAssignments) {
if (directAdvanceAssignment.getReportGlobalAdvance()) {
result.add(directAdvanceAssignment);
@ -415,4 +428,16 @@ public class OrderLine extends OrderElement {
}
return result;
}
public boolean existSameCriterionRequirement(
CriterionRequirement newRequirement) {
return criterionRequirementHandler
.existSameCriterionRequirementIntoOrderLine(this,
newRequirement);
}
protected void copyRequirementToOrderElement(OrderLineGroup container) {
criterionRequirementHandler.copyRequirementToOrderElement(this,
container);
}
}

6
navalplanner-business/src/main/java/org/navalplanner/business/orders/entities/OrderLineGroup.java
View file

@ -159,7 +159,7 @@ public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
result.setWorkHours(0);
result.directAdvanceAssignments = new HashSet<DirectAdvanceAssignment>(
this.directAdvanceAssignments);
copyRequirementToOrderElement(result);
return result;
}
@ -672,4 +672,8 @@ public class OrderLineGroup extends OrderElement implements IOrderLineGroup {
}
}
}
protected void copyRequirementToOrderElement(OrderLine leaf) {
criterionRequirementHandler.copyRequirementToOrderElement(this, leaf);
}
}

3
navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/CriterionRequirement.java
View file

@ -19,7 +19,6 @@
*/
package org.navalplanner.business.requirements.entities;
import org.hibernate.validator.NotNull;
import org.navalplanner.business.common.BaseEntity;
import org.navalplanner.business.orders.entities.HoursGroup;
@ -36,7 +35,6 @@ public class CriterionRequirement extends BaseEntity{
private OrderElement orderElement;
@NotNull
private Criterion criterion;
public CriterionRequirement(){
@ -54,6 +52,7 @@ public class CriterionRequirement extends BaseEntity{
this.hoursGroup = hoursGroup;
}
@NotNull
public Criterion getCriterion() {
return criterion;
}

1
navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/DirectCriterionRequirement.java
View file

@ -78,5 +78,4 @@ public class DirectCriterionRequirement extends CriterionRequirement{
children) {
this.children = children;
}
}

18
navalplanner-business/src/main/java/org/navalplanner/business/requirements/entities/IndirectCriterionRequirement.java
View file

@ -31,20 +31,14 @@ import org.navalplanner.business.orders.entities.OrderElement;
*/
public class IndirectCriterionRequirement extends CriterionRequirement{
@NotNull
private DirectCriterionRequirement parent;
private Boolean isValid = true;
public static IndirectCriterionRequirement create() {
IndirectCriterionRequirement result = new IndirectCriterionRequirement();
result.setNewObject(true);
return result;
}
public static IndirectCriterionRequirement create(DirectCriterionRequirement
parent,Criterion criterion) {
IndirectCriterionRequirement result = new IndirectCriterionRequirement(criterion);
result.setNewObject(true);
result.setParent(parent);
return result;
}
@ -57,14 +51,6 @@ public class IndirectCriterionRequirement extends CriterionRequirement{
return result;
}
public static IndirectCriterionRequirement create(DirectCriterionRequirement
parent,Boolean isValid) {
IndirectCriterionRequirement result = create();
result.setParent(parent);
result.setIsValid(isValid);
return result;
}
/**
* Constructor for hibernate. Do not use!
*/
@ -81,6 +67,7 @@ public class IndirectCriterionRequirement extends CriterionRequirement{
super(criterion,orderElement,hoursGroup);
}
@NotNull
public DirectCriterionRequirement getParent() {
return parent;
}
@ -97,5 +84,4 @@ public class IndirectCriterionRequirement extends CriterionRequirement{
public void setIsValid(boolean isValid) {
this.isValid = isValid;
}
}

23
navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Criterion.java
View file

@ -21,6 +21,7 @@
package org.navalplanner.business.resources.entities;
import java.util.Collections;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
@ -32,6 +33,7 @@ import org.hibernate.validator.NotEmpty;
import org.hibernate.validator.NotNull;
import org.hibernate.validator.Valid;
import org.navalplanner.business.common.BaseEntity;
import org.navalplanner.business.requirements.entities.CriterionRequirement;
/**
* A criterion stored in the database <br />
@ -71,6 +73,7 @@ public class Criterion extends BaseEntity implements ICriterion {
private boolean active = true;
private Set<CriterionRequirement> criterionRequirements = new HashSet<CriterionRequirement>();
/*
* Just for Hibernate mapping in order to have an unique constraint with
* name and type properties.
@ -177,9 +180,27 @@ public class Criterion extends BaseEntity implements ICriterion {
}
}
}
return true;
}
public Set<CriterionRequirement> getCriterionRequirements() {
return Collections.unmodifiableSet(criterionRequirements);
}
public void setCriterionRequirements(
Set<CriterionRequirement> criterionRequirements) {
this.criterionRequirements = criterionRequirements;
}
public void removeCriterionRequirement(
CriterionRequirement criterionRequirement) {
this.criterionRequirements.remove(criterionRequirement);
}
public void addCriterionRequirement(
CriterionRequirement criterionRequirement) {
criterionRequirement.setCriterion(this);
this.criterionRequirements.add(criterionRequirement);
}
}

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

@ -32,4 +32,4 @@ public interface ICriterion {
boolean isSatisfiedBy(Resource resource, Date start, Date end);
}
}

4
navalplanner-business/src/main/resources/navalplanner-business-spring-config.xml
View file

@ -75,4 +75,8 @@
class="org.navalplanner.business.common.Registry"
factory-method="getInstance" />
<bean id="CriterionRequirementHandler"
class="org.navalplanner.business.orders.entities.CriterionRequirementHandler"
factory-method="getInstance" />
</beans>

2
navalplanner-business/src/main/resources/org/navalplanner/business/orders/entities/Orders.hbm.xml
View file

@ -30,7 +30,7 @@
<many-to-many column="LABEL_ID" class="org.navalplanner.business.labels.entities.Label" />
</set>
<set name="criterionRequirements" access="field" cascade="all,delete-orphan" inverse="true">
<set name="criterionRequirements" access="field" cascade="save-update,delete-orphan" inverse="true">
<key column="ORDER_ELEMENT_ID" not-null="false"></key>
<one-to-many class="org.navalplanner.business.requirements.entities.CriterionRequirement"/>
</set>

2
navalplanner-business/src/main/resources/org/navalplanner/business/requirements/entities/Requirements.hbm.xml
View file

@ -17,7 +17,7 @@
<many-to-one class="org.navalplanner.business.resources.entities.Criterion" column="CRITERION_ID" name="criterion"/>
<subclass discriminator-value="DIRECT" name="DirectCriterionRequirement">
<set access="field" cascade="all,delete-orphan" inverse="true" name="children">
<set access="field" name="children" cascade="all,delete-orphan" inverse="true">
<key column="parent"/>
<one-to-many class="IndirectCriterionRequirement"/>
</set>

5
navalplanner-business/src/main/resources/org/navalplanner/business/resources/entities/Resources.hbm.xml
View file

@ -66,6 +66,11 @@
<one-to-many class="Criterion"/>
</set>
<set name="criterionRequirements" access="field">
<key column="CRITERION_ID" not-null="false"></key>
<one-to-many class="org.navalplanner.business.requirements.entities.CriterionRequirement"/>
</set>
<properties name="nameAndType" unique="true">
<property access="field" name="name" insert="false" update="false"/>
<property access="field" name="typeId" insert="false" update="false"

39
navalplanner-business/src/test/java/org/navalplanner/business/test/orders/entities/OrderElementTest.java
View file

@ -22,6 +22,7 @@ package org.navalplanner.business.test.orders.entities;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.navalplanner.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_FILE;
import static org.navalplanner.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;
@ -35,6 +36,8 @@ import java.util.SortedSet;
import javax.annotation.Resource;
import org.hibernate.validator.ClassValidator;
import org.hibernate.validator.InvalidValue;
import org.joda.time.LocalDate;
import org.junit.Before;
import org.junit.Test;
@ -48,9 +51,14 @@ import org.navalplanner.business.advance.entities.DirectAdvanceAssignment;
import org.navalplanner.business.advance.entities.IndirectAdvanceAssignment;
import org.navalplanner.business.advance.exceptions.DuplicateAdvanceAssignmentForOrderElementException;
import org.navalplanner.business.advance.exceptions.DuplicateValueTrueReportGlobalAdvanceException;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.business.orders.entities.OrderLineGroup;
import org.navalplanner.business.requirements.entities.CriterionRequirement;
import org.navalplanner.business.requirements.entities.DirectCriterionRequirement;
import org.navalplanner.business.resources.entities.Criterion;
import org.navalplanner.business.resources.entities.CriterionType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
@ -74,6 +82,9 @@ public class OrderElementTest {
defaultAdvanceTypesBootstrapListener.loadRequiredData();
}
private ClassValidator<OrderElement> orderElementValidator =
new ClassValidator<OrderElement>(OrderElement.class);
private static OrderLine givenOrderLine(String name, String code,
Integer hours) {
OrderLine orderLine = OrderLine
@ -166,6 +177,34 @@ public class OrderElementTest {
return advanceType;
}
@Test
public void checkValidPropagation()throws ValidationException{
OrderElement orderElement = givenOrderLineGroupWithTwoOrderLines(1000,
2000);
try {
InvalidValue[] invalidValues =
orderElementValidator.getInvalidValues(orderElement);
if (invalidValues.length > 0)
throw new ValidationException(invalidValues);
} catch (ValidationException e) {
fail("It not should throw an exception");
}
CriterionType type = CriterionType.create("", "");
Criterion criterion = Criterion.create(type);
CriterionRequirement requirement = DirectCriterionRequirement
.create(criterion);
requirement.setOrderElement(orderElement);
orderElement.addDirectCriterionRequirement(requirement);
try {
InvalidValue[] invalidValues =
orderElementValidator.getInvalidValues(orderElement);
if (invalidValues.length > 0)
throw new ValidationException(invalidValues);
} catch (ValidationException e) {
fail("It no should throw an exception");
}
}
@Test
public void checkAdvancePercentageEmptyOrderLine() {
OrderLine orderLine = givenOrderLine("name", "code", 1000);

243
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementController.java Normal file
View file

@ -0,0 +1,243 @@
/*
* 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 <http://www.gnu.org/licenses/>.
*/
package org.navalplanner.web.orders;
import static org.navalplanner.web.I18nHelper._;
import java.util.List;
import org.hibernate.validator.InvalidValue;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.resources.entities.CriterionWithItsType;
import org.navalplanner.business.workreports.entities.WorkReportLine;
import org.navalplanner.web.common.IMessagesForUser;
import org.navalplanner.web.common.MessagesForUser;
import org.navalplanner.web.common.Util;
import org.navalplanner.web.common.components.NewDataSortableGrid;
import org.navalplanner.web.resources.worker.CriterionSatisfactionDTO;
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.Hbox;
import org.zkoss.zul.Listitem;
import org.zkoss.zul.Row;
import org.zkoss.zul.Rows;
import org.zkoss.zul.Vbox;
/**
* Controller for showing OrderElement assigned labels
*
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
public class AssignedCriterionRequirementToOrderElementController extends
GenericForwardComposer {
private IAssignedCriterionRequirementToOrderElementModel assignedCriterionRequirementToOrderElementModel;
private Vbox vbox;
private NewDataSortableGrid listingRequirements;
private IMessagesForUser messages;
private Component messagesContainer;
@Override
public void doAfterCompose(Component comp) throws Exception {
super.doAfterCompose(comp);
if (messagesContainer == null)
throw new RuntimeException(_("MessagesContainer is needed"));
messages = new MessagesForUser(messagesContainer);
comp.setVariable("assignedCriterionRequirementController", this, true);
vbox = (Vbox) comp;
}
public OrderElement getOrderElement() {
return assignedCriterionRequirementToOrderElementModel.getOrderElement();
}
public void setOrderElement(OrderElement orderElement) {
assignedCriterionRequirementToOrderElementModel.setOrderElement(orderElement);
}
public void openWindow(IOrderElementModel orderElementModel) {
assignedCriterionRequirementToOrderElementModel.setOrderModel(orderElementModel
.getOrderModel());
openWindow(orderElementModel.getOrderElement());
}
public void openWindow(OrderElement orderElement) {
assignedCriterionRequirementToOrderElementModel.init(orderElement);
Util.reloadBindings(vbox);
}
public boolean close() {
try{
assignedCriterionRequirementToOrderElementModel.confirm();
return true;
}catch (ValidationException e) {
showInvalidValues(e);
}
return false;
}
public List<CriterionRequirementDTO> criterionRequirementDTOs(){
return assignedCriterionRequirementToOrderElementModel.
getCriterionRequirementDTOs();
}
public List<CriterionWithItsType> getCriterionWithItsTypes(){
return assignedCriterionRequirementToOrderElementModel.getCriterionWithItsTypes();
}
public void addCriterionRequirementDTO(){
assignedCriterionRequirementToOrderElementModel.assignCriterionRequirementDTO();
reload();
}
public void remove(CriterionRequirementDTO requirement){
assignedCriterionRequirementToOrderElementModel.
deleteCriterionRequirementDTO(requirement);
reload();
}
public void invalidate(CriterionRequirementDTO requirement){
assignedCriterionRequirementToOrderElementModel.
setValidCriterionRequirementDTO(requirement,false);
reload();
}
public void validate(CriterionRequirementDTO requirement){
assignedCriterionRequirementToOrderElementModel.
setValidCriterionRequirementDTO(requirement,true);
reload();
}
public void selectCriterionAndType(Listitem item,Bandbox bandbox,
CriterionRequirementDTO criterionRequirementDTO){
if(item != null){
try{
criterionRequirementDTO = updateRetrievedCriterionRequirement(criterionRequirementDTO);
CriterionWithItsType criterionAndType =
(CriterionWithItsType)item.getValue();
bandbox.close();
validateCriterionWithItsType(bandbox,
criterionAndType,criterionRequirementDTO);
bandbox.setValue(criterionAndType.getNameAndType());
criterionRequirementDTO.setCriterionWithItsType(criterionAndType);
}catch(WrongValueException e){
bandbox.setValue("");
criterionRequirementDTO.setCriterionWithItsType(null);
throw e;
}
}else{
bandbox.setValue("");
}
}
private CriterionRequirementDTO updateRetrievedCriterionRequirement(
CriterionRequirementDTO requirementDTO){
return assignedCriterionRequirementToOrderElementModel.
updateRetrievedCriterionRequirement(requirementDTO);
}
private void validateCriterionWithItsType(Bandbox bandbox,
CriterionWithItsType criterionAndType,
CriterionRequirementDTO requirementDTO)throws WrongValueException{
if(!assignedCriterionRequirementToOrderElementModel.
canAddCriterionRequirement(requirementDTO,criterionAndType)){
throw new WrongValueException(bandbox,
_("The criterion " + criterionAndType.getNameAndType() + " is not valid," +
" exist the same criterion into the order element or into its children."));
}
}
private void reload() {
Util.reloadBindings(listingRequirements);
}
private void showInvalidValues(ValidationException e) {
for (InvalidValue invalidValue : e.getInvalidValues()) {
Object value = invalidValue.getBean();
if(value instanceof CriterionRequirementDTO){
validateCriterionRequirementDTO(invalidValue,
(CriterionRequirementDTO)value);
}
}
}
/**
* Validates {@link CriterionSatisfactionDTO} data constraints
*
* @param invalidValue
*/
private void validateCriterionRequirementDTO(InvalidValue invalidValue,
CriterionRequirementDTO requirementDTO) {
if(listingRequirements != null){
// Find which listItem contains CriterionSatisfaction inside listBox
Row row = findRowOfCriterionSatisfactionDTO(listingRequirements.getRows(),
requirementDTO);
if (row != null) {
String propertyName = invalidValue.getPropertyName();
if (CriterionRequirementDTO.CRITERION_WITH_ITS_TYPE.equals(propertyName)) {
Bandbox bandType = getBandType(row);
bandType.setValue(null);
throw new WrongValueException(bandType,
_("The criterion and its type cannot be null"));
}
}
}
}
/**
* Locates which {@link row} is bound to {@link WorkReportLine} in
* rows
*
* @param Rows
* @param CriterionSatisfactionDTO
* @return
*/
private Row findRowOfCriterionSatisfactionDTO(Rows rows,
CriterionRequirementDTO requirementDTO) {
List<Row> listRows = (List<Row>) rows.getChildren();
for (Row row : listRows) {
if (requirementDTO.equals(row.getValue())) {
return row;
}
}
return null;
}
/**
* Locates {@link Bandbox} criterion requirement in {@link row}
*
* @param row
* @return Bandbox
*/
private Bandbox getBandType(Row row) {
return (Bandbox)((Hbox) row.getChildren().get(0))
.getChildren().get(0);
}
}

307
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/AssignedCriterionRequirementToOrderElementModel.java Normal file
View file

@ -0,0 +1,307 @@
/*
* 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 <http://www.gnu.org/licenses/>.
*/
package org.navalplanner.web.orders;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.hibernate.validator.ClassValidator;
import org.hibernate.validator.InvalidValue;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.orders.daos.IOrderElementDAO;
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.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;
import org.navalplanner.web.orders.CriterionRequirementDTO.FlagState;
import org.navalplanner.web.orders.CriterionRequirementDTO.Type;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
*
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
@Service
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class AssignedCriterionRequirementToOrderElementModel implements
IAssignedCriterionRequirementToOrderElementModel{
@Autowired
IOrderElementDAO orderElementDAO;
OrderElement orderElement;
IOrderModel orderModel;
private ClassValidator<CriterionRequirementDTO> requirementDTOValidator = new ClassValidator<CriterionRequirementDTO>(
CriterionRequirementDTO.class);
private List<CriterionWithItsType> criterionWithItsTypes =
new ArrayList<CriterionWithItsType>();
private List<CriterionRequirementDTO> criterionRequirementDTOs =
new ArrayList<CriterionRequirementDTO>();
@Override
public OrderElement getOrderElement() {
return orderElement;
}
@Override
public void setOrderElement(OrderElement orderElement) {
this.orderElement = orderElement;
}
@Override
@Transactional(readOnly = true)
public void init(OrderElement orderElement) {
this.orderElement = orderElement;
if(orderElement != null){
reattachOrderElement();
initializeDTOs();
initializeCriterionWithItsType();
}
}
private void reattachOrderElement() {
orderElementDAO.reattach(orderElement);
for(OrderElement child : orderElement.getAllChildren()){
child.getName();
reattachCriterionRequirement(child.getCriterionRequirements());
if(child instanceof OrderLine){
for(HoursGroup hoursGroup : child.getHoursGroups()){
hoursGroup.getWorkingHours();
reattachCriterionRequirement(hoursGroup.getCriterionRequirements());
}
}
}
}
private void reattachCriterionRequirement(Set<CriterionRequirement> list){
for(CriterionRequirement requirement : list){
requirement.getCriterion().getName();
requirement.getCriterion().getType().getName();
}
}
private void initializeDTOs() {
criterionRequirementDTOs = new ArrayList<CriterionRequirementDTO>();
for(CriterionRequirement requirement :
orderElement.getCriterionRequirements()){
CriterionRequirementDTO dto =
new CriterionRequirementDTO(requirement);
criterionRequirementDTOs.add(dto);
}
}
private void initializeCriterionWithItsType() {
criterionWithItsTypes = new ArrayList<CriterionWithItsType>();
for(CriterionType type : getTypes()){
if(type.isEnabled()){
for (Criterion criterion : orderModel.getCriterionsFor(type)) {
if(criterion.isActive()){
CriterionWithItsType criterionAndType =
new CriterionWithItsType(type,criterion);
criterionWithItsTypes.add(criterionAndType);
}
}
}
}
}
private Set<CriterionType> getTypes(){
return getMapCriterions().keySet();
}
private Map<CriterionType, List<Criterion>> getMapCriterions(){
return orderModel.getMapCriterions();
}
@Override
public List<CriterionWithItsType> getCriterionWithItsTypes(){
return criterionWithItsTypes;
}
@Override
@Transactional(readOnly = true)
public void assignCriterionRequirementDTO() {
if((orderModel != null) && (orderElement != null)){
CriterionRequirementDTO requirement = new CriterionRequirementDTO(Type.DIRECT);
criterionRequirementDTOs.add(requirement);
}
}
@Override
public void deleteCriterionRequirementDTO(CriterionRequirementDTO requirement) {
if(requirement.isOldObject()){
requirement.setFlagState(FlagState.REMOVED);
}else{
criterionRequirementDTOs.remove(requirement);
}
}
@Override
@Transactional(readOnly = true)
public void confirm() throws ValidationException{
reattachOrderElement();
validateDTOs();
saveDTOs();
}
@Override
public void setOrderModel(IOrderModel orderModel) {
this.orderModel = orderModel;
}
@Override
public List<CriterionRequirementDTO> getCriterionRequirementDTOs() {
List<CriterionRequirementDTO> requirementDTOs =
new ArrayList<CriterionRequirementDTO>();
if((orderModel != null)&&(getOrderElement() != null)){
for(CriterionRequirementDTO requirementDTO : criterionRequirementDTOs){
if(!requirementDTO.getFlagState().equals(FlagState.REMOVED)){
requirementDTOs.add(requirementDTO);
}
}
}
return requirementDTOs;
}
@Override
public CriterionRequirementDTO updateRetrievedCriterionRequirement(
CriterionRequirementDTO requirementDTO){
if(requirementDTO.getFlagState().equals(FlagState.RETRIEVED)){
CriterionRequirementDTO newRequirement = new CriterionRequirementDTO(Type.DIRECT);
criterionRequirementDTOs.add(newRequirement);
requirementDTO.setFlagState(FlagState.REMOVED);
return newRequirement;
}
return requirementDTO;
}
@Override
public boolean canAddCriterionRequirement(CriterionRequirementDTO requirementDTO,
CriterionWithItsType criterionAndType){
CriterionRequirementDTO removedDTO = findRemovedRequirementDTOWithSameCriterion(
criterionAndType.getCriterion());
if(removedDTO != null){
deleteCriterionRequirementDTO(requirementDTO);
removedDTO.setFlagState(FlagState.RETRIEVED);
return true;
}else{
return canAddCriterionRequirement(criterionAndType);
}
}
private CriterionRequirementDTO findRemovedRequirementDTOWithSameCriterion(
Criterion criterion){
for(CriterionRequirementDTO removedDTO : this.criterionRequirementDTOs){
if(removedDTO.getFlagState().equals(FlagState.REMOVED)){
Criterion removedCriterion = removedDTO.
getCriterionWithItsType().getCriterion();
if(criterion.getId().equals(removedCriterion.getId()))
return removedDTO;
}
}
return null;
}
private boolean canAddCriterionRequirement(CriterionWithItsType criterionAndType){
if(orderElement != null){
return (!existSameCriterionRequirementInDTOs(criterionAndType) &&
(canAddCriterionRequirementInOrderElement(criterionAndType)));
}
return true;
}
private boolean existSameCriterionRequirementInDTOs(
CriterionWithItsType newCriterionAndType){
for(CriterionRequirementDTO requirementDTO : criterionRequirementDTOs){
CriterionWithItsType criterionAndType = requirementDTO.getCriterionWithItsType();
if((criterionAndType != null) &&
(criterionAndType.getCriterion().equals(newCriterionAndType.getCriterion()))){
return true;
}
}
return false;
}
private boolean canAddCriterionRequirementInOrderElement(
CriterionWithItsType newCriterionAndType){
return orderElement.canAddCriterionRequirement(DirectCriterionRequirement.
create(newCriterionAndType.getCriterion()));
}
@Override
public void setValidCriterionRequirementDTO(
CriterionRequirementDTO requirement,boolean valid){
requirement.setValid(valid);
}
private void validateDTOs() throws ValidationException{
Set<CriterionRequirementDTO> listDTOs =
new HashSet<CriterionRequirementDTO>(criterionRequirementDTOs);
for(CriterionRequirementDTO requirementDTO : listDTOs){
InvalidValue[] invalidValues;
invalidValues = requirementDTOValidator.getInvalidValues(requirementDTO);
if (invalidValues.length > 0){
throw new ValidationException(invalidValues);
}
}
}
private void saveDTOs(){
updateRemoved();
for(CriterionRequirementDTO requirementDTO : this.criterionRequirementDTOs){
if(requirementDTO.isNewObject()){
Criterion criterion = requirementDTO.getCriterionWithItsType().getCriterion();
CriterionRequirement requirement = DirectCriterionRequirement.create(criterion);
orderElement.addDirectCriterionRequirement(requirement);
}else if(requirementDTO._getType().equals(Type.INDIRECT)){
boolean valid = requirementDTO.isValid();
CriterionRequirement requirement = requirementDTO.getCriterionRequirement();
orderElement.setValidCriterionRequirement((IndirectCriterionRequirement)requirement,valid);
}
}
}
private void updateRemoved(){
for(CriterionRequirementDTO requirementDTO : criterionRequirementDTOs){
if(requirementDTO.getFlagState().equals(FlagState.REMOVED)){
orderElement.removeDirectCriterionRequirement(
(DirectCriterionRequirement)requirementDTO.getCriterionRequirement());
}
}
}
}

196
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/CriterionRequirementDTO.java Normal file
View file

@ -0,0 +1,196 @@
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package org.navalplanner.web.orders;
import static org.navalplanner.web.I18nHelper._;
import org.hibernate.validator.NotNull;
import org.navalplanner.business.INewObject;
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;
/**
* DTO represents the handled data in the form of assigning criterion requirement.
*
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
public class CriterionRequirementDTO implements INewObject {
public static enum Type {
DIRECT, INDIRECT;
}
public static enum FlagState {
NORMAL, REMOVED, RETRIEVED;
}
private static final String DIRECT = _("Direct");
private static final String INDIRECT = _("Indirect");
public static final String CRITERION_WITH_ITS_TYPE = "criterionWithItsType";
private String type;
private String criterionAndType;
private Boolean newObject = false;
private CriterionRequirement criterionRequirement;
private Boolean valid = true;
private FlagState flagState = FlagState.NORMAL;
@NotNull
private CriterionWithItsType criterionWithItsType;
public CriterionRequirementDTO(Type type){
this.setNewObject(true);
this.setType(type);
this.setValid(true);
this.criterionAndType = "";
}
public CriterionRequirementDTO(CriterionRequirement criterionRequirement) {
this.criterionAndType = "";
this.setCriterionRequirement(criterionRequirement);
this.setType(criterionRequirement);
this.setValid(criterionRequirement);
Criterion criterion = criterionRequirement.getCriterion();
CriterionType type = criterion.getType();
setCriterionWithItsType(new CriterionWithItsType(type, criterion));
}
public CriterionWithItsType getCriterionWithItsType() {
return criterionWithItsType;
}
public void setCriterionWithItsType(CriterionWithItsType criterionWithItsType) {
this.criterionWithItsType = criterionWithItsType;
}
public void setCriterionAndType(String criterionAndType) {
this.criterionAndType = criterionAndType;
}
public String getCriterionAndType() {
if(criterionWithItsType == null) return criterionAndType;
return criterionWithItsType.getNameAndType();
}
public void setNewObject(Boolean isNewObject) {
this.newObject = isNewObject;
}
public boolean isOldObject(){
return !isNewObject();
}
@Override
public boolean isNewObject() {
return newObject == null ? false : newObject;
}
public void setCriterionRequirement(CriterionRequirement criterionRequirement) {
this.criterionRequirement = criterionRequirement;
}
public CriterionRequirement getCriterionRequirement() {
return criterionRequirement;
}
public void setType(String type) {
this.type = type;
}
public String getType() {
return type;
}
public Type _getType() {
if(type.equals(DIRECT)){
return Type.DIRECT;
}else{
return Type.INDIRECT;
}
}
private void setType(CriterionRequirement criterionRequirement){
if(criterionRequirement instanceof DirectCriterionRequirement){
type = DIRECT;
}else if(criterionRequirement instanceof IndirectCriterionRequirement){
type = INDIRECT;
}
}
private void setType(Type type){
if(type.equals(Type.DIRECT)){
this.type = DIRECT;
}else{
this.type = INDIRECT;
}
}
public boolean isDirect(){
return (type.equals(DIRECT)) ? true : false;
}
public boolean isIndirectValid(){
return (!isDirect()) && (isValid());
}
public boolean isIndirectInvalid(){
return (!isDirect()) && (isInvalid());
}
public void setValid(Boolean valid) {
this.valid = valid;
}
public void setValid(CriterionRequirement requirement) {
this.valid = true;
if(criterionRequirement instanceof IndirectCriterionRequirement){
this.valid = ((IndirectCriterionRequirement)criterionRequirement).isIsValid();
}
}
public boolean isValid() {
return valid == null ? false : valid;
}
public boolean isInvalid(){
return !isValid();
}
public String getLabelValidate(){
if(isValid()){
return _("Invalidate");
}else{
return _("Validate");
}
}
public void setFlagState(FlagState flagState) {
this.flagState = flagState;
}
public FlagState getFlagState() {
return flagState;
}
public boolean isUpdatable(){
return (isNewObject() || getFlagState().equals(FlagState.RETRIEVED));
}
public boolean isUnmodifiable(){
return !isUpdatable();
}
}

30
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/IAssignedCriterionRequirementToOrderElementModel.java Normal file
View file

@ -0,0 +1,30 @@
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package org.navalplanner.web.orders;
import java.util.List;
import org.navalplanner.business.common.exceptions.ValidationException;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.resources.entities.CriterionWithItsType;
/**
*
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
public interface IAssignedCriterionRequirementToOrderElementModel {
OrderElement getOrderElement();
void setOrderElement(OrderElement orderElement);
void init(OrderElement orderElement);
void assignCriterionRequirementDTO();
void deleteCriterionRequirementDTO(CriterionRequirementDTO requirement);
void confirm()throws ValidationException;
void setOrderModel(IOrderModel orderModel);
List<CriterionRequirementDTO> getCriterionRequirementDTOs();
List<CriterionWithItsType> getCriterionWithItsTypes();
boolean canAddCriterionRequirement(CriterionRequirementDTO requirement,CriterionWithItsType criterionAndType);
void setValidCriterionRequirementDTO(CriterionRequirementDTO requirement, boolean valid);
CriterionRequirementDTO updateRetrievedCriterionRequirement(CriterionRequirementDTO requirementDTO);
}

15
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderCRUDController.java
View file

@ -114,6 +114,7 @@ public class OrderCRUDController extends GenericForwardComposer {
setupAsignedHoursToOrderElementController(comp);
setupManageOrderElementAdvancesController(comp);
setupAssignedLabelsToOrderElementController(comp);
setupAssignedCriterionRequirementsToOrderElementController(comp);
}
private void setupOrderElementTreeController(Component comp,
@ -161,6 +162,16 @@ public class OrderCRUDController extends GenericForwardComposer {
orderElementLabels.getVariable("assignedLabelsController", true);
}
private AssignedCriterionRequirementToOrderElementController assignedCriterionRequirementController;
private void setupAssignedCriterionRequirementsToOrderElementController(
Component comp) throws Exception {
Component orderElementCriterionRequirements = editWindow
.getFellowIfAny("orderElementCriterionRequirements");
assignedCriterionRequirementController = (AssignedCriterionRequirementToOrderElementController) orderElementCriterionRequirements
.getVariable("assignedCriterionRequirementController", true);
}
public List<Order> getOrders() {
return orderModel.getOrders();
}
@ -194,6 +205,9 @@ public class OrderCRUDController extends GenericForwardComposer {
if (!manageOrderElementAdvancesController.save()) {
selectTab("tabAdvances");
}
if (!assignedCriterionRequirementController.close()) {
selectTab("tabRequirements");
}
try {
orderModel.save();
messagesForUser.showMessage(Level.INFO, _("Order saved"));
@ -299,6 +313,7 @@ public class OrderCRUDController extends GenericForwardComposer {
assignedHoursController.openWindow(orderElementModel);
manageOrderElementAdvancesController.openWindow(orderElementModel);
assignedLabelsController.openWindow(orderElementModel);
assignedCriterionRequirementController.openWindow(orderElementModel);
}
private void clearEditWindow() {

22
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementController.java
View file

@ -52,7 +52,7 @@ public class OrderElementController extends GenericForwardComposer {
private Component orderElementHours;
private AsignedHoursToOrderElementController assignedHoursController;
private AsignedHoursToOrderElementController asignedHoursToOrderElementController;
private Component orderElementAdvances;
@ -62,6 +62,10 @@ public class OrderElementController extends GenericForwardComposer {
private AssignedLabelsToOrderElementController assignedLabelsController;
private Component orderElementCriterionRequirements;
private AssignedCriterionRequirementToOrderElementController assignedCriterionRequirementController;
@Override
public void doAfterCompose(Component comp) throws Exception {
super.doAfterCompose(comp);
@ -70,6 +74,7 @@ public class OrderElementController extends GenericForwardComposer {
setupAsignedHoursToOrderElementController(comp);
setupManageOrderElementAdvancesController(comp);
setupAssignedLabelsToOrderElementController(comp);
setupAssignedCriterionRequirementToOrderElementController(comp);
}
private void setupDetailsOrderElementController(Component comp) throws Exception{
@ -78,7 +83,7 @@ public class OrderElementController extends GenericForwardComposer {
}
private void setupAsignedHoursToOrderElementController(Component comp) throws Exception{
assignedHoursController = (AsignedHoursToOrderElementController)
asignedHoursToOrderElementController = (AsignedHoursToOrderElementController)
orderElementHours.getVariable("asignedHoursToOrderElementController", true);
}
@ -93,6 +98,12 @@ public class OrderElementController extends GenericForwardComposer {
orderElementLabels.getVariable("assignedLabelsController", true);
}
private void setupAssignedCriterionRequirementToOrderElementController(
Component comp) throws Exception {
assignedCriterionRequirementController = (AssignedCriterionRequirementToOrderElementController) orderElementCriterionRequirements
.getVariable("assignedCriterionRequirementController", true);
}
public OrderElement getOrderElement() {
return (orderElementModel == null) ? OrderLine.create() : orderElementModel.getOrderElement();
}
@ -108,9 +119,10 @@ public class OrderElementController extends GenericForwardComposer {
setOrderElementModel(model);
detailsController.openWindow(model);
assignedHoursController.openWindow(model);
asignedHoursToOrderElementController.openWindow(model);
manageOrderElementAdvancesController.openWindow(model);
assignedLabelsController.openWindow(model);
assignedCriterionRequirementController.openWindow(model);
try {
((Window) self).doModal();
@ -156,6 +168,10 @@ public class OrderElementController extends GenericForwardComposer {
selectTab("tabAdvances");
return;
}
if (!assignedCriterionRequirementController.close()) {
selectTab("tabRequirements");
return;
}
close();
}

2
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementModel.java
View file

@ -22,6 +22,7 @@ package org.navalplanner.web.orders;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@ -73,6 +74,7 @@ public class OrderElementModel implements IOrderElementModel {
orderElementDAO.reattach(orderElement);
for (HoursGroup hoursGroup : orderElement.getHoursGroups()) {
hoursGroup.getCriterionRequirements().size();
hoursGroup.getCriterions().size();
}

22
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementTreeController.java
View file

@ -33,6 +33,9 @@ import java.util.Set;
import org.navalplanner.business.orders.entities.Order;
import org.navalplanner.business.orders.entities.OrderElement;
import org.navalplanner.business.orders.entities.OrderLine;
import org.navalplanner.web.common.IMessagesForUser;
import org.navalplanner.web.common.Level;
import org.navalplanner.web.common.MessagesForUser;
import org.navalplanner.web.common.Util;
import org.navalplanner.web.common.components.bandboxsearch.BandboxSearch;
import org.zkoss.zk.ui.Component;
@ -65,6 +68,10 @@ import org.zkoss.zul.Treerow;
*/
public class OrderElementTreeController extends GenericForwardComposer {
private IMessagesForUser messagesForUser;
private Component messagesContainer;
private Combobox cbFilterType;
private BandboxSearch bdFilter;
@ -177,12 +184,16 @@ public class OrderElementTreeController extends GenericForwardComposer {
public void addOrderElement() {
snapshotOfOpenedNodes = TreeViewStateSnapshot.snapshotOpened(tree);
if (tree.getSelectedCount() == 1) {
getModel().addOrderElementAt(getSelectedNode());
} else {
getModel().addOrderElement();
try{
if (tree.getSelectedCount() == 1) {
getModel().addOrderElementAt(getSelectedNode());
} else {
getModel().addOrderElement();
}
filterByPredicateIfAny();
} catch (IllegalStateException e) {
messagesForUser.showMessage(Level.ERROR, e.getMessage());
}
filterByPredicateIfAny();
}
private void filterByPredicateIfAny() {
@ -260,6 +271,7 @@ public class OrderElementTreeController extends GenericForwardComposer {
@Override
public void doAfterCompose(Component comp) throws Exception {
super.doAfterCompose(comp);
messagesForUser = new MessagesForUser(messagesContainer);
comp.setVariable("orderElementTreeController", this, true);
}

19
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderElementTreeModel.java
View file

@ -67,14 +67,9 @@ public class OrderElementTreeModel {
for (OrderElement orderElement : orderElements) {
treeModel.add(orderElement, orderElement.getChildren());
addChildren(treeModel, orderElement.getChildren());
reattach(orderElement);
}
}
private static void reattach(OrderElement orderElement) {
orderElement.getHoursGroups().size();
}
private MutableTreeModel<OrderElement> tree;
public OrderElementTreeModel(Order order) {
@ -125,6 +120,8 @@ public class OrderElementTreeModel {
IOrderLineGroup container = turnIntoContainerIfNeeded(parent);
container.add(orderElement);
addToTree(toNode(container), orderElement);
updateCriterionRequirementsInHierarchy(parent, orderElement,
(OrderElement) container);
}
private void addOrderElementAt(OrderElement destinationNode,
@ -132,6 +129,18 @@ public class OrderElementTreeModel {
IOrderLineGroup container = turnIntoContainerIfNeeded(destinationNode);
container.add(position, elementToAdd);
addToTree(toNode(container), position, elementToAdd);
updateCriterionRequirementsInHierarchy(destinationNode, elementToAdd,
(OrderElement) container);
}
private void updateCriterionRequirementsInHierarchy(
OrderElement destination, OrderElement origin,
OrderElement container) {
if (destination instanceof OrderLine) {
container.updateCriterionRequirements();
} else {
origin.updateCriterionRequirements();
}
}
private OrderElement toNode(IOrderLineGroup container) {

31
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/OrderModel.java
View file

@ -52,6 +52,7 @@ import org.navalplanner.business.planner.daos.ITaskElementDAO;
import org.navalplanner.business.planner.entities.Task;
import org.navalplanner.business.planner.entities.TaskElement;
import org.navalplanner.business.planner.entities.TaskGroup;
import org.navalplanner.business.requirements.entities.DirectCriterionRequirement;
import org.navalplanner.business.resources.daos.ICriterionDAO;
import org.navalplanner.business.resources.daos.ICriterionTypeDAO;
import org.navalplanner.business.resources.entities.Criterion;
@ -131,6 +132,7 @@ public class OrderModel implements IOrderModel {
}
}
@Override
public Map<CriterionType, List<Criterion>> getMapCriterions(){
final Map<CriterionType, List<Criterion>> result =
new HashMap<CriterionType, List<Criterion>>();
@ -147,6 +149,7 @@ public class OrderModel implements IOrderModel {
this.order = getFromDB(order);
this.orderElementTreeModel = new OrderElementTreeModel(this.order);
forceLoadAdvanceAssignmentsAndMeasurements(this.order);
forceLoadCriterionRequirements(this.order);
}
private void initializeCacheLabels() {
@ -169,6 +172,29 @@ public class OrderModel implements IOrderModel {
label.getType().getName();
}
private static void forceLoadCriterionRequirements(OrderElement orderElement) {
orderElement.getHoursGroups().size();
for (HoursGroup hoursGroup : orderElement.getHoursGroups()) {
attachDirectCriterionRequirement(hoursGroup
.getDirectCriterionRequirement());
}
attachDirectCriterionRequirement(orderElement
.getDirectCriterionRequirement());
for (OrderElement child : orderElement.getChildren()) {
forceLoadCriterionRequirements(child);
}
}
private static void attachDirectCriterionRequirement(
Set<DirectCriterionRequirement> requirements) {
for (DirectCriterionRequirement requirement : requirements) {
requirement.getChildren().size();
requirement.getCriterion().getName();
requirement.getCriterion().getType().getName();
}
}
private void forceLoadAdvanceAssignmentsAndMeasurements(
OrderElement orderElement) {
for (DirectAdvanceAssignment directAdvanceAssignment : orderElement
@ -215,10 +241,10 @@ public class OrderModel implements IOrderModel {
public void save() throws ValidationException {
reattachCriterions();
this.orderDAO.save(order);
deleteOrderElementNotParent();
deleteOrderElementWithoutParent();
}
private void deleteOrderElementNotParent() throws ValidationException {
private void deleteOrderElementWithoutParent() throws ValidationException {
List<OrderElement> listToBeRemoved = orderElementDAO
.findWithoutParent();
for (OrderElement orderElement : listToBeRemoved) {
@ -311,6 +337,7 @@ public class OrderModel implements IOrderModel {
return getFromDB(order).isSomeTaskElementScheduled();
}
@Override
public List<Criterion> getCriterionsFor(CriterionType criterionType) {
return mapCriterions.get(criterionType);
}

2
navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/CriterionsController.java
View file

@ -62,8 +62,6 @@ public class CriterionsController extends GenericForwardComposer {
}
messages = new MessagesForUser(messagesContainer);
comp.setVariable("assignedCriterionsController", this, true);
//comboboxFilter = (Combobox) comp.getFellow("comboboxfilter");
//listingCriterions = (Grid) comp.getFellow("listingCriterions");
}
public IAssignedCriterionsModel getModel(){

15
navalplanner-webapp/src/main/webapp/orders/_editOrderElement.zul
View file

@ -18,23 +18,25 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
-->
<?component name="orderElementDetails" inline="true" macroURI="_orderElementDetails.zul"?>
<?component name="listOrderElementHours" inline="true" macroURI="_listOrderElementHours.zul"?>
<?component name="listOrderElementAdvances" inline="true" macroURI="_listOrderElementAdvances.zul"?>
<?component name="listOrderElementLabels" inline="true" macroURI="_listOrderElementLabels.zul"?>
<?component name="orderElementDetails" inline="true" macroURI="_orderElementDetails.zul"?>
<?component name="listOrderElementCriterionRequirements" inline="true" macroURI="_listOrderElementCriterionRequirements.zul"?>
<window id="${arg.top_id}" title="${i18n:_('Edit order element')}"
width="950px" left="50px" top="50px"
closable="true" visible="false">
<tabbox height="620px">
<tabs>
<tabbox height="620px">
<tabs>
<tab id="tabDetails" label="${i18n:_('Details')}"></tab>
<tab label="${i18n:_('Assigned hours')}"></tab>
<tab label="${i18n:_('Advances')}"></tab>
<tab id="tabAdvances" label="${i18n:_('Advances')}"></tab>
<tab label="${i18n:_('Labels')}"></tab>
<tab id="tabRequirements" label="${i18n:_('Criterion Requirement')}"></tab>
</tabs>
<tabpanels>
<tabpanel>
<tabpanel>
<orderElementDetails id="orderElementDetails" />
</tabpanel>
<tabpanel>
@ -46,6 +48,9 @@
<tabpanel>
<listOrderElementLabels id="orderElementLabels" />
</tabpanel>
<tabpanel>
<listOrderElementCriterionRequirements id="orderElementCriterionRequirements"/>
</tabpanel>
</tabpanels>
</tabbox>
<hbox>

6
navalplanner-webapp/src/main/webapp/orders/_edition.zul
View file

@ -23,7 +23,7 @@
<?component name="listOrderElementHours" inline="true" macroURI="_listOrderElementHours.zul"?>
<?component name="listOrderElementAdvances" inline="true" macroURI="_listOrderElementAdvances.zul"?>
<?component name="listOrderElementLabels" inline="true" macroURI="_listOrderElementLabels.zul"?>
<?component name="listOrderElementCriterionRequirements" inline="true" macroURI="_listOrderElementCriterionRequirements.zul"?>
<window id="${arg.top_id}">
<tabbox>
<tabs>
@ -33,6 +33,7 @@
<tab label="${i18n:_('Assigned hours')}" />
<tab id="tabAdvances" label="${i18n:_('Advances')}" />
<tab label="${i18n:_('Label')}" />
<tab id="tabRequirements" label="${i18n:_('Criterion Requirement')}"/>
</tabs>
<tabpanels>
<tabpanel>
@ -94,6 +95,9 @@
<tabpanel>
<listOrderElementLabels id="orderElementLabels" />
</tabpanel>
<tabpanel>
<listOrderElementCriterionRequirements id="orderElementCriterionRequirements"/>
</tabpanel>
</tabpanels>
</tabbox>
<hbox>

90
navalplanner-webapp/src/main/webapp/orders/_listOrderElementCriterionRequirements.zul Normal file
View file

@ -0,0 +1,90 @@
<!--
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 <http://www.gnu.org/licenses/>.
-->
<vbox id="${arg.id}"
apply="org.navalplanner.web.orders.AssignedCriterionRequirementToOrderElementController">
<panel title="${i18n:_('Assigned Criterions Requirement')}" border="normal">
<panelchildren>
<hbox align="center">
<separator bar="false" spacing="40px" orient="horizontal"/>
<separator bar="false" spacing="20px" orient="vertical"/>
<button onClick="assignedCriterionRequirementController.addCriterionRequirementDTO();"
label="${i18n:_('Add criterion requirement')}" />
<separator bar="false" spacing="40px" orient="vertical"/>
</hbox>
<newdatasortablegrid id="listingRequirements" mold="paging" pageSize="10" fixedLayout="true"
model="@{assignedCriterionRequirementController.criterionRequirementDTOs}">
<columns>
<newdatasortablecolumn label="${i18n:_('Criterion name')}" sort="auto(criterionAndType)" sortDirection="ascending"/>
<newdatasortablecolumn label="${i18n:_('Type')}" sort="auto(type)" width="70px" align="center"/>
<newdatasortablecolumn label="${i18n:_('Operations')}" width="70px" align="center"/>
</columns>
<rows>
<row self="@{each='criterionRequirementDTO'}" value="@{criterionRequirementDTO}">
<hbox>
<bandbox width="500px"
visible ="@{criterionRequirementDTO.updatable}"
value = "@{criterionRequirementDTO.criterionAndType}">
<bandpopup>
<listbox width="500px" height="150px" fixedLayout="true"
model="@{assignedCriterionRequirementController.criterionWithItsTypes}"
onSelect="assignedCriterionRequirementController.selectCriterionAndType(self.selectedItem,
self.parent.parent,self.parent.parent.parent.parent.value);">
<listhead>
<listheader label="Type" />
<listheader label="Criterion" />
</listhead>
<listitem self="@{each='criterionWithItsType'}" value="@{criterionWithItsType}">
<listcell label="@{criterionWithItsType.type.name}" />
<listcell label="@{criterionWithItsType.nameHierarchy}" />
</listitem>
</listbox>
</bandpopup>
</bandbox>
<label visible="@{criterionRequirementDTO.unmodifiable}"
value="@{criterionRequirementDTO.criterionAndType}"/>
</hbox>
<label value="@{criterionRequirementDTO.type}"/>
<hbox>
<button visible = "@{criterionRequirementDTO.direct}"
sclass="icono" image="/common/img/ico_borrar1.png"
hoverImage="/common/img/ico_borrar.png"
tooltiptext="${i18n:_('Delete')}"
onClick="assignedCriterionRequirementController.remove(self.parent.parent.value);">
</button>
<button visible = "@{criterionRequirementDTO.indirectInvalid}"
label = "${i18n:_('Validate')}"
onClick = "assignedCriterionRequirementController.validate(self.parent.parent.value);">
</button>
<button visible = "@{criterionRequirementDTO.indirectValid}"
label = "${i18n:_('Invalidate')}"
onClick = "assignedCriterionRequirementController.invalidate(self.parent.parent.value);">
</button>
</hbox>
</row>
</rows>
</newdatasortablegrid>
<separator bar="false" spacing="40px" orient="vertical"/>
</panelchildren>
</panel>
<separator bar="false" spacing="40px" orient="vertical"/>
</vbox>