From b272c256ba38e2776ff759e561bc574f1edbb6de Mon Sep 17 00:00:00 2001 From: Diego Pino Garcia Date: Mon, 19 Oct 2009 09:37:05 +0200 Subject: [PATCH] ItEr30S06CUAltaMaquina: Assigned criterions to Machine --- .../AssignedMachineCriterionsModel.java | 328 ++++++++++++++++++ .../IAssignedMachineCriterionsModel.java | 64 ++++ .../machine/MachineCRUDController.java | 27 ++ .../web/resources/machine/MachineModel.java | 31 +- .../worker/AssignedCriterionsModel.java | 5 +- .../worker/CriterionsController.java | 294 +++------------- .../worker/CriterionsMachineController.java | 164 +++++++++ .../webapp/resources/machine/_editMachine.zul | 3 + .../resources/machine/_machineCriterions.zul | 72 ++++ 9 files changed, 729 insertions(+), 259 deletions(-) create mode 100644 navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/AssignedMachineCriterionsModel.java create mode 100644 navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/IAssignedMachineCriterionsModel.java create mode 100644 navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/CriterionsMachineController.java create mode 100644 navalplanner-webapp/src/main/webapp/resources/machine/_machineCriterions.zul diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/AssignedMachineCriterionsModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/AssignedMachineCriterionsModel.java new file mode 100644 index 000000000..5c3325df3 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/AssignedMachineCriterionsModel.java @@ -0,0 +1,328 @@ +package org.navalplanner.web.resources.machine; + +import java.util.ArrayList; +import java.util.Date; +import java.util.HashSet; +import java.util.List; +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.resources.daos.ICriterionTypeDAO; +import org.navalplanner.business.resources.daos.IResourceDAO; +import org.navalplanner.business.resources.entities.Criterion; +import org.navalplanner.business.resources.entities.CriterionSatisfaction; +import org.navalplanner.business.resources.entities.CriterionType; +import org.navalplanner.business.resources.entities.CriterionWithItsType; +import org.navalplanner.business.resources.entities.ICriterionType; +import org.navalplanner.business.resources.entities.Interval; +import org.navalplanner.business.resources.entities.Resource; +import org.navalplanner.web.resources.worker.CriterionSatisfactionDTO; +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; +import org.zkoss.zk.ui.WrongValueException; + +/** + * + * @author Susana Montes Pedreira + * @author Diego Pino Garcia + */ + +@Service() +@Scope(BeanDefinition.SCOPE_PROTOTYPE) +public class AssignedMachineCriterionsModel implements IAssignedMachineCriterionsModel { + + private ClassValidator satisfactionValidator = new ClassValidator( + CriterionSatisfactionDTO.class); + + @Autowired + private IResourceDAO resourceDAO; + + @Autowired + private ICriterionTypeDAO criterionTypeDAO; + + private List criterionsWithItsTypes = new ArrayList(); + + private Resource resource; + + private Set criterionSatisfactionDTOs = new HashSet(); + + @Override + @Transactional(readOnly = true) + public void prepareForEdit(Resource resource) { + this.resource = resource; + if (resource != null) { + reattachmentResource(); + initDTOs(); + } + } + + @Override + @Transactional(readOnly = true) + public void reattachmentResource() { + resourceDAO.save(resource); + initializeCriterionSatisfactions(resource.getCriterionSatisfactions()); + } + + private void initializeCriterionSatisfactions( + Set criterionsSatisfaction) { + for (CriterionSatisfaction criterionSatisfaction : criterionsSatisfaction) { + initializeCriterionSatisfaction(criterionSatisfaction); + } + } + + private void initializeCriterionSatisfaction( + CriterionSatisfaction criterionSatisfaction) { + initializeCriterion(criterionSatisfaction.getCriterion()); + } + + private void initializeCriterion(Criterion criterion) { + criterion.getName(); + if (criterion.getParent() != null) { + criterion.getParent().getName(); + } + reattachCriterionType(criterion.getType()); + } + + private void reattachCriterionType(CriterionType criterionType) { + criterionTypeDAO.save(criterionType); + } + + private void initDTOs() { + criterionSatisfactionDTOs = new HashSet(); + for (CriterionSatisfaction criterionSatisfaction : resource + .getCriterionSatisfactions()) { + if (!criterionSatisfaction.isIsDeleted()) { + CriterionSatisfactionDTO dto = new CriterionSatisfactionDTO( + criterionSatisfaction); + criterionSatisfactionDTOs.add(dto); + } + } + } + + @Override + public Set getAllCriterionSatisfactions() { + if (resource == null) { + return new HashSet(); + } + return allSatisfactionsDTO(); + } + + @Override + public Set getFilterCriterionSatisfactions() { + if (resource == null) { + return new HashSet(); + } + return filterSatisfactionsDTO(); + } + + @Override + public void addCriterionSatisfaction() { + CriterionSatisfactionDTO criterionSatisfactionDTO = new CriterionSatisfactionDTO(); + this.criterionSatisfactionDTOs.add(criterionSatisfactionDTO); + } + + private Set allSatisfactionsDTO() { + Set satisfactions = new HashSet(); + for (CriterionSatisfactionDTO criterionSatisfactionDTO : criterionSatisfactionDTOs) { + if (!criterionSatisfactionDTO.isIsDeleted()) { + satisfactions.add(criterionSatisfactionDTO); + } + } + return satisfactions; + } + + private Set filterSatisfactionsDTO() { + Set satisfactions = new HashSet(); + for (CriterionSatisfactionDTO criterionSatisfactionDTO : criterionSatisfactionDTOs) { + if ((!criterionSatisfactionDTO.isIsDeleted()) + && (criterionSatisfactionDTO.isCurrent())) { + satisfactions.add(criterionSatisfactionDTO); + } + } + return satisfactions; + } + + @Override + public void remove(CriterionSatisfactionDTO criterionSatisfactionDTO) { + if (criterionSatisfactionDTO.isIsNewObject()) { + criterionSatisfactionDTOs.remove(criterionSatisfactionDTO); + } else { + criterionSatisfactionDTO.setIsDeleted(true); + } + } + + @Override + @Transactional(readOnly = true) + public List getCriterionWithItsType() { + criterionsWithItsTypes = new ArrayList(); + List listTypes = criterionTypeDAO.getCriterionTypes(); + for (CriterionType criterionType : listTypes) { + Set listCriterion = getDirectCriterions(criterionType); + getCriterionWithItsType(criterionType, listCriterion); + } + return criterionsWithItsTypes; + } + + private void getCriterionWithItsType(CriterionType type, + Set children) { + for (Criterion criterion : children) { + // Create the criterion with its criterionType and its Hierarchy + // label + CriterionWithItsType criterionAndType = new CriterionWithItsType( + type, criterion); + + // Add to the list + criterionsWithItsTypes.add(criterionAndType); + getCriterionWithItsType(type, criterion.getChildren()); + } + } + + private static Set getDirectCriterions( + CriterionType criterionType) { + Set criterions = new HashSet(); + for (Criterion criterion : criterionType.getCriterions()) { + if (criterion.getParent() == null) { + criterions.add(criterion); + } + } + return criterions; + } + + @Override + public void setCriterionWithItsType( + CriterionSatisfactionDTO criterionSatisfactionDTO, + CriterionWithItsType criterionAndType) throws WrongValueException { + criterionSatisfactionDTO.setCriterionWithItsType(criterionAndType); + } + + @Override + public boolean checkSameCriterionAndSameInterval( + CriterionSatisfactionDTO satisfaction) { + return existSameCriterionAndInterval(satisfaction); + } + + @Override + public boolean checkNotAllowSimultaneousCriterionsPerResource( + CriterionSatisfactionDTO satisfaction) { + ICriterionType type = satisfaction.getCriterionWithItsType() + .getType(); + if (type.isAllowSimultaneousCriterionsPerResource()) { + return false; + } + return existSameCriterionTypeAndInterval(satisfaction); + } + + private boolean existSameCriterionTypeAndInterval( + CriterionSatisfactionDTO satisfaction) { + for (CriterionSatisfactionDTO otherSatisfaction : criterionSatisfactionDTOs) { + if ((!otherSatisfaction.equals(satisfaction)) + && (sameCriterionType(otherSatisfaction, satisfaction)) + && (sameInterval(otherSatisfaction, satisfaction))) { + return true; + } + } + return false; + } + + private boolean existSameCriterionAndInterval( + CriterionSatisfactionDTO satisfaction) { + for (CriterionSatisfactionDTO otherSatisfaction : criterionSatisfactionDTOs) { + if ((!otherSatisfaction.equals(satisfaction)) + && (sameCriterion(otherSatisfaction, satisfaction)) + && (sameInterval(otherSatisfaction, satisfaction))) { + return true; + } + } + return false; + } + + private boolean sameCriterion(CriterionSatisfactionDTO otherSatisfaction, + CriterionSatisfactionDTO satisfaction) { + if (otherSatisfaction.getCriterionWithItsType() == null) + return false; + Criterion otherCriterion = otherSatisfaction.getCriterionWithItsType() + .getCriterion(); + if (otherCriterion.getId().equals( + satisfaction.getCriterionWithItsType().getCriterion().getId())) + return true; + return false; + } + + private boolean sameCriterionType( + CriterionSatisfactionDTO otherSatisfaction, + CriterionSatisfactionDTO satisfaction) { + if (otherSatisfaction.getCriterionWithItsType() == null) + return false; + ICriterionType criterionType = otherSatisfaction + .getCriterionWithItsType().getType(); + if (criterionType.equals(satisfaction.getCriterionWithItsType() + .getType())) + return true; + return false; + } + + private boolean sameInterval(CriterionSatisfactionDTO otherSatisfaction, + CriterionSatisfactionDTO satisfaction) { + if (otherSatisfaction.getStartDate() == null) + return false; + Interval otherInterval = otherSatisfaction.getInterval(); + if (satisfaction.overlapsWith(otherInterval)) + return true; + return false; + } + + public void save() throws ValidationException { + InvalidValue[] invalidValues; + for (CriterionSatisfactionDTO satisfactionDTO : this.criterionSatisfactionDTOs) { + invalidValues = satisfactionValidator + .getInvalidValues(satisfactionDTO); + if (invalidValues.length > 0) + throw new ValidationException(invalidValues); + save(satisfactionDTO); + } + System.out.println("### assignedMachine.save: " + + resource.getCriterionSatisfactions()); + } + + private void save(CriterionSatisfactionDTO satisfactionDTO) { + if (satisfactionDTO.isIsNewObject()) { + addNewSatisfaction(satisfactionDTO); + } else { + if (satisfactionDTO.isIsDeleted()) { + removeSatisfaction(satisfactionDTO); + } else { + updateSatisfaction(satisfactionDTO); + } + } + } + + private void addNewSatisfaction(CriterionSatisfactionDTO satisfactionDTO) { + Interval interval = satisfactionDTO.getInterval(); + resource.addSatisfaction(satisfactionDTO.getCriterionWithItsType(), + interval); + } + + private void removeSatisfaction(CriterionSatisfactionDTO satisfactionDTO) { + CriterionSatisfaction satisfaction = satisfactionDTO + .getCriterionSatisfaction(); + satisfaction.setIsDeleted(true); + } + + private void updateSatisfaction(CriterionSatisfactionDTO satisfactionDTO) { + CriterionSatisfaction satisfaction = satisfactionDTO + .getCriterionSatisfaction(); + Criterion newCriterion = satisfactionDTO.getCriterionWithItsType() + .getCriterion(); + Date newStartDate = satisfactionDTO.getStartDate(); + Date newEndDate = satisfactionDTO.getEndDate(); + satisfaction.setCriterion(newCriterion); + satisfaction.setStartDate(newStartDate); + satisfaction.setEndDate(newEndDate); + } + +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/IAssignedMachineCriterionsModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/IAssignedMachineCriterionsModel.java new file mode 100644 index 000000000..f11b8d905 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/IAssignedMachineCriterionsModel.java @@ -0,0 +1,64 @@ +/* + * This file is part of ###PROJECT_NAME### + * + * Copyright (C) 2009 Fundación para o Fomento da Calidade Industrial e + * Desenvolvemento Tecnolóxico de Galicia + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package org.navalplanner.web.resources.machine; + +import java.util.List; +import java.util.Set; + +import org.navalplanner.business.common.exceptions.ValidationException; +import org.navalplanner.business.resources.entities.CriterionWithItsType; +import org.navalplanner.business.resources.entities.Resource; +import org.navalplanner.web.resources.worker.CriterionSatisfactionDTO; +import org.zkoss.zk.ui.WrongValueException; + +/** + * + * @author Susana Montes Pedreira + * @author Diego Pino Garcia + */ +public interface IAssignedMachineCriterionsModel { + + void addCriterionSatisfaction(); + + public boolean checkNotAllowSimultaneousCriterionsPerResource( + CriterionSatisfactionDTO satisfaction); + + public boolean checkSameCriterionAndSameInterval( + CriterionSatisfactionDTO satisfaction); + + Set getAllCriterionSatisfactions(); + + List getCriterionWithItsType(); + + Set getFilterCriterionSatisfactions(); + + void prepareForEdit(Resource resource); + + void reattachmentResource(); + + void remove(CriterionSatisfactionDTO criterionSatisfactionDTO); + + void save() throws ValidationException; + + public void setCriterionWithItsType( + CriterionSatisfactionDTO criterionSatisfactionDTO, + CriterionWithItsType criterionAndType) throws WrongValueException; +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineCRUDController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineCRUDController.java index cc2c25aab..51c317cc8 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineCRUDController.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineCRUDController.java @@ -32,6 +32,8 @@ import org.navalplanner.web.common.MessagesForUser; import org.navalplanner.web.common.OnlyOneVisible; import org.navalplanner.web.common.Util; import org.navalplanner.web.common.entrypoints.IURLHandlerRegistry; +import org.navalplanner.web.resources.worker.CriterionsController; +import org.navalplanner.web.resources.worker.CriterionsMachineController; import org.zkoss.zk.ui.Component; import org.zkoss.zk.ui.util.GenericForwardComposer; import org.zkoss.zul.api.Window; @@ -57,6 +59,8 @@ public class MachineCRUDController extends GenericForwardComposer { private Component messagesContainer; + private CriterionsMachineController criterionsController; + public MachineCRUDController() { } @@ -66,9 +70,22 @@ public class MachineCRUDController extends GenericForwardComposer { super.doAfterCompose(comp); comp.setVariable("controller", this, true); messagesForUser = new MessagesForUser(messagesContainer); + setupCriterionsController(); showListWindow(); } + private void setupCriterionsController() throws Exception { + final Component comp = editWindow.getFellowIfAny("criterionsContainer"); + criterionsController = new CriterionsMachineController(); + criterionsController.doAfterCompose(comp); + } + + private CriterionsController getCriterionsController() { + return (CriterionsController) editWindow.getFellow( + "criterionsContainer").getAttribute( + "assignedCriterionsController"); + } + private void showListWindow() { getVisibility().showOnly(listWindow); } @@ -91,8 +108,15 @@ public class MachineCRUDController extends GenericForwardComposer { getVisibility().showOnly(editWindow); } + /** + * Loads {@link Machine} into model, shares loaded {@link Machine} with + * {@link CriterionsController} + * + * @param machine + */ public void goToEditForm(Machine machine) { machineModel.initEdit(machine); + criterionsController.prepareForEdit(machineModel.getMachine()); editWindow.setTitle(_("Edit machine")); showEditWindow(); Util.reloadBindings(editWindow); @@ -101,6 +125,9 @@ public class MachineCRUDController extends GenericForwardComposer { public void save() { validate(); try { + if (criterionsController != null) { + criterionsController.save(); + } machineModel.confirmSave(); goToList(); messagesForUser.showMessage(Level.INFO, _("Machine saved")); diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineModel.java index 5fac30d4a..2cf2bcb33 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/machine/MachineModel.java @@ -21,6 +21,7 @@ package org.navalplanner.web.resources.machine; import java.util.List; +import java.util.Set; import org.apache.commons.lang.Validate; import org.hibernate.validator.ClassValidator; @@ -29,6 +30,8 @@ import org.navalplanner.business.common.exceptions.InstanceNotFoundException; import org.navalplanner.business.common.exceptions.ValidationException; import org.navalplanner.business.resources.daos.IMachineDAO; import org.navalplanner.business.resources.daos.IResourceDAO; +import org.navalplanner.business.resources.entities.Criterion; +import org.navalplanner.business.resources.entities.CriterionSatisfaction; import org.navalplanner.business.resources.entities.Machine; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.config.BeanDefinition; @@ -76,6 +79,8 @@ public class MachineModel implements IMachineModel { if (invalidValues.length > 0) { throw new ValidationException(invalidValues); } + System.out.println("### criterionSatisfactions: " + + machine.getCriterionSatisfactions().size()); resourceDAO.save(machine); } @@ -92,9 +97,33 @@ public class MachineModel implements IMachineModel { private Machine getFromDB(Long id) { try { - return (Machine) resourceDAO.find(id); + Machine machine = (Machine) resourceDAO.find(id); + initializeCriterionsSatisfactions(machine + .getCriterionSatisfactions()); + return machine; } catch (InstanceNotFoundException e) { throw new RuntimeException(e); } } + + private void initializeCriterionsSatisfactions( + Set criterionSatisfactions) { + for (CriterionSatisfaction criterionSatisfaction : criterionSatisfactions) { + initializeCriterionSatisfaction(criterionSatisfaction); + } + } + + private void initializeCriterionSatisfaction( + CriterionSatisfaction criterionSatisfaction) { + initializeCriterion(criterionSatisfaction.getCriterion()); + } + + private void initializeCriterion(Criterion criterion) { + criterion.getName(); + criterion.getName(); + if (criterion.getParent() != null) { + criterion.getParent().getName(); + } + } + } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/AssignedCriterionsModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/AssignedCriterionsModel.java index ec5defa26..320ed87ab 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/AssignedCriterionsModel.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/AssignedCriterionsModel.java @@ -9,8 +9,8 @@ import java.util.ArrayList; import java.util.Date; import java.util.HashSet; import java.util.List; - import java.util.Set; + import org.hibernate.validator.ClassValidator; import static org.navalplanner.web.I18nHelper._; import org.hibernate.validator.InvalidValue; @@ -32,14 +32,13 @@ import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.zkoss.zk.ui.WrongValueException; -import org.zkoss.zul.Listbox; /** * * @author Susana Montes Pedreira */ -@Service +@Service() @Scope(BeanDefinition.SCOPE_PROTOTYPE) public class AssignedCriterionsModel implements IAssignedCriterionsModel { diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/CriterionsController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/CriterionsController.java index 6854a3e7c..cd3fb8985 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/CriterionsController.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/CriterionsController.java @@ -4,38 +4,26 @@ */ package org.navalplanner.web.resources.worker; -import java.util.ArrayList; +import static org.navalplanner.web.I18nHelper._; + import java.util.Date; import java.util.List; import java.util.Set; -import org.hibernate.validator.InvalidValue; + +import org.navalplanner.business.common.exceptions.ValidationException; +import org.navalplanner.business.resources.entities.CriterionWithItsType; +import org.navalplanner.business.resources.entities.Worker; import org.navalplanner.web.common.Util; import org.zkoss.zk.ui.Component; import org.zkoss.zk.ui.WrongValueException; - -import org.zkoss.zul.Constraint; -import static org.navalplanner.web.I18nHelper._; -import org.navalplanner.business.common.exceptions.ValidationException; -import org.navalplanner.business.resources.entities.CriterionSatisfaction; -import static org.navalplanner.web.common.InvalidInputsChecker.thereAreInvalidInputsOn; -import static org.navalplanner.web.common.InvalidInputsChecker.isInvalid; -import org.navalplanner.business.resources.entities.CriterionWithItsType; -import org.navalplanner.business.resources.entities.Worker; -import org.navalplanner.web.common.IMessagesForUser; -import org.navalplanner.web.common.Level; -import org.navalplanner.web.common.MessagesForUser; import org.zkoss.zk.ui.util.GenericForwardComposer; import org.zkoss.zul.Bandbox; -import org.zkoss.zul.Column; import org.zkoss.zul.Combobox; import org.zkoss.zul.Comboitem; -import org.zkoss.zul.Datebox; +import org.zkoss.zul.Constraint; import org.zkoss.zul.Grid; -import org.zkoss.zul.Hbox; -import org.zkoss.zul.ListModelExt; import org.zkoss.zul.Listitem; import org.zkoss.zul.Row; -import org.zkoss.zul.Rows; /** * @@ -44,48 +32,30 @@ import org.zkoss.zul.Rows; public class CriterionsController extends GenericForwardComposer { private IAssignedCriterionsModel assignedCriterionsModel; - private Combobox comboboxfilter; + private Combobox comboboxFilter; private Grid listingCriterions; - private IMessagesForUser messages; - private Component messagesContainer; - CriterionsController(IWorkerModel workerModel) { - assignedCriterionsModel = workerModel.getAssignedCriterionsModel(); + protected CriterionsController() { } @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("assignedCriterionsController", this, true); - //comboboxFilter = (Combobox) comp.getFellow("comboboxfilter"); - //listingCriterions = (Grid) comp.getFellow("listingCriterions"); - } - - public IAssignedCriterionsModel getModel(){ - return this.assignedCriterionsModel; + comboboxFilter = (Combobox) comp.getFellow("comboboxfilter"); + listingCriterions = (Grid) comp.getFellow("listingCriterions"); } public void prepareForEdit(Worker worker) { this.assignedCriterionsModel.prepareForEdit(worker); - reload(); } - public void prepareForCreate(Worker worker) { - this.assignedCriterionsModel.prepareForCreate(worker); - } - - public List getCriterionSatisfactionDTOs() { - List list = new ArrayList(); - Comboitem comboitem = comboboxfilter.getSelectedItem(); - if((comboitem != null) && (comboitem.getLabel().equals("Currents"))) { - list.addAll(assignedCriterionsModel.getFilterCriterionSatisfactions()); - }else{ - list.addAll(assignedCriterionsModel.getAllCriterionSatisfactions()); - } - return list; + public Set getCriterionSatisfactionDTOs() { + Comboitem comboitem = comboboxFilter.getSelectedItem(); + if((comboitem != null) && (comboitem.getLabel().equals("in force"))) { + return assignedCriterionsModel.getFilterCriterionSatisfactions(); + } + return assignedCriterionsModel.getAllCriterionSatisfactions(); } public void addCriterionSatisfaction() { @@ -99,18 +69,6 @@ public class CriterionsController extends GenericForwardComposer { public void reload() { Util.reloadBindings(listingCriterions); - forceSortGridSatisfaction(); - } - - public void forceSortGridSatisfaction() { - Column column = (Column) listingCriterions.getColumns().getFirstChild(); - ListModelExt model = (ListModelExt) listingCriterions.getModel(); - if ("ascending".equals(column.getSortDirection())) { - model.sort(column.getSortAscending(), true); - } - if ("descending".equals(column.getSortDirection())) { - model.sort(column.getSortDescending(), false); - } } public void remove(CriterionSatisfactionDTO criterionSatisfactionDTO){ @@ -150,14 +108,7 @@ public class CriterionsController extends GenericForwardComposer { } } - public void changeStartDate(Component comp,Date value){ - CriterionSatisfactionDTO criterionSatisfactionDTO = - (CriterionSatisfactionDTO)((Row) comp.getParent()).getValue(); - validateCriterionWithItsType(criterionSatisfactionDTO,comp); - reload(); - } - - public void changeEndDate(Component comp,Date value){ + public void changeDate(Component comp){ CriterionSatisfactionDTO criterionSatisfactionDTO = (CriterionSatisfactionDTO)((Row) comp.getParent()).getValue(); validateCriterionWithItsType(criterionSatisfactionDTO,comp); @@ -169,206 +120,39 @@ public class CriterionsController extends GenericForwardComposer { @Override public void validate(Component comp, Object value) throws WrongValueException { - validateStartDate(comp,value); + CriterionSatisfactionDTO criterionSatisfactionDTO = + (CriterionSatisfactionDTO)((Row) comp.getParent()).getValue(); + if(!criterionSatisfactionDTO.isLessToEndDate((Date) value)){ + throw new WrongValueException(comp, + _("Start date is not valid, the new start date must be lower than the end date")); + }else if(!criterionSatisfactionDTO.isPreviousStartDate((Date) value)){ + throw new WrongValueException(comp, + _("End date is not valid, the new end date must be later the current end date")); + } } }; } - private void validateStartDate(Component comp, Object value){ - CriterionSatisfactionDTO criterionSatisfactionDTO = - (CriterionSatisfactionDTO)((Row) comp.getParent()).getValue(); - if(!criterionSatisfactionDTO.isLessToEndDate((Date) value)){ - throw new WrongValueException(comp, - _("Start date is not valid, the new start date must be lower than the end date")); - }else if(!criterionSatisfactionDTO.isPreviousStartDate((Date) value)){ - throw new WrongValueException(comp, - _("End date is not valid, the new end date must be later the current end date")); - } - } - public Constraint validateEndDate(){ return new Constraint() { @Override public void validate(Component comp, Object value) throws WrongValueException { - validateEndDate(comp,value); + CriterionSatisfactionDTO criterionSatisfactionDTO = + (CriterionSatisfactionDTO)((Row) comp.getParent()).getValue(); + if(!criterionSatisfactionDTO.isGreaterStartDate((Date) value)){ + throw new WrongValueException(comp, + _("End date is not valid, the new end date must be greater than the start date")); + }else if(!criterionSatisfactionDTO.isPostEndDate((Date) value)){ + throw new WrongValueException(comp, + _("End date is not valid, the new end date must be later the current end date")); + } + validateCriterionWithItsType(criterionSatisfactionDTO,comp); } }; } - - private void validateEndDate(Component comp, Object value){ - CriterionSatisfactionDTO criterionSatisfactionDTO = - (CriterionSatisfactionDTO)((Row) comp.getParent()).getValue(); - if(!criterionSatisfactionDTO.isGreaterStartDate((Date) value)){ - throw new WrongValueException(comp, - _("End date is not valid, the new end date must be greater than the start date")); - }else if(!criterionSatisfactionDTO.isPostEndDate((Date) value)){ - throw new WrongValueException(comp, - _("End date is not valid, the new end date must be later the current end date")); - } - } - - /** - * Shows invalid values for {@link CriterionSatisfaction} - * entities - * - * @param e - */ - public boolean validate() throws ValidationException{ - try{ - if(thereAreInvalidInputsOn(this.listingCriterions)){ - showInvalidInputs(); - return false; - } - assignedCriterionsModel.validate(); - reload(); - } catch (ValidationException e) { - showInvalidValues(e); - for (InvalidValue invalidValue : e.getInvalidValues()) { - messages.showMessage(Level.ERROR, invalidValue.getPropertyName()+invalidValue.getMessage()); - return false; - } - } catch (IllegalStateException e) { - messages.showMessage(Level.ERROR,e.getMessage()); - return false; - } - catch (IllegalArgumentException e) { - messages.showMessage(Level.ERROR,e.getMessage()); - return false; - } - return true; - } - - /** - * Shows invalid inputs for {@link CriterionSatisfactionDTO} entities - * - * @param - */ - private void showInvalidInputs(){ - if(listingCriterions != null){ - Rows rows = listingCriterions.getRows(); - List listRows = rows.getChildren(); - for(Row row : listRows){ - //Validate endDate Domain Restricctions. - Datebox endDate = getEndDatebox(row); - if(isInvalid(endDate)){ - validateEndDate(endDate, endDate.getValue()); - } - //Validate startDate Domain Restricctions. - Datebox startDate = getStartDatebox(row); - if(isInvalid(startDate)){ - validateStartDate(startDate, startDate.getValue()); - } - //Validate endDate Domain Restricctions. - Bandbox bandCriterion = getBandType(row); - if(isInvalid(bandCriterion)){ - CriterionSatisfactionDTO satisfactionDTO = - (CriterionSatisfactionDTO)row.getValue(); - validateCriterionWithItsType(satisfactionDTO,bandCriterion); - } - } - } - } - - /** - * Shows invalid values for {@link CriterionSatisfactionDTO} entities - * - * @param e - */ - private void showInvalidValues(ValidationException e) { - for (InvalidValue invalidValue : e.getInvalidValues()) { - Object value = invalidValue.getBean(); - if(value instanceof CriterionSatisfactionDTO){ - validateCriterionSatisfactionDTO(invalidValue, - (CriterionSatisfactionDTO)value); - } - } - } - - /** - * Validates {@link CriterionSatisfactionDTO} data constraints - * - * @param invalidValue - */ - private void validateCriterionSatisfactionDTO(InvalidValue invalidValue, - CriterionSatisfactionDTO satisfactionDTO) { - if(listingCriterions != null){ - - // Find which listItem contains CriterionSatisfaction inside listBox - Row row = findRowOfCriterionSatisfactionDTO(listingCriterions.getRows(), - satisfactionDTO); - - if (row != null) { - String propertyName = invalidValue.getPropertyName(); - - if (CriterionSatisfactionDTO.START_DATE.equals(propertyName)) { - // Locate TextboxResource - Datebox startDate = getStartDatebox(row); - // Value is incorrect, clear - startDate.setValue(null); - throw new WrongValueException(startDate, - _("The start date cannot be null")); - } - if (CriterionSatisfactionDTO.CRITERION_WITH_ITS_TYPE.equals(propertyName)) { - // Locate TextboxResource - Bandbox bandType = getBandType(row); - // Value is incorrect, clear - 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, - CriterionSatisfactionDTO satisfactionDTO) { - List listRows = (List) rows.getChildren(); - for (Row row : listRows) { - if (satisfactionDTO.equals(row.getValue())) { - return row; - } - } - return null; - } - - /** - * Locates {@link Datebox} criterion satisfaction in {@link row} - * - * @param row - * @return - */ - private Datebox getStartDatebox(Row row) { - return (Datebox) (row.getChildren().get(1)); - } - - /** - * Locates {@link Datebox} criterion satisfaction in {@link row} - * - * @param row - * @return - */ - private Datebox getEndDatebox(Row row) { - return (Datebox) (row.getChildren().get(2)); - } - - /** - * Locates {@link Bandbox} criterion satisfaction in {@link row} - * - * @param row - * @return - */ - private Bandbox getBandType(Row row) { - return (Bandbox)((Hbox) row.getChildren().get(0)) - .getChildren().get(0); + public void save() throws ValidationException{ + assignedCriterionsModel.save(); } } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/CriterionsMachineController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/CriterionsMachineController.java new file mode 100644 index 000000000..aabb354a9 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/resources/worker/CriterionsMachineController.java @@ -0,0 +1,164 @@ +/* + * To change this template, choose Tools | Templates + * and open the template in the editor. + */ +package org.navalplanner.web.resources.worker; + +import static org.navalplanner.web.I18nHelper._; + +import java.util.Date; +import java.util.List; +import java.util.Set; + +import org.navalplanner.business.common.exceptions.ValidationException; +import org.navalplanner.business.resources.entities.CriterionWithItsType; +import org.navalplanner.business.resources.entities.Machine; +import org.navalplanner.web.common.Util; +import org.navalplanner.web.resources.machine.IAssignedMachineCriterionsModel; +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.Combobox; +import org.zkoss.zul.Comboitem; +import org.zkoss.zul.Constraint; +import org.zkoss.zul.Grid; +import org.zkoss.zul.Listitem; +import org.zkoss.zul.Row; + +/** + * + * @author Diego Pino García + */ +public class CriterionsMachineController extends GenericForwardComposer { + + private IAssignedMachineCriterionsModel assignedMachineCriterionsModel; + + private Combobox comboboxFilter; + + private Grid listingCriterions; + + public CriterionsMachineController() { + + } + + @Override + public void doAfterCompose(Component comp) throws Exception { + super.doAfterCompose(comp); + comp.setVariable("assignedCriterionsController", this, true); + } + + public void prepareForEdit(Machine machine) { + this.assignedMachineCriterionsModel.prepareForEdit(machine); + } + + public Set getCriterionSatisfactionDTOs() { + Comboitem comboitem = comboboxFilter.getSelectedItem(); + if((comboitem != null) && (comboitem.getLabel().equals("in force"))) { + return assignedMachineCriterionsModel + .getFilterCriterionSatisfactions(); + } + return assignedMachineCriterionsModel.getAllCriterionSatisfactions(); + } + + public void addCriterionSatisfaction() { + assignedMachineCriterionsModel.addCriterionSatisfaction(); + reload(); + } + + public List getCriterionWithItsTypes(){ + return assignedMachineCriterionsModel.getCriterionWithItsType(); + } + + public void reload() { + Util.reloadBindings(listingCriterions); + } + + public void remove(CriterionSatisfactionDTO criterionSatisfactionDTO){ + assignedMachineCriterionsModel.remove(criterionSatisfactionDTO); + reload(); + } + + public void selectCriterionAndType(Listitem item,Bandbox bandbox, + CriterionSatisfactionDTO criterionSatisfactionDTO){ + if(item != null){ + CriterionWithItsType criterionAndType = (CriterionWithItsType)item.getValue(); + bandbox.setValue(criterionAndType.getNameAndType()); + setCriterionWithItsType(criterionAndType,criterionSatisfactionDTO,bandbox); + }else{ + bandbox.setValue(""); + } + bandbox.close(); + } + + public void setCriterionWithItsType(CriterionWithItsType criterionAndType, + CriterionSatisfactionDTO satisfaction,Bandbox bandbox) throws WrongValueException{ + this.assignedMachineCriterionsModel.setCriterionWithItsType( + satisfaction, criterionAndType); + validateCriterionWithItsType(satisfaction,bandbox); + } + + private void validateCriterionWithItsType(CriterionSatisfactionDTO satisfaction, + Component comp) throws WrongValueException{ + if(satisfaction.getCriterionWithItsType() == null) return; + if(satisfaction.getStartDate() == null) return; + if (assignedMachineCriterionsModel + .checkSameCriterionAndSameInterval(satisfaction)) { + throw new WrongValueException(comp, + _("Criterion is not valid, the criterion overlap other criterionSatisfaction whith same criterion")); + } + if (assignedMachineCriterionsModel + .checkNotAllowSimultaneousCriterionsPerResource(satisfaction)) { + throw new WrongValueException(comp, + _("CriterionType is not valid, the criterionType overlap other criterionSatisfaction whith same criterionType")); + } + } + + public void changeDate(Component comp){ + CriterionSatisfactionDTO criterionSatisfactionDTO = + (CriterionSatisfactionDTO)((Row) comp.getParent()).getValue(); + validateCriterionWithItsType(criterionSatisfactionDTO,comp); + reload(); + } + + public Constraint validateStartDate(){ + return new Constraint() { + @Override + public void validate(Component comp, Object value) + throws WrongValueException { + CriterionSatisfactionDTO criterionSatisfactionDTO = + (CriterionSatisfactionDTO)((Row) comp.getParent()).getValue(); + if(!criterionSatisfactionDTO.isLessToEndDate((Date) value)){ + throw new WrongValueException(comp, + _("Start date is not valid, the new start date must be lower than the end date")); + }else if(!criterionSatisfactionDTO.isPreviousStartDate((Date) value)){ + throw new WrongValueException(comp, + _("End date is not valid, the new end date must be later the current end date")); + } + } + }; + } + + public Constraint validateEndDate(){ + return new Constraint() { + @Override + public void validate(Component comp, Object value) + throws WrongValueException { + CriterionSatisfactionDTO criterionSatisfactionDTO = + (CriterionSatisfactionDTO)((Row) comp.getParent()).getValue(); + if(!criterionSatisfactionDTO.isGreaterStartDate((Date) value)){ + throw new WrongValueException(comp, + _("End date is not valid, the new end date must be greater than the start date")); + }else if(!criterionSatisfactionDTO.isPostEndDate((Date) value)){ + throw new WrongValueException(comp, + _("End date is not valid, the new end date must be later the current end date")); + } + validateCriterionWithItsType(criterionSatisfactionDTO,comp); + } + }; + } + + public void save() throws ValidationException{ + assignedMachineCriterionsModel.save(); + } +} diff --git a/navalplanner-webapp/src/main/webapp/resources/machine/_editMachine.zul b/navalplanner-webapp/src/main/webapp/resources/machine/_editMachine.zul index d12d1645e..fb5d29550 100644 --- a/navalplanner-webapp/src/main/webapp/resources/machine/_editMachine.zul +++ b/navalplanner-webapp/src/main/webapp/resources/machine/_editMachine.zul @@ -18,6 +18,7 @@ along with this program. If not, see . --> + @@ -54,6 +55,8 @@ + + diff --git a/navalplanner-webapp/src/main/webapp/resources/machine/_machineCriterions.zul b/navalplanner-webapp/src/main/webapp/resources/machine/_machineCriterions.zul new file mode 100644 index 000000000..dc0ac5360 --- /dev/null +++ b/navalplanner-webapp/src/main/webapp/resources/machine/_machineCriterions.zul @@ -0,0 +1,72 @@ + + + + + + + + + + + + +