diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/CalendarExceptionTypeDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/CalendarExceptionTypeDAO.java index 134ef7611..37d41ba6a 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/CalendarExceptionTypeDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/CalendarExceptionTypeDAO.java @@ -22,18 +22,24 @@ package org.navalplanner.business.calendars.daos; import java.util.List; +import org.apache.commons.lang.StringUtils; import org.hibernate.Criteria; import org.hibernate.criterion.Restrictions; +import org.navalplanner.business.calendars.entities.CalendarException; import org.navalplanner.business.calendars.entities.CalendarExceptionType; import org.navalplanner.business.common.daos.IntegrationEntityDAO; +import org.navalplanner.business.common.exceptions.InstanceNotFoundException; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Repository; +import org.springframework.transaction.annotation.Propagation; +import org.springframework.transaction.annotation.Transactional; /** * DAO for {@link CalendarExceptionType} * * @author Manuel Rego Casasnovas + * @author Diego Pino Garcia */ @Repository @Scope(BeanDefinition.SCOPE_SINGLETON) @@ -50,4 +56,56 @@ public class CalendarExceptionTypeDAO extends return (list.size() == 1); } + @Override + public List getAll() { + return list(CalendarExceptionType.class); + } + + @Override + public boolean hasCalendarExceptions(CalendarExceptionType type) { + return !getCalendarExceptions(type).isEmpty(); + } + + private List getCalendarExceptions(CalendarExceptionType type) { + Criteria c = getSession().createCriteria(CalendarException.class); + c.add(Restrictions.eq("type.id", type.getId())); + return c.list(); + } + + @Override + @Transactional(readOnly = true, propagation = Propagation.REQUIRES_NEW) + public boolean existsByNameAnotherTransaction(String name) { + return existsByName(name); + } + + @Override + public boolean existsByName(String name) { + try { + findByName(name); + return true; + } catch (InstanceNotFoundException e) { + return false; + } + } + + @Override + @Transactional(readOnly = true) + public CalendarExceptionType findByName(String name) throws InstanceNotFoundException { + if (StringUtils.isBlank(name)) { + throw new InstanceNotFoundException(null, CalendarExceptionType.class.getName()); + } + + CalendarExceptionType calendarExceptionType = (CalendarExceptionType) getSession().createCriteria( + CalendarExceptionType.class).add( + Restrictions.eq("name", name.trim()).ignoreCase()) + .uniqueResult(); + + if (calendarExceptionType == null) { + throw new InstanceNotFoundException(name, CalendarExceptionType.class.getName()); + } else { + return calendarExceptionType; + } + + } + } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/ICalendarExceptionTypeDAO.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/ICalendarExceptionTypeDAO.java index 0002cc745..eb437dd8a 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/ICalendarExceptionTypeDAO.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/daos/ICalendarExceptionTypeDAO.java @@ -20,17 +20,31 @@ package org.navalplanner.business.calendars.daos; +import java.util.List; + import org.navalplanner.business.calendars.entities.CalendarExceptionType; import org.navalplanner.business.common.daos.IIntegrationEntityDAO; +import org.navalplanner.business.common.exceptions.InstanceNotFoundException; /** * Contract for {@link CalendarExceptionTypeDAO} * * @author Manuel Rego Casasnovas + * @author Diego Pino Garcia */ public interface ICalendarExceptionTypeDAO extends IIntegrationEntityDAO { boolean existsByName(CalendarExceptionType type); + List getAll(); + + boolean hasCalendarExceptions(CalendarExceptionType type); + + boolean existsByNameAnotherTransaction(String name); + + CalendarExceptionType findByName(String name) throws InstanceNotFoundException; + + boolean existsByName(String name); + } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CalendarExceptionType.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CalendarExceptionType.java index e1ea0473d..2903dd1a0 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CalendarExceptionType.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CalendarExceptionType.java @@ -20,10 +20,19 @@ package org.navalplanner.business.calendars.entities; +import static org.navalplanner.business.i18n.I18nHelper._; + +import java.util.EnumMap; + import org.apache.commons.lang.BooleanUtils; +import org.apache.commons.lang.StringUtils; +import org.hibernate.validator.AssertTrue; import org.navalplanner.business.calendars.daos.ICalendarExceptionTypeDAO; import org.navalplanner.business.common.IntegrationEntity; import org.navalplanner.business.common.Registry; +import org.navalplanner.business.common.exceptions.InstanceNotFoundException; +import org.navalplanner.business.workingday.EffortDuration; +import org.navalplanner.business.workingday.EffortDuration.Granularity; /** * Type of an exception day. @@ -32,6 +41,20 @@ import org.navalplanner.business.common.Registry; */ public class CalendarExceptionType extends IntegrationEntity { + private String name; + + private String color; + + // Beware. Not Assignable was intended to mean not over assignable. This + // name is kept in order to not break legacy data + private Boolean notAssignable = Boolean.TRUE; + + private EffortDuration duration = EffortDuration.zero(); + + public static CalendarExceptionType create() { + return create(new CalendarExceptionType()); + } + public static CalendarExceptionType create(String name, String color, Boolean notAssignable) { return create(new CalendarExceptionType(name, color, notAssignable)); @@ -43,17 +66,11 @@ public class CalendarExceptionType extends IntegrationEntity { code); } - private String name; - private String color; - - // Beware. Not Assignable was intended to mean not over assignable. This - // name is kept in order to not break legacy data - private Boolean notAssignable; - /** * Constructor for hibernate. Do not use! */ - public CalendarExceptionType() { + protected CalendarExceptionType() { + } public CalendarExceptionType(String name, String color, @@ -67,10 +84,18 @@ public class CalendarExceptionType extends IntegrationEntity { return name; } + public void setName(String name) { + this.name = name; + } + public String getColor() { return color; } + public void setColor(String color) { + this.color = color; + } + /** * @return If more hours can be assigned on this day. */ @@ -78,8 +103,53 @@ public class CalendarExceptionType extends IntegrationEntity { return BooleanUtils.isFalse(notAssignable); } + public void setOverAssignable(Boolean overAssignable) { + this.notAssignable = !overAssignable; + } + + public String getOverAssignableStr() { + return isOverAssignable() ? _("Yes") : _("No"); + } + + public EffortDuration getDuration() { + return duration; + } + + public String getDurationStr() { + EnumMap values = duration.decompose(); + Integer hours = values.get(Granularity.HOURS); + Integer minutes = values.get(Granularity.MINUTES); + Integer seconds = values.get(Granularity.SECONDS); + return hours + ":" + minutes + ":" + seconds ; + } + + public void setDuration(EffortDuration duration) { + this.duration = duration; + } + @Override protected ICalendarExceptionTypeDAO getIntegrationEntityDAO() { return Registry.getCalendarExceptionTypeDAO(); } + + @AssertTrue(message = "name is already used") + public boolean checkConstraintUniqueName() { + if (StringUtils.isBlank(name)) { + return true; + } + + ICalendarExceptionTypeDAO calendarExceptionTypeDAO = getIntegrationEntityDAO(); + if (isNewObject()) { + return !calendarExceptionTypeDAO.existsByNameAnotherTransaction( + name); + } else { + try { + CalendarExceptionType calendarExceptionType = calendarExceptionTypeDAO.findByName(name); + return calendarExceptionType.getId().equals(getId()); + } catch (InstanceNotFoundException e) { + return true; + } + } + } + } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/PredefinedCalendarExceptionTypes.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/PredefinedCalendarExceptionTypes.java index 93d1c43da..33a3cf27f 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/PredefinedCalendarExceptionTypes.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/PredefinedCalendarExceptionTypes.java @@ -20,6 +20,9 @@ package org.navalplanner.business.calendars.entities; +import java.util.ArrayList; +import java.util.List; + /** * Defines the default {@link CalendarExceptionType}. @@ -46,4 +49,14 @@ public enum PredefinedCalendarExceptionTypes { return calendarExceptionType; } + public static boolean contains(CalendarExceptionType exceptionType) { + PredefinedCalendarExceptionTypes[] predefinedExceptionTypes = PredefinedCalendarExceptionTypes.values(); + for (PredefinedCalendarExceptionTypes each: predefinedExceptionTypes) { + if (each.getCalendarExceptionType().getName().equals(exceptionType.getName())) { + return true; + } + } + return false; + } + } diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/workingday/EffortDuration.java b/navalplanner-business/src/main/java/org/navalplanner/business/workingday/EffortDuration.java index 20f84af36..72c0562a7 100644 --- a/navalplanner-business/src/main/java/org/navalplanner/business/workingday/EffortDuration.java +++ b/navalplanner-business/src/main/java/org/navalplanner/business/workingday/EffortDuration.java @@ -243,4 +243,8 @@ public class EffortDuration implements Comparable { return hours; } + public String toString() { + return getHours() + ":" + getMinutes() + ":" + getSeconds(); + } + } diff --git a/navalplanner-business/src/main/resources/org/navalplanner/business/calendars/entities/Calendars.hbm.xml b/navalplanner-business/src/main/resources/org/navalplanner/business/calendars/entities/Calendars.hbm.xml index 89138ff0e..34c01434a 100644 --- a/navalplanner-business/src/main/resources/org/navalplanner/business/calendars/entities/Calendars.hbm.xml +++ b/navalplanner-business/src/main/resources/org/navalplanner/business/calendars/entities/Calendars.hbm.xml @@ -78,10 +78,11 @@ - - - + + + + diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarEditionController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarEditionController.java index d601e2b9d..80385b1f5 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarEditionController.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/calendars/BaseCalendarEditionController.java @@ -53,6 +53,7 @@ import org.zkoss.zk.ui.WrongValueException; import org.zkoss.zk.ui.event.Event; import org.zkoss.zk.ui.event.EventListener; import org.zkoss.zk.ui.event.Events; +import org.zkoss.zk.ui.event.SelectEvent; import org.zkoss.zk.ui.util.Clients; import org.zkoss.zk.ui.util.GenericForwardComposer; import org.zkoss.zul.Button; @@ -136,10 +137,34 @@ public abstract class BaseCalendarEditionController extends private EffortDurationPicker addEffortDurationPickerAtWorkableTimeRow( Component comp) { EffortDurationPicker result = ensureOnePickerOn(comp); - result.setValue(EffortDuration.zero()); + setEffortDurationPicker(getSelectedExceptionType()); return result; } + private void setEffortDurationPicker(CalendarExceptionType exceptionType) { + EffortDurationPicker durationPicker = getEffortDurationPicker(); + EffortDuration effortDuration = exceptionType != null ? exceptionType + .getDuration() : EffortDuration.zero(); + durationPicker.setValue(effortDuration); + } + + private EffortDurationPicker getEffortDurationPicker() { + Component container = self.getFellowIfAny("exceptionDayWorkableTimeRow"); + List existent = ComponentsFinder + .findComponentsOfType(EffortDurationPicker.class, + container.getChildren()); + return !existent.isEmpty() ? (EffortDurationPicker) existent + .iterator().next() : null; + } + + private CalendarExceptionType getSelectedExceptionType() { + Comboitem selectedItem = exceptionTypes.getSelectedItem(); + if (selectedItem != null) { + return (CalendarExceptionType) selectedItem.getValue(); + } + return null; + } + private EffortDurationPicker ensureOnePickerOn(Component comp) { Component container = comp.getFellow("exceptionDayWorkableTimeRow"); @SuppressWarnings("unchecked") @@ -155,13 +180,36 @@ public abstract class BaseCalendarEditionController extends } } + private Combobox exceptionTypes; + private void prepareExceptionTypeCombo() { - Combobox exceptionTypes = (Combobox) window - .getFellow("exceptionTypes"); - fillExceptionTypesComboAndMakrSelectedItem(exceptionTypes); + exceptionTypes = (Combobox) window.getFellow("exceptionTypes"); + fillExceptionTypesComboAndMarkSelectedItem(exceptionTypes); + addSelectListener(exceptionTypes); } - private void fillExceptionTypesComboAndMakrSelectedItem( + private void addSelectListener(final Combobox exceptionTypes) { + exceptionTypes.addEventListener(Events.ON_SELECT, new EventListener() { + + @Override + public void onEvent(Event event) throws Exception { + Comboitem selectedItem = getSelectedItem((SelectEvent) event); + if (selectedItem != null) { + setEffortDurationPicker(getValue(selectedItem)); + } + } + + private Comboitem getSelectedItem(SelectEvent event) { + return (Comboitem) event.getSelectedItems().iterator().next(); + } + + private CalendarExceptionType getValue(Comboitem item) { + return (CalendarExceptionType) item.getValue(); + } + }); + } + + private void fillExceptionTypesComboAndMarkSelectedItem( Combobox exceptionTypes) { exceptionTypes.getChildren().clear(); CalendarExceptionType type = baseCalendarModel diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/common/CustomMenuController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/common/CustomMenuController.java index 676e24579..83a52a081 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/common/CustomMenuController.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/common/CustomMenuController.java @@ -263,6 +263,7 @@ public class CustomMenuController extends Div implements IMenuItemsRegister { subItem(_("Data Types"),"/advance/advanceTypes.zul", "04-avances.html#id1", subItem(_("Advances"),"/advance/advanceTypes.zul", "04-avances.html#id1"), subItem(_("Criteria"),"/resources/criterions/criterions.zul","02-criterios.html#id1"), + subItem(_("Exception Days"),"/excetiondays/exceptionDays.zul",""), subItem(_("Labels"), "/labels/labelTypes.zul","10-etiquetas.html"), subItem(_("Unit Measures"), "/materials/unitTypes.zul", "11-materiales.html#administraci-n-de-materiais"), subItem(_("Work Hours"),"/costcategories/typeOfWorkHours.zul","14-custos.html#administraci-n-de-horas-traballadas"), diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/common/components/EffortDurationPicker.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/common/components/EffortDurationPicker.java index 986c6d768..d07478a02 100644 --- a/navalplanner-webapp/src/main/java/org/navalplanner/web/common/components/EffortDurationPicker.java +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/common/components/EffortDurationPicker.java @@ -135,6 +135,9 @@ public class EffortDurationPicker extends Hbox { } public void setValue(EffortDuration effortDuration) { + if (effortDuration == null) { + effortDuration = EffortDuration.zero(); + } updateUIWithValuesFrom(effortDuration); } diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/exceptionDays/CalendarExceptionTypeCRUDController.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/exceptionDays/CalendarExceptionTypeCRUDController.java new file mode 100644 index 000000000..b8856d244 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/exceptionDays/CalendarExceptionTypeCRUDController.java @@ -0,0 +1,237 @@ +package org.navalplanner.web.exceptionDays; + +import static org.navalplanner.web.I18nHelper._; + +import java.util.List; + +import org.apache.commons.logging.LogFactory; +import org.navalplanner.business.calendars.entities.CalendarExceptionType; +import org.navalplanner.business.calendars.entities.PredefinedCalendarExceptionTypes; +import org.navalplanner.business.common.exceptions.InstanceNotFoundException; +import org.navalplanner.business.common.exceptions.ValidationException; +import org.navalplanner.business.workingday.EffortDuration; +import org.navalplanner.web.common.IMessagesForUser; +import org.navalplanner.web.common.Level; +import org.navalplanner.web.common.MessagesForUser; +import org.navalplanner.web.common.OnlyOneVisible; +import org.navalplanner.web.common.Util; +import org.navalplanner.web.common.components.EffortDurationPicker; +import org.navalplanner.web.common.components.NewDataSortableGrid; +import org.springframework.beans.factory.annotation.Autowired; +import org.zkoss.util.InvalidValueException; +import org.zkoss.zk.ui.Component; +import org.zkoss.zk.ui.WrongValueException; +import org.zkoss.zk.ui.event.MouseEvent; +import org.zkoss.zk.ui.util.GenericForwardComposer; +import org.zkoss.zul.Button; +import org.zkoss.zul.Checkbox; +import org.zkoss.zul.Grid; +import org.zkoss.zul.Messagebox; +import org.zkoss.zul.Row; +import org.zkoss.zul.Textbox; +import org.zkoss.zul.Window; + +/** + * + * @author Diego Pino + * + */ +public class CalendarExceptionTypeCRUDController extends GenericForwardComposer { + + private static final org.apache.commons.logging.Log LOG = LogFactory + .getLog(CalendarExceptionTypeCRUDController.class); + + @Autowired + private ICalendarExceptionTypeModel calendarExceptionTypeModel; + + private Window listWindow; + + private Window editWindow; + + private Textbox tbName; + + private Textbox tbColor; + + private Checkbox cbNotOverAssignable; + + private EffortDurationPicker edpDuration; + + private OnlyOneVisible visibility; + + private IMessagesForUser messagesForUser; + + private Component messagesContainer; + + @Override + public void doAfterCompose(Component comp) throws Exception { + super.doAfterCompose(comp); + messagesForUser = new MessagesForUser(messagesContainer); + comp.setVariable("controller", this, true); + initializeEditWindowComponents(); + showListWindow(); + } + + private void initializeEffortDurationPicker() { + final CalendarExceptionType exceptionType = getExceptionDayType(); + edpDuration = (EffortDurationPicker) editWindow + .getFellowIfAny("edpDuration"); + edpDuration.bind(new Util.Getter() { + + @Override + public EffortDuration get() { + return exceptionType != null ? exceptionType.getDuration() : null; + } + }, new Util.Setter() { + + @Override + public void set(EffortDuration value) { + if (exceptionType != null) { + exceptionType.setDuration(value); + } + } + }); + } + + private void initializeEditWindowComponents() { + tbName = (Textbox) editWindow.getFellowIfAny("tbName"); + tbColor = (Textbox) editWindow.getFellowIfAny("tbColor"); + cbNotOverAssignable = (Checkbox) editWindow + .getFellowIfAny("cbNotOverAssignable"); + } + + private void showListWindow() { + showWindow(listWindow); + } + + private void showWindow(Window window) { + getVisibility().showOnly(window); + } + + private OnlyOneVisible getVisibility() { + if (visibility == null) { + visibility = new OnlyOneVisible(listWindow, editWindow); + } + return visibility; + } + + private void showEditWindow() { + initializeEffortDurationPicker(); + editWindow.setTitle(_("Edit Exception Day Type")); + showWindow(editWindow); + } + + public void goToCreateForm() { + calendarExceptionTypeModel.initCreate(); + showCreateWindow(); + Util.reloadBindings(editWindow); + } + + private void showCreateWindow() { + initializeEffortDurationPicker(); + editWindow.setTitle(_("Create Exception Day Type")); + showWindow(editWindow); + } + + public CalendarExceptionType getExceptionDayType() { + return calendarExceptionTypeModel.getExceptionDayType(); + } + + public List getExceptionDayTypes() { + return calendarExceptionTypeModel.getExceptionDayTypes(); + } + + public void cancel() { + clearFields(); + showListWindow(); + } + + private void clearFields() { + tbName.setRawValue(""); + tbColor.setRawValue(""); + cbNotOverAssignable.setChecked(Boolean.TRUE); + } + + private boolean save() { + try { + calendarExceptionTypeModel.confirmSave(); + messagesForUser.showMessage(Level.INFO, _("Calendar Exception Type saved")); + return true; + } catch (ValidationException e) { + messagesForUser.showInvalidValues(e); + return false; + } + } + + public void saveAndExit() { + boolean couldSave = save(); + if (couldSave) { + clearFields(); + showListWindow(); + Util.reloadBindings(listWindow); + } + } + + public void saveAndContinue() { + save(); + } + + public void showRemoveConfirmationMessage(MouseEvent event) { + Button button = (Button) event.getTarget(); + Component comp = (Component) event.getTarget(); + CalendarExceptionType exceptionType = (CalendarExceptionType) ((Row) button + .getParent().getParent()).getValue(); + + if (PredefinedCalendarExceptionTypes.contains(exceptionType)) { + throw new WrongValueException(comp, "Cannot remove a predefined Exception Day Type"); + } else { + showRemoveConfirmationMessage(exceptionType); + } + } + + public void showRemoveConfirmationMessage( + CalendarExceptionType exceptionType) { + try { + int status = Messagebox + .show(_("Delete item {0}. Are you sure?", + exceptionType.getName()), _("Delete"), + Messagebox.OK | Messagebox.CANCEL, + Messagebox.QUESTION); + if (Messagebox.OK == status) { + confirmDelete(exceptionType); + Util.reloadBindings(listWindow); + } + } catch (InterruptedException e) { + LOG.error(_("Error on showing delete confirm"), e); + } + } + + public void confirmDelete(CalendarExceptionType exceptionType) { + try { + calendarExceptionTypeModel.confirmDelete(exceptionType); + } catch (InstanceNotFoundException e) { + e.printStackTrace(); + } catch (InvalidValueException e) { + NewDataSortableGrid listExceptionDayTypes = (NewDataSortableGrid) listWindow + .getFellowIfAny("listExceptionDayTypes"); + Row row = findRowByValue(listExceptionDayTypes, exceptionType); + throw new WrongValueException(row, e.getMessage()); + } + } + + private Row findRowByValue(Grid grid, Object value) { + final List rows = grid.getRows().getChildren(); + for (Row row: rows) { + if (row.getValue().equals(value)) { + return row; + } + } + return null; + } + + public void goToEditForm(CalendarExceptionType exceptionType) { + calendarExceptionTypeModel.initEdit(exceptionType); + showEditWindow(); + Util.reloadBindings(editWindow); + } + +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/exceptionDays/CalendarExceptionTypeModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/exceptionDays/CalendarExceptionTypeModel.java new file mode 100644 index 000000000..9a1d28186 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/exceptionDays/CalendarExceptionTypeModel.java @@ -0,0 +1,91 @@ +package org.navalplanner.web.exceptionDays; + +import static org.navalplanner.business.i18n.I18nHelper._; + +import java.util.List; + +import org.apache.commons.lang.Validate; +import org.navalplanner.business.calendars.daos.ICalendarExceptionTypeDAO; +import org.navalplanner.business.calendars.entities.CalendarExceptionType; +import org.navalplanner.business.common.exceptions.InstanceNotFoundException; +import org.navalplanner.business.common.exceptions.ValidationException; +import org.navalplanner.web.common.concurrentdetection.OnConcurrentModification; +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.util.InvalidValueException; + +/** + * + * @author Diego Pino + * + */ +@Service +@Scope(BeanDefinition.SCOPE_PROTOTYPE) +@OnConcurrentModification(goToPage = "/exceptionDays/exceptionDays.zul") +public class CalendarExceptionTypeModel implements ICalendarExceptionTypeModel { + + @Autowired + private ICalendarExceptionTypeDAO calendarExceptionTypeDAO; + + private CalendarExceptionType calendarExceptionType; + + @Override + public void initCreate() { + calendarExceptionType = CalendarExceptionType.create(); + } + + public void initEdit() { + + } + + @Override + public CalendarExceptionType getExceptionDayType() { + return calendarExceptionType; + } + + @Override + @Transactional(readOnly=true) + public List getExceptionDayTypes() { + return calendarExceptionTypeDAO.getAll(); + } + + @Override + @Transactional + public void confirmSave() throws ValidationException { + calendarExceptionTypeDAO.save(calendarExceptionType); + } + + @Override + @Transactional + public void confirmDelete(CalendarExceptionType exceptionType) throws InstanceNotFoundException, InvalidValueException { + if (calendarExceptionTypeDAO.hasCalendarExceptions(exceptionType)) { + throw new InvalidValueException(_("Cannot remove {0}, since it is being used by some Exception Day", exceptionType.getName())); + } + if (!exceptionType.isNewObject()) { + calendarExceptionTypeDAO.remove(exceptionType.getId()); + } + } + + @Override + @Transactional(readOnly = true) + public void initEdit(CalendarExceptionType exceptionType) { + Validate.notNull(exceptionType); + this.calendarExceptionType = getFromDB(exceptionType); + } + + private CalendarExceptionType getFromDB(CalendarExceptionType exceptionType) { + return getFromDB(exceptionType.getId()); + } + + private CalendarExceptionType getFromDB(Long id) { + try { + CalendarExceptionType result = calendarExceptionTypeDAO.find(id); + return result; + } catch (InstanceNotFoundException e) { + throw new RuntimeException(e); + } + } +} diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/exceptionDays/ICalendarExceptionTypeModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/exceptionDays/ICalendarExceptionTypeModel.java new file mode 100644 index 000000000..5535f85a0 --- /dev/null +++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/exceptionDays/ICalendarExceptionTypeModel.java @@ -0,0 +1,29 @@ +package org.navalplanner.web.exceptionDays; + +import java.util.List; + +import org.navalplanner.business.calendars.entities.CalendarExceptionType; +import org.navalplanner.business.common.exceptions.InstanceNotFoundException; +import org.zkoss.util.InvalidValueException; + +/** + * + * @author Diego Pino + * + */ +public interface ICalendarExceptionTypeModel { + + void initCreate(); + + void initEdit(CalendarExceptionType exceptionType); + + List getExceptionDayTypes(); + + CalendarExceptionType getExceptionDayType(); + + void confirmSave(); + + void confirmDelete(CalendarExceptionType exceptionType) + throws InstanceNotFoundException, InvalidValueException; + +} diff --git a/navalplanner-webapp/src/main/resources/metainfo/zk/lang-addon.xml b/navalplanner-webapp/src/main/resources/metainfo/zk/lang-addon.xml index f17920593..ecf3e7433 100755 --- a/navalplanner-webapp/src/main/resources/metainfo/zk/lang-addon.xml +++ b/navalplanner-webapp/src/main/resources/metainfo/zk/lang-addon.xml @@ -23,6 +23,12 @@ label + + effortDurationPicker + org.navalplanner.web.common.components.EffortDurationPicker + hbox + + calendarhighlighteddays org.navalplanner.web.common.components.CalendarHighlightedDays diff --git a/navalplanner-webapp/src/main/webapp/excetiondays/_editExceptionDayType.zul b/navalplanner-webapp/src/main/webapp/excetiondays/_editExceptionDayType.zul new file mode 100644 index 000000000..de31913c2 --- /dev/null +++ b/navalplanner-webapp/src/main/webapp/excetiondays/_editExceptionDayType.zul @@ -0,0 +1,73 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +