/*
* This file is part of LibrePlan
*
* Copyright (C) 2009-2010 Fundación para o Fomento da Calidade Industrial e
* Desenvolvemento Tecnolóxico de Galicia
* Copyright (C) 2010-2011 Igalia, S.L.
*
* 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/>.
*/
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package org.libreplan.web.resources.worker;
import static org.libreplan.web.I18nHelper._;
import static org.libreplan.web.common.InvalidInputsChecker.isInvalid;
import static org.libreplan.web.common.InvalidInputsChecker.thereAreInvalidInputsOn;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.libreplan.business.common.exceptions.ValidationException;
import org.libreplan.business.common.exceptions.ValidationException.InvalidValue;
import org.libreplan.business.resources.entities.Criterion;
import org.libreplan.business.resources.entities.CriterionSatisfaction;
import org.libreplan.business.resources.entities.CriterionWithItsType;
import org.libreplan.business.resources.entities.Worker;
import org.libreplan.business.workreports.entities.WorkReportLine;
import org.libreplan.web.common.ConstraintChecker;
import org.libreplan.web.common.IMessagesForUser;
import org.libreplan.web.common.Level;
import org.libreplan.web.common.MessagesForUser;
import org.libreplan.web.common.Util;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.WrongValueException;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.InputEvent;
import org.zkoss.zk.ui.event.KeyEvent;
import org.zkoss.zk.ui.event.MouseEvent;
import org.zkoss.zk.ui.util.GenericForwardComposer;
import org.zkoss.zul.Bandbox;
import org.zkoss.zul.Checkbox;
import org.zkoss.zul.Column;
import org.zkoss.zul.Constraint;
import org.zkoss.zul.Datebox;
import org.zkoss.zul.Grid;
import org.zkoss.zul.Hbox;
import org.zkoss.zul.ListModel;
import org.zkoss.zul.ListModelExt;
import org.zkoss.zul.Listbox;
import org.zkoss.zul.Listitem;
import org.zkoss.zul.Row;
import org.zkoss.zul.Rows;
import org.zkoss.zul.SimpleListModel;
/**
* Controller for {@link Criterion} worker <br />
* @author Susana Montes Pedreira <smontes@wirelessgalicia.com>
*/
public class CriterionsController extends GenericForwardComposer {
private IAssignedCriterionsModel assignedCriterionsModel;
private Checkbox criterionFilterCheckbox;
private Grid listingCriterions;
private IMessagesForUser messages;
private Component messagesContainer;
CriterionsController(IWorkerModel workerModel) {
assignedCriterionsModel = workerModel.getAssignedCriterionsModel();
}
@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);
criterionFilterCheckbox.setChecked(false);
}
public IAssignedCriterionsModel getModel(){
return this.assignedCriterionsModel;
}
public void prepareForEdit(Worker worker) {
this.assignedCriterionsModel.prepareForEdit(worker);
reload();
}
public void prepareForCreate(Worker worker) {
this.assignedCriterionsModel.prepareForCreate(worker);
}
public List<CriterionSatisfactionDTO> getCriterionSatisfactionDTOs() {
List<CriterionSatisfactionDTO> list = new ArrayList<CriterionSatisfactionDTO>();
if(criterionFilterCheckbox.isChecked()) {
list.addAll(assignedCriterionsModel.getFilterCriterionSatisfactions());
}else{
list.addAll(assignedCriterionsModel.getAllCriterionSatisfactions());
}
return list;
}
public void addCriterionSatisfaction() {
assignedCriterionsModel.addCriterionSatisfaction();
reload();
}
public List<CriterionWithItsType> getCriterionWithItsTypes(){
return assignedCriterionsModel.getCriterionWithItsType();
}
public List<CriterionWithItsType> getCriterionWorkersWithItsTypes() {
return assignedCriterionsModel.getCriterionWorkersWithItsType();
}
public void reload() {
Util.reloadBindings(listingCriterions);
forceSortGridSatisfaction();
}
public void forceSortGridSatisfaction() {
Column column = (Column) listingCriterions.getColumns().getFirstChild();
ListModelExt model = (ListModelExt) listingCriterions.getModel();
if (model != null) {
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){
assignedCriterionsModel.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("");
}
}
public void setCriterionWithItsType(CriterionWithItsType criterionAndType,
CriterionSatisfactionDTO satisfaction,Bandbox bandbox) throws WrongValueException{
this.assignedCriterionsModel.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(assignedCriterionsModel.checkSameCriterionAndSameInterval(satisfaction)){
throw new WrongValueException(comp,
_("Criterion already assigned"));
}
if(assignedCriterionsModel.checkNotAllowSimultaneousCriterionsPerResource(satisfaction)){
throw new WrongValueException(comp,
_("This criterion type cannot have multiple values in the same period"));
}
}
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 {
validateStartDate(comp,value);
}
};
}
private void validateStartDate(Component comp, Object value){
CriterionSatisfactionDTO criterionSatisfactionDTO =
(CriterionSatisfactionDTO)((Row) comp.getParent()).getValue();
if(value == null) {
throw new WrongValueException(comp,
_("cannot be empty"));
}
if(!criterionSatisfactionDTO.isLessToEndDate((Date) value)){
throw new WrongValueException(comp,
_("Invalid Start Date. New Start Date must be earlier than End Date"));
}else if(!criterionSatisfactionDTO.isPreviousStartDate((Date) value)){
throw new WrongValueException(
comp,
_("Start date is not valid, the new start date must be previous the current start date"));
}
}
public Constraint validateEndDate(){
return new Constraint() {
@Override
public void validate(Component comp, Object value)
throws WrongValueException {
validateEndDate(comp,value);
}
};
}
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 after start date"));
}else if(!criterionSatisfactionDTO.isPostEndDate((Date) value)){
throw new WrongValueException(comp,
_("Invaldid End Date. New End Date must be after 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);
messages.showInvalidValues(e);
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<Row> 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.getRootBean();
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.getPropertyPath();
if (CriterionSatisfactionDTO.START_DATE.equals(propertyName)) {
// Locate TextboxResource
Datebox startDate = getStartDatebox(row);
// Value is incorrect, clear
startDate.setValue(null);
throw new WrongValueException(startDate,
_("cannot be empty"));
}
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,
_("cannot be empty"));
}
}
}
}
/**
* Locates which {@link row} is bound to {@link WorkReportLine} in
* rows
*
* @param Rows
* @param CriterionSatisfactionDTO
* @return
*/
private Row findRowOfCriterionSatisfactionDTO(Rows rows,
CriterionSatisfactionDTO satisfactionDTO) {
List<Row> listRows = (List<Row>) 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 validateConstraints() {
ConstraintChecker.isValid(self);
}
public void onChangingText(Event event) {
Bandbox bd = (Bandbox) event.getTarget();
final String inputText = ((InputEvent) event).getValue();
Listbox listbox = (Listbox) bd.getFirstChild().getFirstChild();
listbox.setModel(getSubModel(inputText));
listbox.invalidate();
bd.open();
}
public void onCtrlKey(Event event) {
Bandbox bd = (Bandbox) event.getTarget();
Listbox listbox = (Listbox) bd.getFirstChild().getFirstChild();
List<Listitem> items = listbox.getItems();
if (!items.isEmpty()) {
listbox.setSelectedIndex(0);
items.get(0).setFocus(true);
}
}
private ListModel getSubModel(String text) {
List<CriterionWithItsType> list = new ArrayList<CriterionWithItsType>();
text = text.trim().toLowerCase();
for (CriterionWithItsType criterion : this.getCriterionWithItsTypes()) {
if ((criterion.getNameHierarchy().toLowerCase()
.contains(text) || criterion.getType().getName()
.toLowerCase().contains(text))) {
list.add(criterion);
}
}
return new SimpleListModel(list);
}
public void onOK(KeyEvent event) {
Component listitem = event.getReference();
if (listitem instanceof Listitem) {
Bandbox bandbox = (Bandbox) listitem.getParent().getParent()
.getParent();
CriterionSatisfactionDTO criterionSatisfactionDTO = (CriterionSatisfactionDTO) ((Row) bandbox
.getParent().getParent()).getValue();
selectCriterionAndType((Listitem) listitem, bandbox,
criterionSatisfactionDTO);
bandbox.close();
}
}
public void onClick(MouseEvent event) {
Component listitem = event.getTarget();
if (listitem instanceof Listitem) {
Bandbox bandbox = (Bandbox) listitem.getParent().getParent()
.getParent();
bandbox.close();
}
}
}