package fr.ifremer.reefdb.ui.swing.content.manage.program.programs;
   
   /*
    * #%L
    * Reef DB :: UI
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2014 - 2015 Ifremer
   * %%
   * 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 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/>.
   * #L%
   */
  
  import fr.ifremer.quadrige3.ui.core.dto.referential.StatusDTO;
  import fr.ifremer.reefdb.dto.ErrorDTO;
  import fr.ifremer.reefdb.dto.ReefDbBeanFactory;
  import fr.ifremer.reefdb.dto.ReefDbBeans;
  import fr.ifremer.reefdb.dto.configuration.programStrategy.ProgramDTO;
  import fr.ifremer.reefdb.dto.configuration.programStrategy.StrategyDTO;
  import fr.ifremer.reefdb.dto.referential.DepartmentDTO;
  import fr.ifremer.reefdb.dto.referential.LocationDTO;
  import fr.ifremer.reefdb.dto.referential.PersonDTO;
  import fr.ifremer.reefdb.ui.swing.util.table.AbstractReefDbRowUIModel;
  import org.nuiton.util.beans.Binder;
  import org.nuiton.util.beans.BinderFactory;
  
  import java.util.Collection;
  import java.util.Date;
  import java.util.List;
  
  /**
   * Modele pour le tableau de programmes.
   */
  public class ProgramsTableRowModel extends AbstractReefDbRowUIModel<ProgramDTO, ProgramsTableRowModel> implements ProgramDTO {
  
      private static final Binder<ProgramDTO, ProgramsTableRowModel> FROM_BEAN_BINDER =
              BinderFactory.newBinder(ProgramDTO.class, ProgramsTableRowModel.class);
      private static final Binder<ProgramsTableRowModel, ProgramDTO> TO_BEAN_BINDER =
              BinderFactory.newBinder(ProgramsTableRowModel.class, ProgramDTO.class);
      private boolean currentUserIsManager;
      private boolean strategiesValid = true;
      private boolean locationsValid = true;
  
      /**
       * Constructor.
       */
      public ProgramsTableRowModel() {
          super(FROM_BEAN_BINDER, TO_BEAN_BINDER);
      }
  
      /**
       * <p>isCurrentUserIsManager.</p>
       *
       * @return a boolean.
       */
      public boolean isCurrentUserIsManager() {
          return currentUserIsManager;
      }
  
      /**
       * <p>Setter for the field <code>currentUserIsManager</code>.</p>
       *
       * @param currentUserIsManager a boolean.
       */
      public void setCurrentUserIsManager(boolean currentUserIsManager) {
          this.currentUserIsManager = currentUserIsManager;
      }
  
      /**
       * <p>isStrategiesValid.</p>
       *
       * @return a boolean.
       */
      public boolean isStrategiesValid() {
          return strategiesValid;
      }
  
      /**
       * <p>Setter for the field <code>strategiesValid</code>.</p>
       *
       * @param strategiesValid a boolean.
       */
      public void setStrategiesValid(boolean strategiesValid) {
          this.strategiesValid = strategiesValid;
      }
  
      /**
      * <p>isLocationsValid.</p>
      *
      * @return a boolean.
      */
     public boolean isLocationsValid() {
         return locationsValid;
     }
 
     /**
      * <p>Setter for the field <code>locationsValid</code>.</p>
      *
      * @param locationsValid a boolean.
      */
     public void setLocationsValid(boolean locationsValid) {
         this.locationsValid = locationsValid;
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isEditable() {
         return super.isEditable() && !isReadOnly() && isCurrentUserIsManager();
     }
 
     /**
      * <p>isLocal.</p>
      *
      * @return a boolean.
      */
     public boolean isLocal() {
         return ReefDbBeans.isLocalStatus(getStatus());
     }
 
     /** {@inheritDoc} */
     @Override
     protected ProgramDTO newBean() {
         return ReefDbBeanFactory.newProgramDTO();
     }
 
     /** {@inheritDoc} */
     @Override
     public StatusDTO getStatus() {
         return delegateObject.getStatus();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setStatus(StatusDTO status) {
         delegateObject.setStatus(status);
     }
 
     /** {@inheritDoc} */
     @Override
     public String getCode() {
         return delegateObject.getCode();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setCode(String code) {
         delegateObject.setCode(code);
     }
 
     @Override
     public String getDescription() {
         return delegateObject.getDescription();
     }
 
     @Override
     public void setDescription(String description) {
         delegateObject.setDescription(description);
     }
 
     /** {@inheritDoc} */
     @Override
     public String getName() {
         return delegateObject.getName();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setName(String name) {
         delegateObject.setName(name);
     }
 
     /** {@inheritDoc} */
     @Override
     public String getComment() {
         return delegateObject.getComment();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setComment(String comment) {
         delegateObject.setComment(comment);
     }
 
     /** {@inheritDoc} */
     @Override
     public StrategyDTO getStrategies(int index) {
         return delegateObject.getStrategies(index);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isStrategiesEmpty() {
         return delegateObject.isStrategiesEmpty();
     }
 
     /** {@inheritDoc} */
     @Override
     public int sizeStrategies() {
         return delegateObject.sizeStrategies();
     }
 
     /** {@inheritDoc} */
     @Override
     public void addStrategies(StrategyDTO strategy) {
         delegateObject.addStrategies(strategy);
     }
 
     /** {@inheritDoc} */
     @Override
     public void addAllStrategies(Collection<StrategyDTO> strategy) {
         delegateObject.addAllStrategies(strategy);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeStrategies(StrategyDTO strategy) {
         return delegateObject.removeStrategies(strategy);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeAllStrategies(Collection<StrategyDTO> strategy) {
         return delegateObject.removeAllStrategies(strategy);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsStrategies(StrategyDTO strategy) {
         return delegateObject.containsStrategies(strategy);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsAllStrategies(Collection<StrategyDTO> strategy) {
         return delegateObject.containsAllStrategies(strategy);
     }
 
     /** {@inheritDoc} */
     @Override
     public Collection<StrategyDTO> getStrategies() {
         return delegateObject.getStrategies();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setStrategies(Collection<StrategyDTO> strategy) {
         delegateObject.setStrategies(strategy);
     }
 
     /** {@inheritDoc} */
     @Override
     public LocationDTO getLocations(int index) {
         return delegateObject.getLocations(index);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isLocationsEmpty() {
         return delegateObject.isLocationsEmpty();
     }
 
     /** {@inheritDoc} */
     @Override
     public int sizeLocations() {
         return delegateObject.sizeLocations();
     }
 
     /** {@inheritDoc} */
     @Override
     public void addLocations(LocationDTO location) {
         delegateObject.addLocations(location);
     }
 
     /** {@inheritDoc} */
     @Override
     public void addAllLocations(Collection<LocationDTO> location) {
         delegateObject.addAllLocations(location);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeLocations(LocationDTO location) {
         return delegateObject.removeLocations(location);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeAllLocations(Collection<LocationDTO> location) {
         return delegateObject.removeAllLocations(location);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsLocations(LocationDTO location) {
         return delegateObject.containsLocations(location);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsAllLocations(Collection<LocationDTO> location) {
         return delegateObject.containsAllLocations(location);
     }
 
     /** {@inheritDoc} */
     @Override
     public List<LocationDTO> getLocations() {
         return delegateObject.getLocations();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setLocations(List<LocationDTO> location) {
         delegateObject.setLocations(location);
     }
 
     /** {@inheritDoc} */
     @Override
     public ErrorDTO getErrors(int index) {
         return delegateObject.getErrors(index);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isErrorsEmpty() {
         return delegateObject.isErrorsEmpty();
     }
 
     /** {@inheritDoc} */
     @Override
     public int sizeErrors() {
         return delegateObject.sizeErrors();
     }
 
     /** {@inheritDoc} */
     @Override
     public void addErrors(ErrorDTO errors) {
         delegateObject.addErrors(errors);
     }
 
     /** {@inheritDoc} */
     @Override
     public void addAllErrors(Collection<ErrorDTO> errors) {
         delegateObject.addAllErrors(errors);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeErrors(ErrorDTO errors) {
         return delegateObject.removeErrors(errors);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeAllErrors(Collection<ErrorDTO> errors) {
         return delegateObject.removeAllErrors(errors);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsErrors(ErrorDTO errors) {
         return delegateObject.containsErrors(errors);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsAllErrors(Collection<ErrorDTO> errors) {
         return delegateObject.containsAllErrors(errors);
     }
 
     /** {@inheritDoc} */
     @Override
     public Collection<ErrorDTO> getErrors() {
         return delegateObject.getErrors();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setErrors(Collection<ErrorDTO> errors) {
         delegateObject.setErrors(errors);
     }
 
     /** {@inheritDoc} */
     @Override
     public PersonDTO getManagerPersons(int index) {
         return delegateObject.getManagerPersons(index);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isManagerPersonsEmpty() {
         return delegateObject.isManagerPersonsEmpty();
     }
 
     /** {@inheritDoc} */
     @Override
     public int sizeManagerPersons() {
         return delegateObject.sizeManagerPersons();
     }
 
     /** {@inheritDoc} */
     @Override
     public void addManagerPersons(PersonDTO managerPersons) {
         delegateObject.addManagerPersons(managerPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public void addAllManagerPersons(Collection<PersonDTO> managerPersons) {
         delegateObject.addAllManagerPersons(managerPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeManagerPersons(PersonDTO managerPersons) {
         return delegateObject.removeManagerPersons(managerPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeAllManagerPersons(Collection<PersonDTO> managerPersons) {
         return delegateObject.removeAllManagerPersons(managerPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsManagerPersons(PersonDTO managerPersons) {
         return delegateObject.containsManagerPersons(managerPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsAllManagerPersons(Collection<PersonDTO> managerPersons) {
         return delegateObject.containsAllManagerPersons(managerPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public Collection<PersonDTO> getManagerPersons() {
         return delegateObject.getManagerPersons();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setManagerPersons(Collection<PersonDTO> managerPersons) {
         delegateObject.setManagerPersons(managerPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public PersonDTO getRecorderPersons(int index) {
         return delegateObject.getRecorderPersons(index);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isRecorderPersonsEmpty() {
         return delegateObject.isRecorderPersonsEmpty();
     }
 
     /** {@inheritDoc} */
     @Override
     public int sizeRecorderPersons() {
         return delegateObject.sizeRecorderPersons();
     }
 
     /** {@inheritDoc} */
     @Override
     public void addRecorderPersons(PersonDTO recorderPersons) {
         delegateObject.addRecorderPersons(recorderPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public void addAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
         delegateObject.addAllRecorderPersons(recorderPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeRecorderPersons(PersonDTO recorderPersons) {
         return delegateObject.removeRecorderPersons(recorderPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
         return delegateObject.removeAllRecorderPersons(recorderPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsRecorderPersons(PersonDTO recorderPersons) {
         return delegateObject.containsRecorderPersons(recorderPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
         return delegateObject.containsAllRecorderPersons(recorderPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public Collection<PersonDTO> getRecorderPersons() {
         return delegateObject.getRecorderPersons();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setRecorderPersons(Collection<PersonDTO> recorderPersons) {
         delegateObject.setRecorderPersons(recorderPersons);
     }
 
     /** {@inheritDoc} */
     @Override
     public DepartmentDTO getRecorderDepartments(int index) {
         return delegateObject.getRecorderDepartments(index);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isRecorderDepartmentsEmpty() {
         return delegateObject.isRecorderDepartmentsEmpty();
     }
 
     /** {@inheritDoc} */
     @Override
     public int sizeRecorderDepartments() {
         return delegateObject.sizeRecorderDepartments();
     }
 
     /** {@inheritDoc} */
     @Override
     public void addRecorderDepartments(DepartmentDTO recorderDepartments) {
         delegateObject.addRecorderDepartments(recorderDepartments);
     }
 
     /** {@inheritDoc} */
     @Override
     public void addAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
         delegateObject.addAllRecorderDepartments(recorderDepartments);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeRecorderDepartments(DepartmentDTO recorderDepartments) {
         return delegateObject.removeRecorderDepartments(recorderDepartments);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean removeAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
         return delegateObject.removeAllRecorderDepartments(recorderDepartments);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsRecorderDepartments(DepartmentDTO recorderDepartments) {
         return delegateObject.containsRecorderDepartments(recorderDepartments);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean containsAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
         return delegateObject.containsAllRecorderDepartments(recorderDepartments);
     }
 
     /** {@inheritDoc} */
     @Override
     public Collection<DepartmentDTO> getRecorderDepartments() {
         return delegateObject.getRecorderDepartments();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
         delegateObject.setRecorderDepartments(recorderDepartments);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isStrategiesLoaded() {
         return delegateObject.isStrategiesLoaded();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setStrategiesLoaded(boolean strategiesLoaded) {
         delegateObject.setStrategiesLoaded(strategiesLoaded);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isLocationsLoaded() {
         return delegateObject.isLocationsLoaded();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setLocationsLoaded(boolean locationsLoaded) {
         delegateObject.setLocationsLoaded(locationsLoaded);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isDirty() {
         return delegateObject.isDirty();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setDirty(boolean dirty) {
         delegateObject.setDirty(dirty);
     }
 
     @Override
     public boolean isReadOnly() {
         return delegateObject.isReadOnly();
     }
 
     @Override
     public void setReadOnly(boolean readOnly) {
         delegateObject.setReadOnly(readOnly);
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean isNewCode() {
         return delegateObject.isNewCode();
     }
 
     /** {@inheritDoc} */
     @Override
     public void setNewCode(boolean newCode) {
         delegateObject.setNewCode(newCode);
     }
 
     @Override
     public boolean isDepartmentHermetic() {
         return delegateObject.isDepartmentHermetic();
     }
 
     @Override
     public void setDepartmentHermetic(boolean departmentHermetic) {
         delegateObject.setDepartmentHermetic(departmentHermetic);
     }
 
     @Override
     public Date getCreationDate() {
         return delegateObject.getCreationDate();
     }
 
     @Override
     public void setCreationDate(Date date) {
         delegateObject.setCreationDate(date);
     }
 
     @Override
     public Date getUpdateDate() {
         return delegateObject.getUpdateDate();
     }
 
     @Override
     public void setUpdateDate(Date date) {
         delegateObject.setUpdateDate(date);
     }
 
 
 }