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

ItEr34S07CUObtencionRequisitosEnProxectoTraballoItEr33S07 : assign criterion requirements to orders and its orderElements.

Browse source
This commit is contained in:
Susana Montes Pedreira 2009-11-10 18:04:17 +01:00 • committed by Javier Moran Rua
parent 5ada35d5a5
commit 73006de168
5 changed files with 146 additions and 283 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -24,8 +24,6 @@ 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;
@ -33,7 +31,6 @@ 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;
@ -92,138 +89,115 @@ public class AssignedCriterionRequirementToOrderElementController extends
}
public boolean close() {
try{
assignedCriterionRequirementToOrderElementModel.confirm();
return true;
}catch (ValidationException e) {
showInvalidValues(e);
if (showInvalidValues()) {
return false;
}
return false;
assignedCriterionRequirementToOrderElementModel.confirm();
return true;
}
public List<CriterionRequirementDTO> criterionRequirementDTOs(){
public List<CriterionRequirementWrapper> criterionRequirementWrappers() {
return assignedCriterionRequirementToOrderElementModel.
getCriterionRequirementDTOs();
getCriterionRequirementWrappers();
}
public List<CriterionWithItsType> getCriterionWithItsTypes(){
return assignedCriterionRequirementToOrderElementModel.getCriterionWithItsTypes();
}
public void addCriterionRequirementDTO(){
assignedCriterionRequirementToOrderElementModel.assignCriterionRequirementDTO();
public void addCriterionRequirementWrapper() {
assignedCriterionRequirementToOrderElementModel
.assignCriterionRequirementWrapper();
reload();
}
public void remove(CriterionRequirementDTO requirement){
public void remove(CriterionRequirementWrapper requirement){
assignedCriterionRequirementToOrderElementModel.
deleteCriterionRequirementDTO(requirement);
deleteCriterionRequirementWrapper(requirement);
reload();
}
public void invalidate(CriterionRequirementDTO requirement){
public void invalidate(CriterionRequirementWrapper requirement){
assignedCriterionRequirementToOrderElementModel.
setValidCriterionRequirementDTO(requirement,false);
setValidCriterionRequirementWrapper(requirement, false);
reload();
}
public void validate(CriterionRequirementDTO requirement){
public void validate(CriterionRequirementWrapper requirement){
assignedCriterionRequirementToOrderElementModel.
setValidCriterionRequirementDTO(requirement,true);
setValidCriterionRequirementWrapper(requirement, true);
reload();
}
public void selectCriterionAndType(Listitem item,Bandbox bandbox,
CriterionRequirementDTO criterionRequirementDTO){
CriterionRequirementWrapper criterionRequirementWrapper) {
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){
CriterionWithItsType criterionAndType = (CriterionWithItsType) item
.getValue();
bandbox.close();
bandbox.setValue(criterionAndType.getNameAndType());
if (!assignedCriterionRequirementToOrderElementModel
.canSetCriterionWithItsType(criterionRequirementWrapper,
criterionAndType)) {
bandbox.setValue("");
criterionRequirementDTO.setCriterionWithItsType(null);
throw e;
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."));
}
}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);
}
private boolean showInvalidValues() {
CriterionRequirementWrapper invalidWrapper = this.assignedCriterionRequirementToOrderElementModel
.validateWrappers();
if (invalidWrapper != null) {
showInvalidValues(invalidWrapper);
return true;
}
return false;
}
/**
* Validates {@link CriterionSatisfactionDTO} data constraints
*
* Validates {@link CriterionRequirementWrapper} data constraints
* @param invalidValue
*/
private void validateCriterionRequirementDTO(InvalidValue invalidValue,
CriterionRequirementDTO requirementDTO) {
private void showInvalidValues(
CriterionRequirementWrapper requirementWrapper) {
if(listingRequirements != null){
// Find which listItem contains CriterionSatisfaction inside listBox
Row row = findRowOfCriterionSatisfactionDTO(listingRequirements.getRows(),
requirementDTO);
Row row = findRowOfCriterionRequirementWrapper(listingRequirements
.getRows(),
requirementWrapper);
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
*
* Locates which {@link row} is bound to {@link WorkReportLine} in rows
* @param Rows
* @param CriterionSatisfactionDTO
* @param CriterionRequirementWrapper
* @return
*/
private Row findRowOfCriterionSatisfactionDTO(Rows rows,
CriterionRequirementDTO requirementDTO) {
private Row findRowOfCriterionRequirementWrapper(Rows rows,
CriterionRequirementWrapper requirementWrapper) {
List<Row> listRows = (List<Row>) rows.getChildren();
for (Row row : listRows) {
if (requirementDTO.equals(row.getValue())) {
if (requirementWrapper.equals(row.getValue())) {
return row;
}
}

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

@ -21,13 +21,10 @@
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;
@ -35,12 +32,9 @@ 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;
@ -63,14 +57,11 @@ public class AssignedCriterionRequirementToOrderElementModel implements
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>();
private List<CriterionRequirementWrapper> criterionRequirementWrappers =
new ArrayList<CriterionRequirementWrapper>();
@Override
public OrderElement getOrderElement() {
@ -88,7 +79,7 @@ public class AssignedCriterionRequirementToOrderElementModel implements
this.orderElement = orderElement;
if(orderElement != null){
reattachOrderElement();
initializeDTOs();
initializeWrappers();
initializeCriterionWithItsType();
}
}
@ -114,13 +105,14 @@ public class AssignedCriterionRequirementToOrderElementModel implements
}
}
private void initializeDTOs() {
criterionRequirementDTOs = new ArrayList<CriterionRequirementDTO>();
private void initializeWrappers() {
criterionRequirementWrappers = new ArrayList<CriterionRequirementWrapper>();
for(CriterionRequirement requirement :
orderElement.getCriterionRequirements()){
CriterionRequirementDTO dto =
new CriterionRequirementDTO(requirement);
criterionRequirementDTOs.add(dto);
CriterionRequirementWrapper Wrapper =
new CriterionRequirementWrapper(
requirement, false);
criterionRequirementWrappers.add(Wrapper);
}
}
@ -154,28 +146,47 @@ public class AssignedCriterionRequirementToOrderElementModel implements
@Override
@Transactional(readOnly = true)
public void assignCriterionRequirementDTO() {
public void assignCriterionRequirementWrapper() {
if((orderModel != null) && (orderElement != null)){
CriterionRequirementDTO requirement = new CriterionRequirementDTO(Type.DIRECT);
criterionRequirementDTOs.add(requirement);
CriterionRequirement newRequirement = DirectCriterionRequirement
.create();
CriterionRequirementWrapper requirement = new CriterionRequirementWrapper(
newRequirement, true);
criterionRequirementWrappers.add(requirement);
}
}
@Override
public void deleteCriterionRequirementDTO(CriterionRequirementDTO requirement) {
if(requirement.isOldObject()){
requirement.setFlagState(FlagState.REMOVED);
}else{
criterionRequirementDTOs.remove(requirement);
public boolean canSetCriterionWithItsType(
CriterionRequirementWrapper requirementWrapper,
CriterionWithItsType criterionAndType) {
requirementWrapper.setCriterionWithItsType(criterionAndType);
return canAddNewCriterionRequirement(requirementWrapper);
}
private boolean canAddNewCriterionRequirement(
CriterionRequirementWrapper requirementWrapper) {
DirectCriterionRequirement requirement = (DirectCriterionRequirement) requirementWrapper
.getCriterionRequirement();
if (orderElement.canAddCriterionRequirement(requirement)) {
orderElement.addDirectCriterionRequirement(requirement);
return true;
}
return false;
}
@Override
public void deleteCriterionRequirementWrapper(
CriterionRequirementWrapper requirementWrapper) {
DirectCriterionRequirement requirement = (DirectCriterionRequirement) requirementWrapper
.getCriterionRequirement();
orderElement.removeDirectCriterionRequirement(requirement);
criterionRequirementWrappers.remove(requirementWrapper);
}
@Override
@Transactional(readOnly = true)
public void confirm() throws ValidationException{
reattachOrderElement();
validateDTOs();
saveDTOs();
}
@Override
@ -184,124 +195,25 @@ public class AssignedCriterionRequirementToOrderElementModel implements
}
@Override
public List<CriterionRequirementDTO> getCriterionRequirementDTOs() {
List<CriterionRequirementDTO> requirementDTOs =
new ArrayList<CriterionRequirementDTO>();
public List<CriterionRequirementWrapper> getCriterionRequirementWrappers() {
if((orderModel != null)&&(getOrderElement() != null)){
for(CriterionRequirementDTO requirementDTO : criterionRequirementDTOs){
if(!requirementDTO.getFlagState().equals(FlagState.REMOVED)){
requirementDTOs.add(requirementDTO);
}
}
return criterionRequirementWrappers;
}
return requirementDTOs;
return new ArrayList<CriterionRequirementWrapper>();
}
@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;
public void setValidCriterionRequirementWrapper(
CriterionRequirementWrapper requirementWrapper, boolean valid) {
requirementWrapper.setValid(valid);
}
@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;
public CriterionRequirementWrapper validateWrappers() {
for (CriterionRequirementWrapper requirementWrapper : criterionRequirementWrappers) {
if (requirementWrapper.getCriterionWithItsType() == null) {
return requirementWrapper;
}
}
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());
}
}
}
}

76
navalplanner-webapp/src/main/java/org/navalplanner/web/orders/CriterionRequirementDTO.java → navalplanner-webapp/src/main/java/org/navalplanner/web/orders/CriterionRequirementWrapper.java
View file

@ -6,7 +6,6 @@
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;
@ -20,22 +19,12 @@ import org.navalplanner.business.resources.entities.CriterionWithItsType;
*
* @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;
}
public class CriterionRequirementWrapper implements INewObject {
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;
@ -46,27 +35,21 @@ public class CriterionRequirementDTO implements INewObject {
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) {
public CriterionRequirementWrapper(CriterionRequirement criterionRequirement,
boolean isNewObject) {
this.criterionAndType = "";
this.setCriterionRequirement(criterionRequirement);
this.setType(criterionRequirement);
this.setValid(criterionRequirement);
this.initType(criterionRequirement);
this.initValid(criterionRequirement);
this.setNewObject(isNewObject);
Criterion criterion = criterionRequirement.getCriterion();
CriterionType type = criterion.getType();
setCriterionWithItsType(new CriterionWithItsType(type, criterion));
if (!isNewObject) {
Criterion criterion = criterionRequirement.getCriterion();
CriterionType type = criterion.getType();
setCriterionWithItsType(new CriterionWithItsType(type, criterion));
}
}
public CriterionWithItsType getCriterionWithItsType() {
@ -75,6 +58,12 @@ public class CriterionRequirementDTO implements INewObject {
public void setCriterionWithItsType(CriterionWithItsType criterionWithItsType) {
this.criterionWithItsType = criterionWithItsType;
if (criterionWithItsType != null) {
criterionRequirement.setCriterion(criterionWithItsType
.getCriterion());
} else {
criterionRequirement.setCriterion(null);
}
}
public void setCriterionAndType(String criterionAndType) {
@ -115,15 +104,7 @@ public class CriterionRequirementDTO implements INewObject {
return type;
}
public Type _getType() {
if(type.equals(DIRECT)){
return Type.DIRECT;
}else{
return Type.INDIRECT;
}
}
private void setType(CriterionRequirement criterionRequirement){
private void initType(CriterionRequirement criterionRequirement) {
if(criterionRequirement instanceof DirectCriterionRequirement){
type = DIRECT;
}else if(criterionRequirement instanceof IndirectCriterionRequirement){
@ -131,14 +112,6 @@ public class CriterionRequirementDTO implements INewObject {
}
}
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;
}
@ -153,9 +126,10 @@ public class CriterionRequirementDTO implements INewObject {
public void setValid(Boolean valid) {
this.valid = valid;
((IndirectCriterionRequirement) criterionRequirement).setIsValid(valid);
}
public void setValid(CriterionRequirement requirement) {
private void initValid(CriterionRequirement requirement) {
this.valid = true;
if(criterionRequirement instanceof IndirectCriterionRequirement){
this.valid = ((IndirectCriterionRequirement)criterionRequirement).isIsValid();
@ -178,16 +152,8 @@ public class CriterionRequirementDTO implements INewObject {
}
}
public void setFlagState(FlagState flagState) {
this.flagState = flagState;
}
public FlagState getFlagState() {
return flagState;
}
public boolean isUpdatable(){
return (isNewObject() || getFlagState().equals(FlagState.RETRIEVED));
return isNewObject();
}
public boolean isUnmodifiable(){

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

@ -6,6 +6,7 @@
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;
@ -18,13 +19,23 @@ public interface IAssignedCriterionRequirementToOrderElementModel {
OrderElement getOrderElement();
void setOrderElement(OrderElement orderElement);
void init(OrderElement orderElement);
void assignCriterionRequirementDTO();
void deleteCriterionRequirementDTO(CriterionRequirementDTO requirement);
void assignCriterionRequirementWrapper();
void deleteCriterionRequirementWrapper(
CriterionRequirementWrapper requirement);
void confirm()throws ValidationException;
void setOrderModel(IOrderModel orderModel);
List<CriterionRequirementDTO> getCriterionRequirementDTOs();
List<CriterionRequirementWrapper> getCriterionRequirementWrappers();
List<CriterionWithItsType> getCriterionWithItsTypes();
boolean canAddCriterionRequirement(CriterionRequirementDTO requirement,CriterionWithItsType criterionAndType);
void setValidCriterionRequirementDTO(CriterionRequirementDTO requirement, boolean valid);
CriterionRequirementDTO updateRetrievedCriterionRequirement(CriterionRequirementDTO requirementDTO);
boolean canSetCriterionWithItsType(
CriterionRequirementWrapper requirementWrapper,
CriterionWithItsType criterionAndType);
CriterionRequirementWrapper validateWrappers();
void setValidCriterionRequirementWrapper(
CriterionRequirementWrapper requirement, boolean valid);
}

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

@ -25,23 +25,23 @@
<hbox align="center">
<separator bar="false" spacing="40px" orient="horizontal"/>
<separator bar="false" spacing="20px" orient="vertical"/>
<button onClick="assignedCriterionRequirementController.addCriterionRequirementDTO();"
<button onClick="assignedCriterionRequirementController.addCriterionRequirementWrapper();"
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}">
model="@{assignedCriterionRequirementController.criterionRequirementWrappers}">
<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}">
<row self="@{each='criterionRequirementWrapper'}" value="@{criterionRequirementWrapper}">
<hbox>
<bandbox width="500px"
visible ="@{criterionRequirementDTO.updatable}"
value = "@{criterionRequirementDTO.criterionAndType}">
visible ="@{criterionRequirementWrapper.updatable}"
value = "@{criterionRequirementWrapper.criterionAndType}">
<bandpopup>
<listbox width="500px" height="150px" fixedLayout="true"
model="@{assignedCriterionRequirementController.criterionWithItsTypes}"
@ -58,23 +58,23 @@
</listbox>
</bandpopup>
</bandbox>
<label visible="@{criterionRequirementDTO.unmodifiable}"
value="@{criterionRequirementDTO.criterionAndType}"/>
<label visible="@{criterionRequirementWrapper.unmodifiable}"
value="@{criterionRequirementWrapper.criterionAndType}"/>
</hbox>
<label value="@{criterionRequirementDTO.type}"/>
<label value="@{criterionRequirementWrapper.type}"/>
<hbox>
<button visible = "@{criterionRequirementDTO.direct}"
<button visible = "@{criterionRequirementWrapper.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}"
<button visible = "@{criterionRequirementWrapper.indirectInvalid}"
label = "${i18n:_('Validate')}"
onClick = "assignedCriterionRequirementController.validate(self.parent.parent.value);">
</button>
<button visible = "@{criterionRequirementDTO.indirectValid}"
<button visible = "@{criterionRequirementWrapper.indirectValid}"
label = "${i18n:_('Invalidate')}"
onClick = "assignedCriterionRequirementController.invalidate(self.parent.parent.value);">
</button>